/*
 *
 *    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 implements the Weave Tunnel Connection Manager that
 *      manages the connection state machine.
 *
 */
#ifndef __STDC_FORMAT_MACROS
#define __STDC_FORMAT_MACROS
#endif

#include <Weave/Profiles/weave-tunneling/WeaveTunnelConnectionMgr.h>

#include <Weave/Profiles/weave-tunneling/WeaveTunnelAgent.h>
#include <Weave/Profiles/weave-tunneling/WeaveTunnelCommon.h>

#include <Weave/Support/CodeUtils.h>
#include <Weave/Support/RandUtils.h>
#include <Weave/Support/FibonacciUtils.h>
#include <SystemLayer/SystemTimer.h>

#if WEAVE_CONFIG_ENABLE_TUNNELING

using namespace nl::Inet;
using namespace nl::Weave::Profiles::WeaveTunnel;
using namespace nl::Weave::Profiles::StatusReporting;

using nl::Weave::System::PacketBuffer;

WeaveTunnelConnectionMgr::WeaveTunnelConnectionMgr(void)
{
    mConnectionState            = kState_NotConnected;
    mServiceCon                 = NULL;
    mTunFailedConnAttemptsInRow = 0;
}

/*
 * Initialize the WeaveTunnelConnectionMgr.
 *
 * @param[in] tunAgent              A pointer to the WeaveTunnelAgent object.
 *
 * @return WEAVE_NO_ERROR unconditionally.
 */
WEAVE_ERROR WeaveTunnelConnectionMgr::Init(WeaveTunnelAgent *tunAgent,
                                           TunnelType tunType,
                                           SrcInterfaceType srcIntfType,
                                           const char *connIntfName)
{
    WEAVE_ERROR err                   = WEAVE_NO_ERROR;

    // Check if the WeaveTunnelAgent object is valid.

    VerifyOrExit(tunAgent != NULL, err = WEAVE_ERROR_INVALID_ARGUMENT);

    mTunAgent                         = tunAgent;
    mConnectionState                  = kState_NotConnected;
    mServiceCon                       = NULL;
    mTunFailedConnAttemptsInRow       = 0;
    mTunType                          = tunType;
    mSrcInterfaceType                 = srcIntfType;
    mMaxFailedConAttemptsBeforeNotify = WEAVE_CONFIG_TUNNELING_MAX_NUM_CONNECT_BEFORE_NOTIFY;
    mServiceConnDelayPolicyCallback   = DefaultReconnectPolicyCallback;
    if (connIntfName)
    {
        strncpy(mServiceConIntf, connIntfName, sizeof(mServiceConIntf) - 1);
        mServiceConIntf[sizeof(mServiceConIntf) - 1] = '\0';
    }
    else
    {
        mServiceConIntf[0] = '\0';
    }

    // Configure default values for TCP User timeout, TCP KeepAlives, and
    // Tunnel Liveness.

    if (tunType == kType_TunnelPrimary)
    {
#if WEAVE_CONFIG_TUNNEL_TCP_USER_TIMEOUT_SUPPORTED
        mMaxUserTimeoutSecs           = WEAVE_CONFIG_PRIMARY_TUNNEL_MAX_TIMEOUT_SECS;
#endif // WEAVE_CONFIG_TUNNEL_TCP_USER_TIMEOUT_SUPPORTED

#if WEAVE_CONFIG_TUNNEL_TCP_KEEPALIVE_SUPPORTED
        mKeepAliveIntervalSecs        = WEAVE_CONFIG_PRIMARY_TUNNEL_KEEPALIVE_INTERVAL_SECS;
#endif // WEAVE_CONFIG_TUNNEL_TCP_KEEPALIVE_SUPPORTED

#if WEAVE_CONFIG_TUNNEL_LIVENESS_SUPPORTED
        mTunnelLivenessInterval       = WEAVE_CONFIG_PRIMARY_TUNNEL_LIVENESS_INTERVAL_SECS;
#endif // WEAVE_CONFIG_TUNNEL_LIVENESS_SUPPORTED
    }
    else
    {
#if WEAVE_CONFIG_TUNNEL_TCP_USER_TIMEOUT_SUPPORTED
        mMaxUserTimeoutSecs           = WEAVE_CONFIG_BACKUP_TUNNEL_MAX_TIMEOUT_SECS;
#endif // WEAVE_CONFIG_TUNNEL_TCP_USER_TIMEOUT_SUPPORTED

#if WEAVE_CONFIG_TUNNEL_TCP_KEEPALIVE_SUPPORTED
        mKeepAliveIntervalSecs        = WEAVE_CONFIG_BACKUP_TUNNEL_KEEPALIVE_INTERVAL_SECS;
#endif // WEAVE_CONFIG_TUNNEL_TCP_KEEPALIVE_SUPPORTED

#if WEAVE_CONFIG_TUNNEL_LIVENESS_SUPPORTED
        mTunnelLivenessInterval       = WEAVE_CONFIG_BACKUP_TUNNEL_LIVENESS_INTERVAL_SECS;
#endif // WEAVE_CONFIG_TUNNEL_LIVENESS_SUPPORTED
    }

#if WEAVE_CONFIG_TUNNEL_TCP_KEEPALIVE_SUPPORTED
    mMaxNumProbes                     = WEAVE_CONFIG_TUNNEL_MAX_KEEPALIVE_PROBES;
#endif // WEAVE_CONFIG_TUNNEL_TCP_KEEPALIVE_SUPPORTED

    // Initialize WeaveTunnelControl

    err = mTunControl.Init(mTunAgent);
    SuccessOrExit(err);

exit:
    return err;
}

