/*
 *
 *    Copyright (c) 2014-2017 Nest Labs, Inc.
 *    All rights reserved.
 *
 *    Licensed under the Apache License, Version 2.0 (the "License");
 *    you may not use this file except in compliance with the License.
 *    You may obtain a copy of the License at
 *
 *        http://www.apache.org/licenses/LICENSE-2.0
 *
 *    Unless required by applicable law or agreed to in writing, software
 *    distributed under the License is distributed on an "AS IS" BASIS,
 *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *    See the License for the specific language governing permissions and
 *    limitations under the License.
 */

/**
 *    @file
 *      This file contains headers for the TunnelAgent module that coordinates routing between
 *      peripheral networks and the Nest Service within the Border Gateway and Mobile devices.
 *
 */

#ifndef _WEAVE_TUNNEL_AGENT_H_
#define _WEAVE_TUNNEL_AGENT_H_

#include <Weave/Core/WeaveCore.h>
#include <Weave/Profiles/weave-tunneling/WeaveTunnelCommon.h>
#include <Weave/Profiles/weave-tunneling/WeaveTunnelConnectionMgr.h>
#include <Weave/Profiles/service-directory/ServiceDirectory.h>

#if WEAVE_CONFIG_ENABLE_TUNNELING

#define TUN_DEFAULT_INTF_NAME                 "weav-tun0"
#define PRIMARY_TUNNEL_DEFAULT_INTF_NAME      "wlan0"
#define BACKUP_TUNNEL_DEFAULT_INTF_NAME       "ppp0"
#define TUN_INTF_NAME_MAX_LEN                 (64)
#define WEAVE_ULA_FABRIC_DEFAULT_PREFIX_LEN   (48)

#define TUNNEL_PACKET_QUEUE_INVALID_INDEX     (-1)

namespace nl {
namespace Weave {
namespace Profiles {
namespace WeaveTunnel {

#if WEAVE_CONFIG_ENABLE_SERVICE_DIRECTORY
using namespace ::nl::Weave::Profiles::ServiceDirectory;
#endif

class WeaveTunnelConnectionMgr;

/// Platform provided Weave Addressing and Routing routines
namespace Platform {
    /**
     *  @brief
     *    The set of states for Weave tunnel availability.
     */
    typedef enum TunnelAvailabilityMode
    {
        kMode_Primary           = 1,  /**< Set when the Weave Service Tunnel is available over the primary interface */
        kMode_PrimaryAndBackup  = 2,  /**< Set when the Weave Service Tunnel is available over both priary and backup interface */
        kMode_BackupOnly        = 3,  /**< Set when the Weave Service Tunnel is available over the backup interface only */
    } TunnelAvailabilityMode;

    // Following APIs must be implemented by platform:

    // Perform address/route assignment tasks when the Weave tunnel interface is brought up.

    extern void TunnelInterfaceUp(InterfaceId tunIf);

    // Perform address/route deletion tasks when the Weave tunnel interface is brought down.

    extern void TunnelInterfaceDown(InterfaceId tunIf);

    // Perform address/route assignment tasks when the Service tunnel connection is established.

    extern void ServiceTunnelEstablished(InterfaceId tunIf, TunnelAvailabilityMode tunMode);

    // Perform address and route assignment tasks when the Service tunnel connection is torn down.

    extern void ServiceTunnelDisconnected(InterfaceId tunIf);

    /// Perform address and route assignment tasks when the Service tunnel connection avalability state
    /// changes.

    extern void ServiceTunnelModeChange(InterfaceId tunIf, TunnelAvailabilityMode tunMode);

} // namespace Platform

#if WEAVE_CONFIG_TUNNEL_ENABLE_STATISTICS
/**
 *  This structure contains the relevant statistics counters that is common
 *  to the Primary and Backup Tunnels
 */
typedef struct WeaveTunnelCommonStatistics
{
    uint64_t     mTxBytesToService;                                        /**< Number of bytes transmitted to the Service. */
    uint64_t     mRxBytesFromService;                                      /**< Number of bytes received from the Service. */
    uint32_t     mTxMessagesToService;                                     /**< Number of messages transmitted to the Service. */
    uint32_t     mRxMessagesFromService;                                   /**< Number of messages received from the Service. */
    uint32_t     mTunnelDownCount;                                         /**< Counter for the Weave Tunnel Down events. */
    uint32_t     mTunnelConnAttemptCount;                                  /**< Counter for the Weave Tunnel Connection attempts. */
    WEAVE_ERROR  mLastTunnelDownError;                                     /**< The Weave error encountered when the tunnel last went down. */
    uint64_t     mLastTimeTunnelWentDown;                                  /**< Last time Weave Tunnel went Down. */
    uint64_t     mLastTimeTunnelEstablished;                               /**< Last time Weave Tunnel was Established. */
} WeaveTunnelCommonStatistics;

/**
 *  This structure contains the relevant statistics counters for the WeaveTunnel.
 */
typedef struct WeaveTunnelStatistics
{
    WeaveTunnelCommonStatistics mPrimaryStats;                             /**< Primary Weave Tunnel statistics counters. */
    uint32_t     mDroppedMessagesCount;                                    /**< Number of dropped messages by the WeaveTunnelAgent. */
    TunnelType   mCurrentActiveTunnel;                                     /**< The Weave tunnel that is currently being used for data traffic. */
#if WEAVE_CONFIG_TUNNEL_FAILOVER_SUPPORTED
    WeaveTunnelCommonStatistics mBackupStats;                              /**< Backup Weave Tunnel statistics counters. */
    uint32_t     mTunnelFailoverCount;                                     /**< Counter for the Weave Tunnel Failover events. */
    WEAVE_ERROR  mLastTunnelFailoverError;                                 /**< The Weave error encountered when the tunnel last failed over from Primary to Backup. */
    uint64_t     mLastTimeForTunnelFailover;                               /**< Last time Weave Tunnel failed over to Backup. */
    uint64_t     mLastTimeWhenPrimaryAndBackupWentDown;                    /**< Last time when both Primary and Backup Weave Tunnel went down. */
#endif // WEAVE_CONFIG_TUNNEL_FAILOVER_SUPPORTED
} WeaveTunnelStatistics;
#endif // WEAVE_CONFIG_TUNNEL_ENABLE_STATISTICS

class WeaveTunnelAgent
{
  friend class WeaveTunnelControl;
  friend class WeaveTunnelConnectionMgr;

public:

/// States of the Tunnel Agent in relation to its connection(s) to
/// the Service;
    typedef enum AgentState
    {
        kState_NotInitialized                      = 0, ///<Used to indicate that the Tunnel Agent is not initialized.
        kState_Initialized_NoTunnel                = 1, ///<Used to indicate that the Tunnel Agent is initialized but no tunnel has been established.
        kState_PrimaryTunModeEstablished           = 2, ///<Used to indicate that the Primary tunnel to the Service has been established.
        kState_BkupOnlyTunModeEstablished          = 3, ///<Used to indicate that the Backup tunnel to the Service has been established.
        kState_PrimaryAndBkupTunModeEstablished    = 4, ///<Used to indicate that both the Primary and the Backup tunnel has been established.
    } AgentState;

/// Weave Tunnel flag bits.
    typedef enum WeaveTunnelFlags
    {
        kTunnelFlag_PrimaryEnabled  = 0x01,  ///< Set when the primary tunnel is enabled.
        kTunnelFlag_BackupEnabled   = 0x02,  ///< Set when the backup tunnel is enabled.
    } WeaveTunnelFlags;

#if WEAVE_CONFIG_ENABLE_SERVICE_DIRECTORY
/// Service Manager pointer to use to lookup and connect to Service.
    WeaveServiceManager *mServiceMgr;
#endif