/**
 * Shutdown the WeaveTunnelConnectionMgr.
 *
 */
void WeaveTunnelConnectionMgr::Shutdown(void)
{

    // Close the Tunnel Control

    mTunControl.Close();

    // Reset the handle to the TunnelAgent and the Service connection objects.
    mTunAgent = NULL;
    mServiceCon = NULL;

}

/**
 * Set InterfaceName for Tunnel connection.
 *
 * @param[in] tunIntf              The InterfaceName for setting the Service tunnel connection.
 *
 */
void WeaveTunnelConnectionMgr::SetInterfaceName(const char *tunIntf)
{
    if (tunIntf)
    {
        strncpy(mServiceConIntf, tunIntf, sizeof(mServiceConIntf) - 1);
        mServiceConIntf[sizeof(mServiceConIntf) - 1] = '\0';
    }
}

/**
 * Set SrcInterfaceType for Tunnel connection.
 *
 * @param[in] srcIntfType          The network technology type of the interface for Service tunnel connection.
 */
void WeaveTunnelConnectionMgr::SetInterfaceType (const SrcInterfaceType srcIntfType)
{
    mSrcInterfaceType    = srcIntfType;
}

#if WEAVE_CONFIG_TUNNEL_TCP_USER_TIMEOUT_SUPPORTED

/**
 * Configure the TCP user timeout.
 *
 * @param[in]  maxTimeoutSecs
 *    The maximum timeout for the TCP connection.
 *
 *
 *  @retval  #WEAVE_NO_ERROR                     on successful enabling of TCP User Timeout
 *                                               on the connection.
 *  @retval  #WEAVE_ERROR_INCORRECT_STATE        if the WeaveConnection object is not
 *                                               in the correct state for sending messages.
 *  @retval  other Inet layer errors related to TCP endpoint setting the user timeout option.
 */
WEAVE_ERROR WeaveTunnelConnectionMgr::ConfigureConnTimeout(uint16_t maxTimeoutSecs)
{
    WEAVE_ERROR err = WEAVE_NO_ERROR;

    err = mServiceCon->SetUserTimeout(maxTimeoutSecs * nl::Weave::System::kTimerFactor_milli_per_unit);
    if (err == INET_ERROR_NOT_IMPLEMENTED)
    {
        err = WEAVE_NO_ERROR;
    }
    VerifyOrExit(err == WEAVE_NO_ERROR,
                 WeaveLogDetail(WeaveTunnel,
                               "Error setting TCP user timeout: %d", err);
                );

    // Now set the member configurations

    mMaxUserTimeoutSecs    = maxTimeoutSecs;

exit:
    return err;
}
#endif // WEAVE_CONFIG_TUNNEL_TCP_USER_TIMEOUT_SUPPORTED

#if WEAVE_CONFIG_TUNNEL_TCP_KEEPALIVE_SUPPORTED
/**
 * Configure and Enable the TCP KeepAlive for the tunnel.
 *
 * @param[in]  keepAliveIntervalSecs
 *    The TCP keepalive interval in seconds.
 *
 * @param[in]  maxNumProbes
 *    The maximum number of TCP keepalive probes.
 *
 *  @retval  #WEAVE_NO_ERROR                     on successful enabling of TCP keepalive probes
 *                                               on the connection.
 *  @retval  #WEAVE_ERROR_INCORRECT_STATE        if the WeaveConnection object is not
 *                                               in the correct state for sending messages.
 *  @retval  other Inet layer errors related to the TCP endpoint enable keepalive operation.
 */
WEAVE_ERROR WeaveTunnelConnectionMgr::ConfigureAndEnableTCPKeepAlive(uint16_t intervalSecs, uint16_t maxNumProbes)
{
    WEAVE_ERROR err = WEAVE_NO_ERROR;

    // Try enabling keepalive on the connection.

    err = mServiceCon->EnableKeepAlive(intervalSecs, maxNumProbes);
    SuccessOrExit(err);

    // Now set the member configurations

    mKeepAliveIntervalSecs = intervalSecs;
    mMaxNumProbes          = maxNumProbes;

exit:
    return err;
}
#endif // WEAVE_CONFIG_TUNNEL_TCP_KEEPALIVE_SUPPORTED

#if WEAVE_CONFIG_TUNNEL_LIVENESS_SUPPORTED
/**
 * Configure the Tunnel Liveness interval.
 */
void WeaveTunnelConnectionMgr::ConfigureTunnelLivenessInterval(uint16_t livenessIntervalSecs)
{
    mTunnelLivenessInterval = livenessIntervalSecs;
}
#endif // WEAVE_CONFIG_TUNNEL_LIVENESS_SUPPORTED

/**
 * Try to establish a connecttion to the Service either using
 * ServiceManager or directly
 *
 */
WEAVE_ERROR WeaveTunnelConnectionMgr::TryConnectingNow(void)
{
    WEAVE_ERROR err = WEAVE_NO_ERROR;
    InterfaceId connIntfId = INET_NULL_INTERFACEID;
#if WEAVE_CONFIG_TUNNEL_ENABLE_STATISTICS
    WeaveTunnelCommonStatistics *tunStats = NULL;
#endif // WEAVE_CONFIG_TUNNEL_ENABLE_STATISTICS

    WeaveLogDetail(WeaveTunnel, "TryConnectingNow on %s tunnel", mTunType == kType_TunnelPrimary?"primary":"backup");

    // Get the InterfaceId from the interface name.

    if (mServiceConIntf[0] != '\0')
    {
        // Get the InterfaceId from the interface name.

        err = InterfaceNameToId(mServiceConIntf, connIntfId);
        SuccessOrExit(err);
    }

#if WEAVE_CONFIG_ENABLE_SERVICE_DIRECTORY
    // Initiate TCP connection with Service.

    if (mTunAgent->mServiceMgr)
    {
        err = mTunAgent->mServiceMgr->connect(mTunAgent->mPeerNodeId,
                                              mTunAgent->mAuthMode, this,
                                              ServiceMgrStatusHandler,
                                              HandleServiceConnectionComplete,
                                              WEAVE_CONFIG_TUNNEL_CONNECT_TIMEOUT_SECS * nl::Weave::System::kTimerFactor_milli_per_unit,
                                              connIntfId);
    }
    else
#endif
    {
        err = StartServiceTunnelConn(mTunAgent->mPeerNodeId,
                                     mTunAgent->mServiceAddress,
                                     mTunAgent->mServicePort,
                                     mTunAgent->mAuthMode,
                                     connIntfId);
    }

    SuccessOrExit(err);

    // Change the connection state to connecting.

    mConnectionState = kState_Connecting;

#if WEAVE_CONFIG_TUNNEL_ENABLE_STATISTICS
    // Update tunnel statistics
    tunStats = mTunAgent->GetCommonTunnelStatistics(mTunType);

    if (tunStats != NULL)
    {
        tunStats->mTunnelConnAttemptCount++;
    }
#endif // WEAVE_CONFIG_TUNNEL_ENABLE_STATISTICS
exit:
    return err;
}

/* Decide whether and how(fast or slow) to reconnect again to the Service */
void WeaveTunnelConnectionMgr::DecideOnReconnect(ReconnectParam &reconnParam)
{
    uint32_t delayMsecs;
    // Exit if we do not need to reconnect.

    if ((mTunType == kType_TunnelPrimary && !mTunAgent->IsPrimaryTunnelEnabled())
#if WEAVE_CONFIG_TUNNEL_FAILOVER_SUPPORTED
        ||
        (mTunType == kType_TunnelBackup && !mTunAgent->IsBackupTunnelEnabled())
#endif
       )
    {
        ExitNow();
    }

    // Fetch the backoff delay before connecting.
    mServiceConnDelayPolicyCallback(this, reconnParam, delayMsecs);

    // Retry connecting using a backoff mechanism  upto a maximum number of retries
    // before failover to a backup tunnel connection if one exists.
    //
    // For the first retry do not go to Service directory and reconnect
    // to the same IP address in cache but, thereafter, clear cache and
    // fetch hostname from Service directory before connecting.

    if (mTunFailedConnAttemptsInRow < mMaxFailedConAttemptsBeforeNotify)
    {
#if WEAVE_CONFIG_ENABLE_SERVICE_DIRECTORY
        if (mTunFailedConnAttemptsInRow > 1)
        {
            // Clear the Service directory cache

            if (mTunAgent->mServiceMgr)
            {
                mTunAgent->mServiceMgr->clearCache();
            }
        }
#endif
        // Try to reconnect with Service.

        ScheduleConnect(delayMsecs);
    }
    else
    {
        ResetCacheAndScheduleConnect(delayMsecs);
    }

    // Notify application appropriately

    if  (mTunFailedConnAttemptsInRow == mMaxFailedConAttemptsBeforeNotify)
    {
        // Notify about Tunnel down or failover.

        mTunAgent->WeaveTunnelConnectionDown(this, reconnParam.mLastConnectError);
    }
    else
    {
        // Notify connection error

        mTunAgent->WeaveTunnelConnectionErrorNotify(this, reconnParam.mLastConnectError);
    }

exit:
    return;
}