    WeaveTunnelAgent(void);

#if WEAVE_CONFIG_ENABLE_SERVICE_DIRECTORY
/**
 * Initialize the Tunnel agent. This creates te Tunnel endpoint object, sets up the tunnel
 * interface, initializes member variables, callbacks and WeaveTunnelControl.
 */
    WEAVE_ERROR Init(InetLayer *inet, WeaveExchangeManager *exchMgr,
                     uint64_t dstNodeId, WeaveAuthMode authMode,
                     WeaveServiceManager *svcMgr,
                     const char *intfName = TUN_DEFAULT_INTF_NAME,
                     uint8_t role = kClientRole_BorderGateway,
                     void *appContext = NULL);
#endif

/**
 * Initialize the Tunnel agent. This creates te Tunnel endpoint object, sets up the tunnel
 * interface, initializes member variables, callbacks and WeaveTunnelControl.
 */
    WEAVE_ERROR Init(InetLayer *inet, WeaveExchangeManager *exchMgr,
                     uint64_t dstNodeId, IPAddress dstIPAddr, WeaveAuthMode authMode,
                     const char *intfName = TUN_DEFAULT_INTF_NAME,
                     uint8_t role = kClientRole_BorderGateway,
                     void *appContext = NULL);

/**
 * Set the WeaveAuthMode for the Tunnel.
 *
 */
    void SetAuthMode(const WeaveAuthMode authMode);

/**
 * Set the destination nodeId, IPAddress and port for the Tunnel.
 *
 */
    void SetDestination(const uint64_t nodeId, const IPAddress ipAddr,
                        const uint16_t servicePort = WEAVE_PORT);

/**
 * Set the Tunneling device role(BorderGateway, StandaloneDevice, MobileDevice) for the Tunnel.
 *
 */
    void SetTunnelingDeviceRole(const Role role);

/**
 * Get the TunnelAgent state.
 *
 */
    AgentState GetWeaveTunnelAgentState(void);

#if WEAVE_CONFIG_TUNNEL_TCP_USER_TIMEOUT_SUPPORTED
/**
 *  Configure the TCP user timeout option on the primary tunnel connection.
 */
    WEAVE_ERROR ConfigurePrimaryTunnelTimeout(uint16_t maxTimeoutSecs);
#endif // WEAVE_CONFIG_TUNNEL_TCP_USER_TIMEOUT_SUPPORTED

#if WEAVE_CONFIG_TUNNEL_TCP_KEEPALIVE_SUPPORTED
/**
 *  Configure and enable the TCP keepalive option on the primary
 *  tunnel connection.
 */
    WEAVE_ERROR ConfigureAndEnablePrimaryTunnelTCPKeepAlive(uint16_t keepAliveIntervalSecs,
                                                            uint16_t maxNumProbes);
#endif // WEAVE_CONFIG_TUNNEL_TCP_KEEPALIVE_SUPPORTED

#if WEAVE_CONFIG_TUNNEL_LIVENESS_SUPPORTED
/**
 * Configure the Primary Tunnel Liveness interval.
 */
    void ConfigurePrimaryTunnelLivenessInterval(uint16_t livenessIntervalSecs);
#endif // WEAVE_CONFIG_TUNNEL_LIVENESS_SUPPORTED
/**
 *  Check if the primary tunnel is enabled.
 */
    bool IsPrimaryTunnelEnabled(void) const;

/**
 * Enable Primary Tunnel.
 */
    void EnablePrimaryTunnel(void);

/**
 * Disable Primary Tunnel.
 */
    void DisablePrimaryTunnel(void);

#if WEAVE_CONFIG_TUNNEL_FAILOVER_SUPPORTED

/**
 *  Check if the backup tunnel is enabled.
 */
    bool IsBackupTunnelEnabled(void) const;

/**
 * Enable Backup Tunnel.
 */
    void EnableBackupTunnel(void);

/**
 * Disable Backup Tunnel.
 */
    void DisableBackupTunnel(void);

/**
 * Start Primary Tunnel.
 */
    void StartPrimaryTunnel(void);

/**
 * Stop Primary Tunnel.
 */
    void StopPrimaryTunnel(void);

/**
 * Start Backup Tunnel.
 */
    void StartBackupTunnel(void);

/**
 * Stop Backup Tunnel.
 */
    void StopBackupTunnel(void);

#if WEAVE_CONFIG_TUNNEL_TCP_USER_TIMEOUT_SUPPORTED
/**
 *  Configure the TCP user timeout option on the backup tunnel connection.
 */
    WEAVE_ERROR ConfigureBackupTunnelTimeout(uint16_t maxTimeoutSecs);
#endif // WEAVE_CONFIG_TUNNEL_TCP_USER_TIMEOUT_SUPPORTED

#if WEAVE_CONFIG_TUNNEL_TCP_KEEPALIVE_SUPPORTED
/**
 *  Configure and enable the TCP keepalive option on the backup
 *  tunnel connection.
 */
    WEAVE_ERROR ConfigureAndEnableBackupTunnelTCPKeepAlive(uint16_t keepAliveIntervalSecs,
                                                           uint16_t maxNumProbes);
#endif // WEAVE_CONFIG_TUNNEL_TCP_KEEPALIVE_SUPPORTED

#if WEAVE_CONFIG_TUNNEL_LIVENESS_SUPPORTED
/**
 * Configure the Backup Tunnel Liveness interval.
 */
    void ConfigureBackupTunnelLivenessInterval(uint16_t livenessIntervalSecs);
#endif // WEAVE_CONFIG_TUNNEL_LIVENESS_SUPPORTED

/**
 * Set the primary tunnel interface name
 *
 */
    void SetPrimaryTunnelInterface(const char *primaryIntfName);

/**
 * Set the backup tunnel interface name
 *
 */
    void SetBackupTunnelInterface(const char *backupIntfName);

/**
 * Set the primary tunnel interface type
 *
 */
    void SetPrimaryTunnelInterfaceType(const SrcInterfaceType primaryIntfType);

/**
 * Set the backup tunnel interface type
 *
 */
    void SetBackupTunnelInterfaceType(const SrcInterfaceType backupIntfType);

#endif // WEAVE_CONFIG_TUNNEL_FAILOVER_SUPPORTED

/**
 * Shutdown the Tunnel Agent. This tears down connection to the Service and closes the TunEndPoint
 * interface after removing addresses and routes associated with the tunnel interface.
 */
    WEAVE_ERROR Shutdown(void);

/**
 * Start the Service Tunnel. This enables the tunnel and tries to establish a connection
 * to the Service.
 */
    WEAVE_ERROR StartServiceTunnel(void);

/**
 * Start the Service Tunnel. This enables the tunnel and tries to establish a connection
 * to the Service.
 */
    WEAVE_ERROR StartServiceTunnel(uint64_t dstNodeId,
                                   IPAddress dstIPAddr,
                                   WeaveAuthMode authMode);

/**
 * Close the Tunnel connection to the Service.
 */
    void StopServiceTunnel(void);

/**
 * Close the Tunnel connection to the Service.
 */
    void StopServiceTunnel(WEAVE_ERROR err);

#if WEAVE_CONFIG_TUNNEL_ENABLE_STATISTICS
/**
 * Get the WeaveTunnel statistics counters.
 *
 * @param[out] tunnelStats  A reference to the WeaveTunnelStatistics structure.
 *
 * @return WEAVE_ERROR  Weave error encountered when getting tunnel statistics.
 */
   WEAVE_ERROR GetWeaveTunnelStatistics(WeaveTunnelStatistics &tunnelStats);
#endif // WEAVE_CONFIG_TUNNEL_ENABLE_STATISTICS

/**
 * Function pointer to handler set by a higher layer to act upon various notifications related to
 * the tunnel to the Service.
 *
 * @param[in] reason        The reason for the status notification to the application.
 *
 * @param[in] err           Weave error encountered, if any
 *
 * @param[in] appCtxt       A pointer to an application context object
 *
 * @return void.
 */
    typedef void (*OnServiceTunnelStatusNotifyFunct)(WeaveTunnelConnectionMgr::TunnelConnNotifyReasons reason,
                                                     WEAVE_ERROR err, void *appCtxt);

/**
 * Function pointer to handler set by a higher layer to act upon various notifications related to
 * the tunnel to the Service.
 *
 */
    OnServiceTunnelStatusNotifyFunct OnServiceTunStatusNotify;

/**
 * Function pointer to handler set by a higher layer when a Tunnel Reconnect is received from the Service
 *
 * @param[in] tunType          The tunnel type, Primary or Backup.
 *
 * @param[in] reconnectHost    The hostname provided by Service to reconnect to.
 *
 * @param[in] reconnectPort    The destination port provided by Service to reconnect to.
 *
 * @param[in] appCtxt       A pointer to an application context object
 *
 * @return void.
 */
    typedef void (*OnServiceTunnelReconnectNotifyFunct)(TunnelType tunType,
                                                        const char *reconnectHost,
                                                        const uint16_t reconnectPort,
                                                        void *appCtxt);