/* Handler for reconnecting to the Service after wait period timeout */
void WeaveTunnelConnectionMgr::ServiceConnectTimeout(System::Layer* aSystemLayer, void* aAppState, System::Error aError)
{
    ReconnectParam reconnParam;
    WeaveTunnelConnectionMgr* tConnMgr = static_cast<WeaveTunnelConnectionMgr*>(aAppState);

    // Exit if we do not need to reconnect.
    // We need to check to evaluate if, in the meantime, the application has disabled
    // the Tunnel(by a call to DisablePrimaryTunnel() or DisableBackupTunnel()) or not.

    if ((tConnMgr->mTunType == kType_TunnelPrimary && !tConnMgr->mTunAgent->IsPrimaryTunnelEnabled())
#if WEAVE_CONFIG_TUNNEL_FAILOVER_SUPPORTED
        ||
        (tConnMgr->mTunType == kType_TunnelBackup && !tConnMgr->mTunAgent->IsBackupTunnelEnabled())
#endif
       )
    {
        ExitNow();
    }

    // Check the connection state; Make sure it is reset and in kState_NotConnected
    // state before connecting.

    if (tConnMgr->mConnectionState != kState_NotConnected)
    {
        tConnMgr->StopServiceTunnelConn(aError);
    }

    // Reconnect to Service.

    WeaveLogDetail(WeaveTunnel, "Connecting to node %" PRIx64 "\n",
                   tConnMgr->mTunAgent->mPeerNodeId);

    aError = tConnMgr->TryConnectingNow();

    if (aError != WEAVE_NO_ERROR)
    {
        reconnParam.PopulateReconnectParam(aError);

        tConnMgr->StopAndReconnectTunnelConn(reconnParam);
    }

exit:
    return;
}

/* Reset the address cache in the Service Directory and schedule a delayed reconnect. */
void WeaveTunnelConnectionMgr::ResetCacheAndScheduleConnect(uint32_t delay)
{
#if WEAVE_CONFIG_ENABLE_SERVICE_DIRECTORY
        // Reset the Service directory

    if (mTunAgent->mServiceMgr)
    {
        mTunAgent->mServiceMgr->clearCache();
    }
#endif

    ScheduleConnect(delay);
}

/* Schedule a reconnect timer */
void WeaveTunnelConnectionMgr::ScheduleConnect(uint32_t delay)
{
    mTunAgent->mExchangeMgr->MessageLayer->SystemLayer->StartTimer(delay, ServiceConnectTimeout, this);
}

void WeaveTunnelConnectionMgr::CancelDelayedReconnect(void)
{
    mTunAgent->mExchangeMgr->MessageLayer->SystemLayer->CancelTimer(ServiceConnectTimeout, this);
}

/* Start the connection to the Service */
WEAVE_ERROR WeaveTunnelConnectionMgr::StartServiceTunnelConn(uint64_t destNodeId, IPAddress destIPAddr,
                                                             uint16_t destPort,
                                                             WeaveAuthMode authMode,
                                                             InterfaceId connIntfId)
{
    WEAVE_ERROR err = WEAVE_NO_ERROR;

    if (mServiceCon != NULL && mConnectionState == kState_NotConnected)
    {
        // Remove previous connection(currently closed)

        mServiceCon->Close();
        mServiceCon = NULL;
    }

    // Do nothing if a connect attempt is already in progress.

    VerifyOrExit(mServiceCon == NULL, err = WEAVE_ERROR_INVALID_ARGUMENT);

    // Create a new WeaveConnection object

    mServiceCon = mTunAgent->mExchangeMgr->MessageLayer->NewConnection();

    VerifyOrExit(mServiceCon != NULL, err = WEAVE_ERROR_NO_MEMORY);

    // Setup connection handlers

    mServiceCon->OnConnectionComplete = HandleServiceConnectionComplete;

    // Set app state to WeaveTunnelConnectionMgr

    mServiceCon->AppState = this;

    // Set the connection timeout

    mServiceCon->SetConnectTimeout(WEAVE_CONFIG_TUNNEL_CONNECT_TIMEOUT_SECS * nl::Weave::System::kTimerFactor_milli_per_unit);

    err = mServiceCon->Connect(destNodeId, authMode, destIPAddr, destPort, connIntfId);

exit:
    return err;
}

/* Stop the connection to the Service */
void WeaveTunnelConnectionMgr::StopServiceTunnelConn(WEAVE_ERROR err)
{
    // Close connection to the Service

#if WEAVE_CONFIG_ENABLE_SERVICE_DIRECTORY
    if (mTunAgent->mServiceMgr)
    {
        mTunAgent->mServiceMgr->cancel(mTunAgent->mPeerNodeId, this);
    }
#endif

    if (mServiceCon)
    {
        if (err == WEAVE_NO_ERROR)
        {
            if (mServiceCon->Close() != WEAVE_NO_ERROR)
            {
                mServiceCon->Abort();
            }
        }
        else
        {
            mServiceCon->Abort();
        }

        mServiceCon = NULL;
    }

    mConnectionState = kState_NotConnected;
}

/**
 * Stop Service tunnel connection and attempt to reconnect again.
 *
 * @param[in]  err    A WEAVE_ERROR passed in from the caller.
 *
 */
void WeaveTunnelConnectionMgr::StopAndReconnectTunnelConn(ReconnectParam &reconnParam)
{
    StopServiceTunnelConn(reconnParam.mLastConnectError);

    // Attempt Reconnecting

    AttemptReconnect(reconnParam);
}

/**
 * Close the Service tunnel.
 *
 * @param[in]  err    A WEAVE_ERROR passed in from the caller.
 *
 * @note
 *   The WeaveTunnelConnectionMgr would attempt a graceful close by sending
 *   a Tunnel Close message to the Service if the tunnel is in the
 *   kState_TunnelOpen state; else it will close the TCP connection from its
 *   end.
 */
void WeaveTunnelConnectionMgr::ServiceTunnelClose(WEAVE_ERROR err)
{
    bool release = true;

    // Send a Tunnel Close control message

    if (mConnectionState == WeaveTunnelConnectionMgr::kState_TunnelOpen && err == WEAVE_NO_ERROR)
    {
        err = mTunControl.SendTunnelClose(this);
        if (err == WEAVE_NO_ERROR)
        {
            // Set the appropriate connection state to Closing.

            mConnectionState = WeaveTunnelConnectionMgr::kState_TunnelClosing;
            release = false;
        }
    }

    if (release)
    {
        // Release held resources(e.g., ExchangeContext, Timers) if any and stop tunnel connection.

        ReleaseResourcesAndStopTunnelConn(err);

        // Set the WeaveTunnelAgent state to tunnel disabled so that we do not reconnect.

        mTunAgent->WeaveTunnelConnectionDown(this, err);
    }

    // Reset the failed connection attempts in a row as tunnel is being disabled.

    mTunFailedConnAttemptsInRow = 0;

}

/**
 * Handler to receive tunneled IPv6 packets from the Service TCP connection and forward to the Tunnel
 * EndPoint interface after decapsulating the raw IPv6 packet from inside the tunnel header.
 *
 * @param[in] con                          A pointer to the WeaveConnection object.
 *
 * @param[in] msgInfo                      A pointer to the WeaveMessageInfo object.
 *
 * @param[in] message                      A pointer to the PacketBuffer object holding the tunneled IPv6 packet.
 *
 * @return void
 */
void WeaveTunnelConnectionMgr::RecvdFromService (WeaveConnection *con,
                                                 const WeaveMessageInfo *msgInfo,
                                                 PacketBuffer *msg)
{
    WeaveTunnelConnectionMgr *tConnMgr = static_cast<WeaveTunnelConnectionMgr *>(con->AppState);

    tConnMgr->mTunAgent->HandleTunneledReceive(msg, tConnMgr->mTunType);

    return;
}

void WeaveTunnelConnectionMgr::ServiceMgrStatusHandler(void* appState, WEAVE_ERROR err, StatusReport *report)
{
    ReconnectParam reconnParam;

    WeaveTunnelConnectionMgr *tConnMgr = static_cast<WeaveTunnelConnectionMgr *>(appState);

    WeaveLogError(WeaveTunnel, "ServiceManager reported err %s, status %s\n",
            nl::ErrorStr(err), report ? nl::StatusReportStr(report->mProfileId, report->mStatusCode) : "none");

    if (err == WEAVE_NO_ERROR)
    {
        err = WEAVE_ERROR_STATUS_REPORT_RECEIVED;
    }

    // The connection is closed by Service Manager; Set the connection state before reconnecting.

    tConnMgr->mConnectionState = WeaveTunnelConnectionMgr::kState_NotConnected;

    // Increment the failed connection attempts counter.

    if (report)
    {
        reconnParam.PopulateReconnectParam(err, report->mProfileId, report->mStatusCode);
    }
    else
    {
        reconnParam.PopulateReconnectParam(err);
    }

    tConnMgr->AttemptReconnect(reconnParam);
}

/**
 * Handler invoked when Service TCP connection is completed. The device proceeds to initiate Tunnel control
 * commands to the Service from this function.
 *
 * @param[in] con                          A pointer to the WeaveConnection object.
 *
 * @param[in] conErr                       Any error within the WeaveConnection or WEAVE_NO_ERROR.
 *
 * @return void
 */