    OnServiceTunnelReconnectNotifyFunct OnServiceTunReconnectNotify;

#if WEAVE_CONFIG_TUNNEL_ENABLE_TRANSIT_CALLBACK
/**
 * Function pointer to handler set by a higher layer to decode and log contents of IP packets.
 *
 * @param[in] pkt         A const reference to an IP packet buffer.
 *
 * @param[in] direction   The direction of the tunneled packet(inbound or outbound).
 *
 * @param[in] type        The type of the Tunnel.
 *
 * @param[out] toDrop     indicates whether the packet needs to be dropped based on some application policy.
 *
 * @return void.
 */
    typedef void (*OnPacketTransitFunct)(const PacketBuffer &pkt,
                                         nl::Weave::Profiles::WeaveTunnel::TunnelPktDirection direction,
                                         nl::Weave::Profiles::WeaveTunnel::TunnelType type, bool &toDrop);

    OnPacketTransitFunct OnTunneledPacketTransit;

#endif // WEAVE_CONFIG_TUNNEL_ENABLE_TRANSIT_CALLBACK

/**
 * Handler to receive IPv6 packets from the Tunnel EndPoint interface and forward, either to the Service
 * via the Service TCP connection after encapsulating IPv6 packet inside the tunnel header or to the Mobile
 * client over a shortcut tunnel. If the Service connection is not yet up, the message is queued until the
 * connection is set up. For tunneling to the Mobile client device, the nexthop neighbor table is referenced.
 */
    static void RecvdFromTunnelEndPoint(TunEndPoint *tunEP, PacketBuffer *message);

/**
 * Handler to receive tunneled IPv6 packets over the shortcut UDP tunnel between the border gateway and the mobile
 * device and forward to the Tunnel EndPoint interface after decapsulating the raw IPv6 packet from inside the
 * tunnel header.
 */
    static void RecvdFromShortcutUDPTunnel (WeaveMessageLayer *msgLayer, PacketBuffer *message);

/**
 * Get the WeaveTunnelAgentState name
 *
 */
    const char *GetAgentStateName(const AgentState state);

/**
 * Get the system time in milliseconds
 *
 */
    uint64_t GetTimeMsec(void);
private:

    // Node Id of the Service endpoint

    uint64_t mPeerNodeId;

    // IP address of the Service endpoint

    IPAddress mServiceAddress;

    // Port of the Service endpoint

    uint16_t mServicePort;

    // Authentication mode to be used

    WeaveAuthMode mAuthMode;

    // Queued messages for Service; pending until connection established.

    PacketBuffer *queuedMsgs[WEAVE_CONFIG_TUNNELING_MAX_NUM_PACKETS_QUEUED];
    int qFront, qRear;

    // Role; Border gateway or Mobile device

    uint8_t mRole;

    // Flag for enabling/disabling specific Tunnel

    uint8_t mTunnelFlags;

    InetLayer *mInet;                       // Associated InetLayer object

#if !WEAVE_SYSTEM_CONFIG_USE_LWIP
    // Interface name of TunEndPoint

    char mIntfName[TUN_INTF_NAME_MAX_LEN];
#endif // !WEAVE_SYSTEM_CONFIG_USE_LWIP

    TunEndPoint *mTunEP;

    // Handle to the WeaveExchangeManager object.

    WeaveExchangeManager *mExchangeMgr;

    // Weave Tunnel Connection Manager object for the Primary tunnel

    WeaveTunnelConnectionMgr mPrimaryTunConnMgr;

#if WEAVE_CONFIG_TUNNEL_FAILOVER_SUPPORTED
    // Weave Tunnel Connection Manager object for the Backup tunnel

    WeaveTunnelConnectionMgr mBackupTunConnMgr;
#endif

#if WEAVE_CONFIG_TUNNEL_SHORTCUT_SUPPORTED
    // Weave Tunnel Control for Tunnel shortcut

    WeaveTunnelControl mTunShortcutControl;
#endif

    // WeaveTunnelAgent state

    AgentState  mTunAgentState;

    // Application context
    void *mAppContext;

#if WEAVE_CONFIG_TUNNEL_ENABLE_STATISTICS
    WeaveTunnelStatistics mWeaveTunnelStats;

    void UpdateOutboundMessageStatistics(const TunnelType tunType, const uint64_t msgLen);
    void UpdateTunnelDownStatistics(const TunnelType tunType, const WEAVE_ERROR conErr);
    WeaveTunnelCommonStatistics *GetCommonTunnelStatistics(const TunnelType tunType);
#endif // WEAVE_CONFIG_TUNNEL_ENABLE_STATISTICS

    void SetState(AgentState toState);
    // TunEndPoint management functions

    WEAVE_ERROR CreateTunEndPoint(void);
    WEAVE_ERROR SetupTunEndPoint(void);
    WEAVE_ERROR TeardownTunEndPoint(void);