void WeaveTunnelConnectionMgr::HandleServiceConnectionComplete(WeaveConnection *con, WEAVE_ERROR conErr)
{
    char ipAddrStr[64];
    WeaveTunnelRoute tunRoute;
    ReconnectParam reconnParam;
    uint64_t globalId = 0;
    uint8_t routePriority = WeaveTunnelRoute::kRoutePriority_Medium;

    WeaveTunnelConnectionMgr *tConnMgr = static_cast<WeaveTunnelConnectionMgr *>(con->AppState);
    con->PeerAddr.ToString(ipAddrStr, sizeof(ipAddrStr));

    tConnMgr->mServiceCon = con;

    SuccessOrExit(conErr);

    WeaveLogDetail(WeaveTunnel, "Connection established to node %" PRIx64 " (%s) on %s tunnel\n",
                   con->PeerNodeId, ipAddrStr, tConnMgr->mTunType == kType_TunnelPrimary?"primary":"backup");

    // Set here the Tunneled Data handler and ConnectionClosed handler.

    tConnMgr->mServiceCon->OnConnectionClosed = HandleServiceConnectionClosed;
    tConnMgr->mServiceCon->OnTunneledMessageReceived = RecvdFromService;

    // Set the appropriate route priority based on the tunnel type

    if (tConnMgr->mTunType == kType_TunnelBackup)
    {
        routePriority = WeaveTunnelRoute::kRoutePriority_Low;
    }

    // Create tunnel route for Service and send Tunnel control message.

    memset(&tunRoute, 0, sizeof(tunRoute));
    globalId = WeaveFabricIdToIPv6GlobalId(tConnMgr->mTunAgent->mExchangeMgr->FabricState->FabricId);
    if (tConnMgr->mTunAgent->mRole == kClientRole_BorderGateway)
    {
        tunRoute.tunnelRoutePrefix[0].IPAddr = IPAddress::MakeULA(globalId, kWeaveSubnetId_ThreadMesh, 0);
        tunRoute.tunnelRoutePrefix[0].Length = NL_INET_IPV6_DEFAULT_PREFIX_LEN;
        tunRoute.tunnelRoutePrefix[1].IPAddr = IPAddress::MakeULA(globalId, kWeaveSubnetId_PrimaryWiFi, 0);
        tunRoute.tunnelRoutePrefix[1].Length = NL_INET_IPV6_DEFAULT_PREFIX_LEN;
        tunRoute.tunnelRoutePrefix[2].IPAddr = IPAddress::MakeULA(globalId, kWeaveSubnetId_PrimaryWiFi,
                                                           WeaveNodeIdToIPv6InterfaceId(tConnMgr->mTunAgent->mExchangeMgr->FabricState->LocalNodeId));
        tunRoute.tunnelRoutePrefix[2].Length = NL_INET_IPV6_MAX_PREFIX_LEN;
        tunRoute.tunnelRoutePrefix[3].IPAddr = IPAddress::MakeULA(globalId, kWeaveSubnetId_ThreadMesh,
                                                           WeaveNodeIdToIPv6InterfaceId(tConnMgr->mTunAgent->mExchangeMgr->FabricState->LocalNodeId));
        tunRoute.tunnelRoutePrefix[3].Length = NL_INET_IPV6_MAX_PREFIX_LEN;
        tunRoute.priority[0] = tunRoute.priority[1] = tunRoute.priority[2] = tunRoute.priority[3] = routePriority;
        tunRoute.numOfPrefixes = 4;
    }
    else if (tConnMgr->mTunAgent->mRole == kClientRole_MobileDevice)
    {
        tunRoute.tunnelRoutePrefix[0].IPAddr = IPAddress::MakeULA(globalId, kWeaveSubnetId_MobileDevice,
                                                           WeaveNodeIdToIPv6InterfaceId(tConnMgr->mTunAgent->mExchangeMgr->FabricState->LocalNodeId));
        tunRoute.tunnelRoutePrefix[0].Length = NL_INET_IPV6_MAX_PREFIX_LEN;
        tunRoute.priority[0] = routePriority;
        tunRoute.numOfPrefixes = 1;

    }
    else if (tConnMgr->mTunAgent->mRole == kClientRole_StandaloneDevice)
    {
        tunRoute.tunnelRoutePrefix[0].IPAddr = IPAddress::MakeULA(globalId, kWeaveSubnetId_PrimaryWiFi,
                                                           WeaveNodeIdToIPv6InterfaceId(tConnMgr->mTunAgent->mExchangeMgr->FabricState->LocalNodeId));
        tunRoute.tunnelRoutePrefix[0].Length = NL_INET_IPV6_MAX_PREFIX_LEN;
        tunRoute.tunnelRoutePrefix[1].IPAddr = IPAddress::MakeULA(globalId, kWeaveSubnetId_ThreadMesh,
                                                           WeaveNodeIdToIPv6InterfaceId(tConnMgr->mTunAgent->mExchangeMgr->FabricState->LocalNodeId));
        tunRoute.tunnelRoutePrefix[1].Length = NL_INET_IPV6_MAX_PREFIX_LEN;
        tunRoute.priority[0] = tunRoute.priority[1] = routePriority;
        tunRoute.numOfPrefixes = 2;
    }

    conErr = tConnMgr->mTunControl.SendTunnelOpen(tConnMgr, &tunRoute);
    SuccessOrExit(conErr);

    // Set state variables to indicate successful connection.

    tConnMgr->mConnectionState = kState_ConnectionEstablished;

#if WEAVE_CONFIG_TUNNEL_TCP_USER_TIMEOUT_SUPPORTED
    // With the connection established, configure the User timeout on the connection

    conErr = tConnMgr->ConfigureConnTimeout(tConnMgr->mMaxUserTimeoutSecs);
    SuccessOrExit(conErr);
#endif // WEAVE_CONFIG_TUNNEL_TCP_USER_TIMEOUT_SUPPORTED

#if WEAVE_CONFIG_TUNNEL_TCP_KEEPALIVE_SUPPORTED
    // With the connection established, configure the User timeout on the connection

    conErr = tConnMgr->ConfigureAndEnableTCPKeepAlive(tConnMgr->mKeepAliveIntervalSecs, tConnMgr->mMaxNumProbes);
    SuccessOrExit(conErr);
#endif // WEAVE_CONFIG_TUNNEL_TCP_KEEPALIVE_SUPPORTED

exit:

    if (conErr != WEAVE_NO_ERROR)
    {
        WeaveLogError(WeaveTunnel, "Connection FAILED to node %" PRIx64 " (%s): %ld: Try to reconnect on %s tunnel\n",
                      con ? con->PeerNodeId : 0, ipAddrStr, (long)conErr, tConnMgr->mTunType == kType_TunnelPrimary?"primary":"backup");

        // Attempt to reconnect to Service.
        reconnParam.PopulateReconnectParam(conErr);

        tConnMgr->StopAndReconnectTunnelConn(reconnParam);
    }

    return;
}

/**
 * Handler invoked when Service TCP connection is closed. The device, subsequently, tries to
 * re-establish the connection to the Service.
 *
 * @param[in] con                          A pointer to the WeaveConnection object.
 *
 * @param[in] conErr                       Any error within the WeaveConnection or WEAVE_NO_ERROR.
 *
 * @return void
 */
void WeaveTunnelConnectionMgr::HandleServiceConnectionClosed (WeaveConnection *con, WEAVE_ERROR conErr)
{
    char ipAddrStr[64];
    uint64_t peerNodeId;
    ReconnectParam reconnParam;

    WeaveTunnelConnectionMgr *tConnMgr = static_cast<WeaveTunnelConnectionMgr *>(con->AppState);

    con->PeerAddr.ToString(ipAddrStr, sizeof(ipAddrStr));
    peerNodeId = con->PeerNodeId;

    if (conErr == WEAVE_NO_ERROR)
    {
        WeaveLogDetail(WeaveTunnel, "Connection closed to node %" PRIx64 " (%s) on %s tunnel\n",
                       peerNodeId, ipAddrStr, tConnMgr->mTunType == kType_TunnelPrimary?"primary":"backup");

        conErr = WEAVE_ERROR_CONNECTION_CLOSED_UNEXPECTEDLY;

    }
    else
    {
        WeaveLogError(WeaveTunnel, "Connection ABORTED to node %" PRIx64 " (%s): %ld on %s tunnel\n",
                      peerNodeId, ipAddrStr, (long)conErr, tConnMgr->mTunType == kType_TunnelPrimary?"primary":"backup");
    }

    // Free any outstanding resources that might be held before reconnecting

    tConnMgr->ReleaseResourcesAndStopTunnelConn(conErr);

    reconnParam.PopulateReconnectParam(conErr);

    tConnMgr->AttemptReconnect(reconnParam);
}

/**
 * Release ExchangeContext and Reconnect timer
 */
void WeaveTunnelConnectionMgr::ReleaseResourcesAndStopTunnelConn(WEAVE_ERROR err)
{
    // Release the ExchangeContext if being held

    if (mTunControl.mServiceExchangeCtxt != NULL)
    {
        mTunControl.mServiceExchangeCtxt->Close();
        mTunControl.mServiceExchangeCtxt = NULL;
    }

#if WEAVE_CONFIG_TUNNEL_LIVENESS_SUPPORTED
        // Stop the Tunnel Liveness timer

        StopLivenessTimer();
#endif // WEAVE_CONFIG_TUNNEL_LIVENESS_SUPPORTED

    // Cancel the Reconnect timer

    CancelDelayedReconnect();

    // Stop the tunnel connection

    StopServiceTunnelConn(err);
}

/**
 * Increment the connection attempt counter and try to reconnect to Service
 */
void WeaveTunnelConnectionMgr::AttemptReconnect(ReconnectParam &reconnParam)
{
    mTunFailedConnAttemptsInRow++;

    DecideOnReconnect(reconnParam);
}

#if WEAVE_CONFIG_TUNNEL_LIVENESS_SUPPORTED
void WeaveTunnelConnectionMgr::TunnelLivenessTimeout(System::Layer* aSystemLayer, void* aAppState, System::Error aError)
{
    WEAVE_ERROR err = WEAVE_NO_ERROR;
    ReconnectParam reconnParam;

    WeaveTunnelConnectionMgr* tConnMgr = static_cast<WeaveTunnelConnectionMgr*>(aAppState);

    WeaveLogDetail(WeaveTunnel, "Sending Tunnel liveness probe on %s tunnel\n",
                   tConnMgr->mTunType == kType_TunnelPrimary ? "primary" : "backup");

    err = tConnMgr->mTunControl.SendTunnelLiveness(tConnMgr);

    if (err != WEAVE_NO_ERROR)
    {
        reconnParam.PopulateReconnectParam(err);

        tConnMgr->StopAndReconnectTunnelConn(reconnParam);
    }

    return;
}