    // Tunnel management and maintenance functions

    WEAVE_ERROR ConfigureAndInit (InetLayer *inet, WeaveExchangeManager *exchMgr,
                                  uint64_t dstNodeId, IPAddress dstIPAddr, WeaveAuthMode authMode,
#if WEAVE_CONFIG_ENABLE_SERVICE_DIRECTORY
                                  WeaveServiceManager *svcMgr,
#endif
                                  const char *intfName, uint8_t role, void *appContext);

    // Message encapsulating/decapsulating functions for sending between Tunnel and other interfaces

    WEAVE_ERROR AddTunnelHdrToMsg(PacketBuffer *msg);
    WEAVE_ERROR HandleSendingToService(PacketBuffer *msg);
    WEAVE_ERROR HandleTunneledReceive(PacketBuffer *msg, TunnelType tunType);

    /// Decide based on lookup of nexthop table and send locally
    /// via UDP tunnel or remotely via Service TCP connection.

    WEAVE_ERROR DecideAndSendShortcutOrRemoteTunnel(uint64_t nodeId, PacketBuffer *msg);

    void PopulateTunnelMsgHeader(WeaveMessageInfo *msgInfo, const WeaveTunnelConnectionMgr *connMgr);

    void ParseDestinationIPAddress(const PacketBuffer &inMsg, IPAddress &outDest);

    WEAVE_ERROR SendMessageUponPktTransitAnalysis(const WeaveTunnelConnectionMgr *connMgr,
                                                  TunnelPktDirection pktDir,
                                                  TunnelType tunType,
                                                  WeaveMessageInfo *msgInfo,
                                                  PacketBuffer *msg,
                                                  bool &dropPacket);

    static void ServiceMgrStatusHandler(void* appState, WEAVE_ERROR err, StatusReport *report);

    // Service queue management functions

    void SendQueuedMessages(const WeaveTunnelConnectionMgr *connMgr);
    WEAVE_ERROR EnQueuePacket(PacketBuffer *pkt);
    PacketBuffer *DeQueuePacket(void);
    void DumpQueuedMessages(void);

    // Tunnel Control post-processing functions

    void WeaveTunnelConnectionUp(const WeaveMessageInfo *msgInfo,
                                 const WeaveTunnelConnectionMgr *connMgr,
                                 const bool isRoutingRestricted);
    void WeaveTunnelConnectionDown(const WeaveTunnelConnectionMgr *connMgr, WEAVE_ERROR conErr);
    void WeaveTunnelServiceReconnectRequested(const WeaveTunnelConnectionMgr *connMgr,
                                              const char *redirectHost, const uint16_t redirectPort);
    void WeaveTunnelDownNotifyAndSetState(WEAVE_ERROR conErr);
    void WeaveTunnelUpNotifyAndSetState(AgentState state,
                                        Platform::TunnelAvailabilityMode tunMode,
                                        WeaveTunnelConnectionMgr::TunnelConnNotifyReasons notifyReason,
                                        WeaveTunnelConnectionMgr *connMgr,
                                        const bool isRoutingRestricted);
    void RemovePlatformTunnelRoute(void);

#if WEAVE_CONFIG_TUNNEL_FAILOVER_SUPPORTED
    void WeaveTunnelModeChangeNotifyAndSetState(AgentState state,
                                                Platform::TunnelAvailabilityMode tunMode,
                                                WeaveTunnelConnectionMgr::TunnelConnNotifyReasons notifyReason,
                                                WEAVE_ERROR conErr);
#endif // WEAVE_CONFIG_TUNNEL_FAILOVER_SUPPORTED
    void WeaveTunnelConnectionErrorNotify(const WeaveTunnelConnectionMgr *connMgr, WEAVE_ERROR conErr);

#if WEAVE_CONFIG_TUNNEL_LIVENESS_SUPPORTED
    void RestartTunnelLivenessTimer(TunnelType tunType);

    void NotifyTunnelLiveness(TunnelType tunType, WEAVE_ERROR err);
#endif // WEAVE_CONFIG_TUNNEL_LIVENESS_SUPPORTED

};


} // namespace WeaveTunnel
} // namespace Profiles
} // namespace Weave
} // namespace nl
#endif // WEAVE_CONFIG_ENABLE_TUNNELING
#endif// _WEAVE_TUNNEL_AGENT_H_