/* Schedule a timer for sending a Tunnel Liveness control message */
void WeaveTunnelConnectionMgr::StartLivenessTimer(void)
{
    mTunAgent->mExchangeMgr->MessageLayer->SystemLayer->StartTimer(mTunnelLivenessInterval * nl::Weave::System::kTimerFactor_milli_per_unit, TunnelLivenessTimeout, this);
}

/* Stop the Tunnel Liveness timer for sending a Tunnel Liveness control message */
void WeaveTunnelConnectionMgr::StopLivenessTimer(void)
{
    mTunAgent->mExchangeMgr->MessageLayer->SystemLayer->CancelTimer(TunnelLivenessTimeout, this);
}

/* Restart the timer for sending a Tunnel Liveness control message */
void WeaveTunnelConnectionMgr::RestartLivenessTimer(void)
{
    StopLivenessTimer();

    StartLivenessTimer();
}
#endif // WEAVE_CONFIG_TUNNEL_LIVENESS_SUPPORTED

/**
 * @brief The default policy implementation for fetching the next time to
 * connect to the Service. This policy picks a random timeslot (with
 * millisecond resolution) over an increasing window, following a fibonacci
 * sequence upto WEAVE_CONFIG_TUNNELING_RECONNECT_MAX_FIBONACCI_INDEX.
 *
 * @param appState[in]          App state pointer set during initialization of
 *                              the SubscriptionClient.
 * @param reconnectParam[in]    Structure with parameters that influence the calculation of the
 *                              reconnection delay.
 *
 * @param delayMsec[out]        Time in milliseconds to wait before next
 *                              reconnect attempt.
 */

void WeaveTunnelConnectionMgr::DefaultReconnectPolicyCallback(void * const appState,
                                                              ReconnectParam & reconnParam,
                                                              uint32_t & delayMsec)
{
    uint32_t fibonacciNum = 0;
    uint32_t maxWaitTimeInMsec = 0;
    uint32_t waitTimeInMsec = 0;
    uint32_t minWaitTimeInMsec = 0;
    uint32_t fibIndex = 0;

    WeaveTunnelConnectionMgr* tConnMgr = static_cast<WeaveTunnelConnectionMgr*>(appState);

    if (tConnMgr->mTunFailedConnAttemptsInRow <= WEAVE_CONFIG_TUNNELING_RECONNECT_MAX_FIBONACCI_INDEX)
    {
        fibIndex = tConnMgr->mTunFailedConnAttemptsInRow;
    }
    else
    {
        fibIndex = WEAVE_CONFIG_TUNNELING_RECONNECT_MAX_FIBONACCI_INDEX;
    }

    fibonacciNum = GetFibonacciForIndex(fibIndex);

    maxWaitTimeInMsec = fibonacciNum * WEAVE_CONFIG_TUNNELING_CONNECT_WAIT_TIME_MULTIPLIER_SECS * System::kTimerFactor_milli_per_unit;

    if (maxWaitTimeInMsec != 0)
    {
        // If the reconnectParam comes with a minimum wait time that is greater
        // than the normally configured min wait time(as a percentage of the
        // maxWaitTime), then preferentially use the one in the reconnectParam.

        minWaitTimeInMsec = (reconnParam.mMinDelayToConnectSecs * System::kTimerFactor_milli_per_unit) >
                            (WEAVE_CONFIG_TUNNELING_MIN_WAIT_TIME_INTERVAL_PERCENT * maxWaitTimeInMsec) / 100 ?
                            reconnParam.mMinDelayToConnectSecs * System::kTimerFactor_milli_per_unit :
                            (WEAVE_CONFIG_TUNNELING_MIN_WAIT_TIME_INTERVAL_PERCENT * maxWaitTimeInMsec) / 100;

        waitTimeInMsec = minWaitTimeInMsec + (GetRandU32() % (maxWaitTimeInMsec - minWaitTimeInMsec));
    }

    delayMsec = waitTimeInMsec;

    WeaveLogDetail(WeaveTunnel, "Tunnel reconnect policy: attempts %" PRIu32 ", max wait time %" PRIu32 " ms, selected wait time %" PRIu32 " ms",
                   tConnMgr->mTunFailedConnAttemptsInRow, maxWaitTimeInMsec, waitTimeInMsec);

    return;
}

/**
 * Populate the fields of the ReconnectParam structure
 */
void ReconnectParam::PopulateReconnectParam(WEAVE_ERROR lastConnectError,
                                            uint32_t profileId,
                                            uint16_t statusCode,
                                            uint32_t minDelayToConnectSecs)
{
    mStatusProfileId = profileId;
    mStatusCode = statusCode;
    mLastConnectError = lastConnectError;
    mMinDelayToConnectSecs = minDelayToConnectSecs;
}

#endif // WEAVE_CONFIG_ENABLE_TUNNELING