/*
 *
 *    Copyright (c) 2013-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 header for the Weave Tunnel Control Protocol, its state management
 *      and protocol operation functions.
 *
 *
 */

#ifndef __STDC_FORMAT_MACROS
#define __STDC_FORMAT_MACROS
#endif // __STDC_FORMAT_MACROS

#include "WeaveTunnelControl.h"
#include "WeaveTunnelAgent.h"
#include "WeaveTunnelConnectionMgr.h"
#include <InetLayer/InetInterface.h>
#include <SystemLayer/SystemTimer.h>
#include <Weave/Support/CodeUtils.h>
#include <Weave/Profiles/ProfileCommon.h>
#include <Weave/Core/WeaveServerBase.h>
#include <Weave/Core/WeaveTLV.h>

#if WEAVE_CONFIG_ENABLE_TUNNELING

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

WeaveTunnelControl::WeaveTunnelControl(void)
{
    mTunnelAgent               = NULL;
#if WEAVE_CONFIG_TUNNEL_SHORTCUT_SUPPORTED
    mShortcutTunExchangeCtxt   = NULL;
#endif // WEAVE_CONFIG_TUNNEL_SHORTCUT_SUPPORTED
    mServiceExchangeCtxt       = NULL;
    mCtrlResponseTimeout       = 0;
    OnTunStatusRcvd            = NULL;
}

/**
 * Initialize WeaveTunnelControl to set relevant members like the Weave Tunnel Agent and callbacks.
 *
 * @param[in] tunAgent          A pointer to the WeaveTunnelAgent object.
 *
 * @param[in] statusRcvd        A pointer to a callback for the StatusRcvd handler.
 *
 * @return WEAVE_NO_ERROR.
 */
WEAVE_ERROR WeaveTunnelControl::Init(WeaveTunnelAgent *tunAgent,
                                     TunnelStatusRcvdFunct statusRcvd)
{
    WEAVE_ERROR err            = WEAVE_NO_ERROR;
    mTunnelAgent               = tunAgent;
#if WEAVE_CONFIG_TUNNEL_SHORTCUT_SUPPORTED
    mShortcutTunExchangeCtxt   = NULL;
    mShortcutTunnelAdvInterval = WEAVE_CONFIG_TUNNELING_SHORTCUT_TUNNEL_ADV_INTERVAL_SECS;
    memset(ShortcutTunnelPeerCache, 0, sizeof(ShortcutTunnelPeerCache));
#endif // WEAVE_CONFIG_TUNNEL_SHORTCUT_SUPPORTED
    mServiceExchangeCtxt       = NULL;
    mCtrlResponseTimeout       = WEAVE_CONFIG_TUNNELING_CTRL_RESPONSE_TIMEOUT_SECS;
    OnTunStatusRcvd            = statusRcvd;

    // Check if the WeaveTunnelAgent object is valid.

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

    err = mTunnelAgent->mExchangeMgr->RegisterUnsolicitedMessageHandler(kWeaveProfile_Tunneling,
                                                                        kMsgType_TunnelReconnect,
                                                                        HandleTunnelReconnect, this);
    SuccessOrExit(err);

exit:
    return err;
}

/**
 * Close WeaveTunnelControl by closing any outstanding exchange contexts and resetting members.
 *
 * @return WEAVE_NO_ERROR.
 */
WEAVE_ERROR WeaveTunnelControl::Close(void)
{
    // Close all the exchanegContexts

#if WEAVE_CONFIG_TUNNEL_SHORTCUT_SUPPORTED
    if (mShortcutTunExchangeCtxt != NULL)
    {
        mShortcutTunExchangeCtxt->Close();
    }
#endif // WEAVE_CONFIG_TUNNEL_SHORTCUT_SUPPORTED

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

    // Unregister the Tunnel reconnect handler

    mTunnelAgent->mExchangeMgr->UnregisterUnsolicitedMessageHandler(kWeaveProfile_Tunneling,
                                                                    kMsgType_TunnelReconnect);

    Free();

    return WEAVE_NO_ERROR;
}

/**
 * Send a Tunnel Open control message to the peer node with a set of tunnel routes.
 *
 * @param[in] conMgr            A pointer to the WeaveTunnelConnectionMgr object.
 *
 * @param[in] tunRoutes         List of prefix routes to add to route table.
 *
 * @return WEAVE_ERROR          WEAVE_NO_ERROR on success, else error.
 */
WEAVE_ERROR WeaveTunnelControl::SendTunnelOpen(WeaveTunnelConnectionMgr *conMgr,
                                               WeaveTunnelRoute *tunRoutes)
{
    return SendTunnelMessage(kMsgType_TunnelOpenV2, conMgr,
                             mTunnelAgent->mExchangeMgr->FabricState->FabricId,
                             tunRoutes, HandleTunnelOpenResponse);
}

/**
 * Send a Tunnel Close control message to the peer node.
 *
 * @param[in] conMgr            A pointer to the WeaveTunnelConnectionMgr object.
 *
 * @return WEAVE_ERROR          WEAVE_NO_ERROR on success, else error.
 */
WEAVE_ERROR WeaveTunnelControl::SendTunnelClose (WeaveTunnelConnectionMgr *conMgr)
{
    return SendTunnelMessage(kMsgType_TunnelClose, conMgr,
                             mTunnelAgent->mExchangeMgr->FabricState->FabricId,
                             NULL, HandleTunnelCloseResponse);
}

/**
 * Send a Tunnel Route Update control message to the peer node with a set of tunnel routes.
 *
 * @param[in] conMgr            A pointer to the WeaveTunnelConnectionMgr object.
 *
 * @param[in] tunRoutes         List of prefix routes to add to route table.
 *
 * @return WEAVE_ERROR          WEAVE_NO_ERROR on success, else error.
 */
WEAVE_ERROR WeaveTunnelControl::SendTunnelRouteUpdate(WeaveTunnelConnectionMgr *conMgr,
                                                      WeaveTunnelRoute *tunRoutes)
{
    return SendTunnelMessage(kMsgType_TunnelRouteUpdate, conMgr,
                             mTunnelAgent->mExchangeMgr->FabricState->FabricId,
                             tunRoutes, HandleTunnelRouteUpdateResponse);
}

#if WEAVE_CONFIG_TUNNEL_LIVENESS_SUPPORTED
/**
 * Send a Tunnel Liveness control message to the peer node.
 *
 * @param[in] conMgr            A pointer to the WeaveTunnelConnectionMgr object.
 *
 * @return WEAVE_ERROR          WEAVE_NO_ERROR on success, else error.
 */
WEAVE_ERROR WeaveTunnelControl::SendTunnelLiveness(WeaveTunnelConnectionMgr *conMgr)
{
    return SendTunnelMessage(kMsgType_TunnelLiveness, conMgr,
                             0,
                             NULL, HandleTunnelLivenessResponse);
}
#endif // WEAVE_CONFIG_TUNNEL_LIVENESS_SUPPORTED

#if WEAVE_CONFIG_TUNNEL_SHORTCUT_SUPPORTED
/**
 * Fetch the interface for sending the broadcast advertisements
 *
 * @param[out] sendIntfId      The send interface id for broadcasting advertisements.
 *
 * @return WEAVE_ERROR         WEAVE_NO_ERROR on success, else error.
 */
WEAVE_ERROR WeaveTunnelControl::GetSendInterfaceIdForBroadcast (InterfaceId &sendIntfId)
{
    WEAVE_ERROR res = WEAVE_NO_ERROR;
    uint64_t globalId = 0;
    IPAddress sendIntfAddr;
    globalId = WeaveFabricIdToIPv6GlobalId(mTunnelAgent->mExchangeMgr->FabricState->FabricId);
    if (mTunnelAgent->mRole == WeaveTunnelAgent::kRole_BorderGateway)
    {
        sendIntfAddr = IPAddress::MakeULA(globalId, kWeaveSubnetId_PrimaryWiFi,
                                WeaveNodeIdToIPv6InterfaceId(mTunnelAgent->mExchangeMgr->FabricState->LocalNodeId));
    }
    else if (mTunnelAgent->mRole == WeaveTunnelAgent::kRole_MobileDevice)
    {
        sendIntfAddr = IPAddress::MakeULA(globalId, kWeaveSubnetId_MobileDevice,
                                WeaveNodeIdToIPv6InterfaceId(mTunnelAgent->mExchangeMgr->FabricState->LocalNodeId));
    }
    res = mTunnelAgent->mInet->GetInterfaceFromAddr(sendIntfAddr, sendIntfId);

    return res;
}

/* Send the Shortcut Tunnel Advertise message of specified type */
WEAVE_ERROR WeaveTunnelControl::SendShortcutTunnelAdvertiseMessage (TunnelCtrlMsgType shortcutTunAdvMsgType,
                                                                    InterfaceId sendIntfId,
                                                                    uint64_t localAddrIdentifier)
{
    WEAVE_ERROR         err         = WEAVE_NO_ERROR;
    PacketBuffer*       msgBuf      = NULL;
    ExchangeContext*    exchangeCtx = NULL;
    uint8_t*            p           = NULL;

    // allocate buffer and send tunnel message
    msgBuf = PacketBuffer::New();

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

    VerifyOrExit(mTunnelAgent->mExchangeMgr != NULL,
                 err = WEAVE_ERROR_INCORRECT_STATE);

    exchangeCtx = mTunnelAgent->mExchangeMgr->NewContext(nl::Weave::kAnyNodeId, this);

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

    mShortcutTunExchangeCtxt = exchangeCtx;

    //Encode the Fabric Id for Border Gateway and the Node Id for Mobile Client.
    p = msgBuf->Start();
    LittleEndian::Write64(p, localAddrIdentifier);
    msgBuf->SetDataLength(8);
    mShortcutTunExchangeCtxt->PeerIntf = sendIntfId;
    err = mShortcutTunExchangeCtxt->SendMessage(kWeaveProfile_Tunneling, shortcutTunAdvMsgType, msgBuf,
                                                nl::Weave::ExchangeContext::kSendFlag_MulticastFromLinkLocal);
    msgBuf = NULL;
    SuccessOrExit(err);

exit:
    if (NULL != msgBuf)
    {
        PacketBuffer::Free(msgBuf);
    }

    if (mShortcutTunExchangeCtxt != NULL)
    {
        mShortcutTunExchangeCtxt->Close();
        mShortcutTunExchangeCtxt = NULL;
    }

    return err;
}

/**
 * Send a border router advertise message advertising its fabric Id.
 *
 * @return WEAVE_ERROR         WEAVE_NO_ERROR on success, else error.
 */
WEAVE_ERROR WeaveTunnelControl::SendBorderRouterAdvertise (void)
{
    WEAVE_ERROR res        = WEAVE_NO_ERROR;
    InterfaceId sendIntfId = INET_NULL_INTERFACEID;

    // Get the sendIntfId for the broadcast

    res = GetSendInterfaceIdForBroadcast(sendIntfId);

    if (res == WEAVE_NO_ERROR)
    {
        res = SendShortcutTunnelAdvertiseMessage(kMsgType_TunnelRouterAdvertise, sendIntfId,
                                                 mTunnelAgent->mExchangeMgr->FabricState->FabricId);
    }

    return res;
}

/**
 * Send a mobile client advertise message advertising its Node Id.
 *
 * @return WEAVE_ERROR         WEAVE_NO_ERROR on success, else error.
 */
WEAVE_ERROR WeaveTunnelControl::SendMobileClientAdvertise (void)
{
    WEAVE_ERROR res        = WEAVE_NO_ERROR;
    InterfaceId sendIntfId = INET_NULL_INTERFACEID;

    //Get the sendIntfId for the broadcast
    res = GetSendInterfaceIdForBroadcast(sendIntfId);

    if (res == WEAVE_NO_ERROR)
    {
        res = SendShortcutTunnelAdvertiseMessage(kMsgType_TunnelMobileClientAdvertise, sendIntfId,
                                                 mTunnelAgent->mExchangeMgr->FabricState->LocalNodeId);
    }

    return res;
}

/**
 * Function registered with WeaveMessageLayer for listening to Shortcut
 * tunnel advertisments and updating cache.
 *
 * @param[in] ec               A pointer to the ExchangeContext object.
 *
 * @param[in] pktInfo          A pointer to the IPPacketInfo object.
 *
 * @param[in] msgInfo          A pointer to the WeaveMessageInfo object.
 *
 * @param[in] profileId        The profileId for which this handler was called.
 *
 * @param[in] msgType          The msgType within the above profile.
 *
 * @param[in] payload          A pointer to the PacketBuffer object holding the
 *                             advertisement message.
 *
 * @return void
 */
void WeaveTunnelControl::HandleShortcutTunnelAdvertiseMessage (ExchangeContext *ec, const IPPacketInfo *pktInfo,
                                                               const WeaveMessageInfo *msgInfo, uint32_t profileId,
                                                               uint8_t msgType, PacketBuffer *payload)
{
    uint8_t     *p  = NULL;
    WeaveTunnelControl *tunControl = static_cast<WeaveTunnelControl *>(ec->AppState);
    uint64_t peerId = 0;
    // Verify that the message is a Tunnel Control Message for added safety.
    if (profileId != kWeaveProfile_Tunneling)
    {
        ExitNow();
    }

    p = payload->Start();
    peerId = LittleEndian::Read64(p);

    //Go through the message type and update the local nextHop Table
    switch (msgType)
    {
        case kMsgType_TunnelRouterAdvertise:
          //TunnelRouter advertisements are meant for mobile client devices.
          if (tunControl->mTunnelAgent->mRole != WeaveTunnelAgent::kRole_MobileDevice)
          {
              ExitNow();
          }

          tunControl->UpdateOrAddTunnelPeerEntry(peerId, pktInfo->SrcAddress,
                                                 msgInfo->SourceNodeId);

          break;
        case kMsgType_TunnelMobileClientAdvertise:
          //Mobile Client advertisements are meant for tunnel border gateways.
          if (tunControl->mTunnelAgent->mRole != WeaveTunnelAgent::kRole_BorderGateway)
          {
              ExitNow();
          }

          tunControl->UpdateOrAddTunnelPeerEntry(peerId, pktInfo->SrcAddress,
                                                 msgInfo->SourceNodeId);

          break;
        default:
          break;
    }

exit:
    // Free the payload buffer.
    PacketBuffer::Free(payload);

    // Discard the exchange context.
    ec->Close();
    ec = NULL;

    return;
}

/**
 * Verify if the peer is present in the shortcut tunnel cache for sending locally.
 *
 * @param[in] peerId          The identifier for the peer for the tunnel shortcut.
 *                            It is the FabricId if the peer is a border gateway and
 *                            the nodeId if the peer is a mobile device.
 *
 * @return true if present and false otherwise.
 */
bool WeaveTunnelControl::IsPeerInShortcutTunnelCache(uint64_t peerId)
{
    int nextHopTableIndex  = -1;
    bool retVal            = false;
    nextHopTableIndex = FindTunnelPeerEntry(peerId);

    if (nextHopTableIndex >= 0)
    {
       retVal = true;
    }

    return retVal;
}

/**
 * Enable shortcut tunneling by sending advertisments from either the Border
 * gateway or Mobile client and also listening to advertisements from shortcut
 * tunnel counterparts.
 *
 * @return void
 */
void WeaveTunnelControl::EnableShortcutTunneling (void)
{
    RegisterShortcutTunnelAdvHandlers();

    if (mTunnelAgent->mRole == WeaveTunnelAgent::kRole_BorderGateway)
    {
        StartShortcutTunnelAdvertisementsFromBorderRouter();
    }
    else if (mTunnelAgent->mRole == WeaveTunnelAgent::kRole_MobileDevice)
    {
        StartShortcutTunnelAdvertisementsFromMobileClient();
    }

    StartNextHopTableMonitor();
}

/**
 * Disable shortcut tunneling of sending advertisments from either the Border gateway or Mobile client and
 * also listening to advertisements from shortcut tunnel counterparts.
 *
 * @return void
 */
void WeaveTunnelControl::DisableShortcutTunneling (void)
{
    UnregisterShortcutTunnelAdvHandlers();

    if (mTunnelAgent->mRole == WeaveTunnelAgent::kRole_BorderGateway)
    {
        StopShortcutTunnelAdvertisementsFromBorderRouter();
    }
    else if (mTunnelAgent->mRole == WeaveTunnelAgent::kRole_MobileDevice)
    {
        StopShortcutTunnelAdvertisementsFromMobileClient();
    }

    StopNextHopTableMonitor();
}

/**
 * Send message over the tunnel shortcut.
 */
WEAVE_ERROR WeaveTunnelControl::SendMessageOverTunnelShortcut(uint64_t peerId,
                                                              WeaveMessageInfo *msgInfo,
                                                              PacketBuffer *msg)
{
    WEAVE_ERROR err = WEAVE_NO_ERROR;
    int nextHopTableIndex  = -1;

    nextHopTableIndex = FindTunnelPeerEntry(peerId);

    VerifyOrExit(nextHopTableIndex >= 0, err = WEAVE_ERROR_TUNNEL_PEER_ENTRY_NOT_FOUND);

    // For shortcut tunneling explicitly set the destination node id from neighbor cache

    msgInfo->DestNodeId = ShortcutTunnelPeerCache[nextHopTableIndex].peerNodeId;

    err = mTunnelAgent->mExchangeMgr->MessageLayer->SendUDPTunneledMessage(
                                 ShortcutTunnelPeerCache[nextHopTableIndex].peerAddr,
                                 msgInfo, msg);
    msg = NULL;

exit:
    if (msg != NULL)
    {
        PacketBuffer::Free(msg);
#if WEAVE_CONFIG_TUNNEL_ENABLE_STATISTICS
        // Update tunnel statistics
        mTunnelAgent->mWeaveTunnelStats.mDroppedMessagesCount++;
#endif // WEAVE_CONFIG_TUNNEL_ENABLE_STATISTICS
    }

    return err;
}

/* Timer expiry function for sending periodic border router advertisements for shortcut tunneling */
void WeaveTunnelControl::BorderRouterAdvTimeout (InetLayer *inetLayer, void *appState, INET_ERROR err)
{
    WEAVE_ERROR      res     = WEAVE_NO_ERROR;
    WeaveTunnelControl *tunControl = static_cast<WeaveTunnelControl *>(appState);

    // Send the Border Router Advertise message.

    tunControl->SendBorderRouterAdvertise();

    // Restart the timer.

    res = tunControl->mTunnelAgent->mExchangeMgr->MessageLayer->Inet->StartTimer(tunControl->mShortcutTunnelAdvInterval * nl::Weave::System::kTimerFactor_milli_per_unit,
                                                                                 BorderRouterAdvTimeout, tunControl);
    VerifyOrDieWithMsg(res == WEAVE_NO_ERROR, WeaveTunnel, "Cannot start BorderRouterAdvTimeout\n");
}

/* Timer expiry function for sending periodic mobile client advertisements for shortcut tunneling */
void WeaveTunnelControl::MobileClientAdvTimeout (InetLayer *inetLayer, void *appState, INET_ERROR err)
{
    WEAVE_ERROR      res     = WEAVE_NO_ERROR;
    WeaveTunnelControl *tunControl = static_cast<WeaveTunnelControl *>(appState);

    // Send the Mobile Client Advertise message.

    tunControl->SendMobileClientAdvertise();

    // Restart the timer.

    res = tunControl->mTunnelAgent->mExchangeMgr->MessageLayer->Inet->StartTimer(tunControl->mShortcutTunnelAdvInterval * nl::Weave::System::kTimerFactor_milli_per_unit,
                                                                                 MobileClientAdvTimeout, tunControl);
    VerifyOrDieWithMsg(res == WEAVE_NO_ERROR, WeaveTunnel, "Cannot start MobileClientAdvTimeout\n");
}

/* Timer expiry functions to mark and purge stale entries from previous advertisements  */
void WeaveTunnelControl::PurgeStaleNextHopEntries (InetLayer *inetLayer, void *appState, INET_ERROR err)
{
    WEAVE_ERROR      res     = WEAVE_NO_ERROR;
    WeaveTunnelControl *tunControl = static_cast<WeaveTunnelControl *>(appState);

    // Go through the shortcut tunnel nexthop table and purge stale entries.

    for (int i = 0; i < WEAVE_CONFIG_TUNNELING_MAX_NUM_SHORTCUT_TUNNEL_PEERS; i++)
    {
        if (tunControl->ShortcutTunnelPeerCache[i].peerIdentifier)
        {
            if (tunControl->ShortcutTunnelPeerCache[i].staleFlag)
            {
                // Remove stale entry

                tunControl->FreeNextHopEntry(i);
            }
            else
            {
                // Mark as stale

                tunControl->ShortcutTunnelPeerCache[i].staleFlag = true;
            }
        }
    }

    // Restart the timer.

    res = tunControl->mTunnelAgent->mExchangeMgr->MessageLayer->Inet->StartTimer(tunControl->mShortcutTunnelAdvInterval * nl::Weave::System::kTimerFactor_milli_per_unit,
                                                                                 PurgeStaleNextHopEntries, tunControl);
    VerifyOrDieWithMsg(res == WEAVE_NO_ERROR, WeaveTunnel, "Cannot start PurgeStaleNextHopEntries\n");
}

/* Start the nexthop cache monitor */
void WeaveTunnelControl::StartNextHopTableMonitor (void)
{
    mTunnelAgent->mExchangeMgr->MessageLayer->Inet->StartTimer(mShortcutTunnelAdvInterval * nl::Weave::System::kTimerFactor_milli_per_unit,
                                                               PurgeStaleNextHopEntries, this);
}

/* Stop the nexthop cache monitor */
void WeaveTunnelControl::StopNextHopTableMonitor (void)
{
    mTunnelAgent->mExchangeMgr->MessageLayer->Inet->CancelTimer(PurgeStaleNextHopEntries, this);
}

/* Register the handlers for receving the shortcut tunnel advertisements for refreshing the nexthop cache */
void WeaveTunnelControl::RegisterShortcutTunnelAdvHandlers (void)
{
    mTunnelAgent->mExchangeMgr->RegisterUnsolicitedMessageHandler(kWeaveProfile_Tunneling, kMsgType_TunnelRouterAdvertise,
                                                                  HandleShortcutTunnelAdvertiseMessage, this);

    mTunnelAgent->mExchangeMgr->RegisterUnsolicitedMessageHandler(kWeaveProfile_Tunneling, kMsgType_TunnelMobileClientAdvertise,
                                                                  HandleShortcutTunnelAdvertiseMessage, this);
}

/* Unregister the handlers for receving the shortcut tunnel advertisements for refreshing the nexthop cache */
void WeaveTunnelControl::UnregisterShortcutTunnelAdvHandlers (void)
{
    mTunnelAgent->mExchangeMgr->UnregisterUnsolicitedMessageHandler(kWeaveProfile_Tunneling, kMsgType_TunnelRouterAdvertise);

    mTunnelAgent->mExchangeMgr->UnregisterUnsolicitedMessageHandler(kWeaveProfile_Tunneling, kMsgType_TunnelMobileClientAdvertise);
}

/* Start sending the periodic border router advertisement messages */
void WeaveTunnelControl::StartShortcutTunnelAdvertisementsFromBorderRouter(void)
{
    mTunnelAgent->mExchangeMgr->MessageLayer->Inet->StartTimer(mShortcutTunnelAdvInterval * nl::Weave::System::kTimerFactor_milli_per_unit,
                                                               BorderRouterAdvTimeout, this);
}

/* Stop sending the periodic border router advertisement messages */
void WeaveTunnelControl::StopShortcutTunnelAdvertisementsFromBorderRouter(void)
{
    mTunnelAgent->mExchangeMgr->MessageLayer->Inet->CancelTimer(BorderRouterAdvTimeout, this);
}

/* Start sending the periodic mobile client advertisement messages */
void WeaveTunnelControl::StartShortcutTunnelAdvertisementsFromMobileClient(void)
{
    mTunnelAgent->mExchangeMgr->MessageLayer->Inet->StartTimer(mShortcutTunnelAdvInterval * nl::Weave::System::kTimerFactor_milli_per_unit,
                                                               MobileClientAdvTimeout, this);
}

/* Stop sending the periodic mobile client advertisement messages */
void WeaveTunnelControl::StopShortcutTunnelAdvertisementsFromMobileClient(void)
{
    mTunnelAgent->mExchangeMgr->MessageLayer->Inet->CancelTimer(MobileClientAdvTimeout, this);
}

/* Lookup NextHop table entry */
int WeaveTunnelControl::FindTunnelPeerEntry (uint64_t peerId)
{
    int index = -1;
    for (int i = 0; i < WEAVE_CONFIG_TUNNELING_MAX_NUM_SHORTCUT_TUNNEL_PEERS; i++)
    {
        if (peerId == ShortcutTunnelPeerCache[i].peerIdentifier)
        {
            index = i;
            break;
        }
    }

    return index;
}

/* Create a new route entry */
int WeaveTunnelControl::NewNextHopEntry (void)
{
    int retIndex = -1;

    for (int i = 0; i < WEAVE_CONFIG_TUNNELING_MAX_NUM_SHORTCUT_TUNNEL_PEERS; i++)
    {
        if (!ShortcutTunnelPeerCache[i].peerIdentifier)
        {
            retIndex = i;
            break;
        }
    }

    return retIndex;
}

/* Free a nexthop entry at a particular index */
WEAVE_ERROR WeaveTunnelControl::FreeNextHopEntry (int index)
{
    WEAVE_ERROR err = WEAVE_NO_ERROR;

    if ((index < 0) || (index >= WEAVE_CONFIG_TUNNELING_MAX_NUM_SHORTCUT_TUNNEL_PEERS))
    {
        ExitNow();
    }

    memset(&ShortcutTunnelPeerCache[index], 0, sizeof(ShortcutTunnelPeerEntry));

exit:

    return err;
}

/* Lookup and update a nexthop entry or add a new entry */
WEAVE_ERROR WeaveTunnelControl::UpdateOrAddTunnelPeerEntry (uint64_t peerId, IPAddress peerAddress, uint64_t peerNodeId)
{
    WEAVE_ERROR err = WEAVE_NO_ERROR;
    int8_t index = -1;
    // Check and update the ShortcutTunnelPeerCache

    index = FindTunnelPeerEntry(peerId);
    if (index < 0)
    {
        // Not found; Create a new entry

        index = NewNextHopEntry();
        if (index < 0)
        {
            ExitNow(err = WEAVE_ERROR_TUNNEL_NEXTHOP_TABLE_FULL);
        }
    }

    // Update the fields in the cache.

    ShortcutTunnelPeerCache[index].peerIdentifier = peerId;
    ShortcutTunnelPeerCache[index].peerAddr       = peerAddress;
    ShortcutTunnelPeerCache[index].peerNodeId     = peerNodeId;
    ShortcutTunnelPeerCache[index].staleFlag      = false;

exit:

    return err;
}
#endif // WEAVE_CONFIG_TUNNEL_SHORTCUT_SUPPORTED

/* Reset the members */
void WeaveTunnelControl::Free (void)
{
    mTunnelAgent               = NULL;
#if WEAVE_CONFIG_TUNNEL_SHORTCUT_SUPPORTED
    mShortcutTunExchangeCtxt   = NULL;
#endif // WEAVE_CONFIG_TUNNEL_SHORTCUT_SUPPORTED
    mServiceExchangeCtxt       = NULL;
    OnTunStatusRcvd            = NULL;
}

/* Create an Exchange Context for exchanging Weave Control messages */
WEAVE_ERROR WeaveTunnelControl::CreateContext (WeaveConnection *aConnection,
                                               ExchangeContext::MessageReceiveFunct onMsgRcvd)
{
    WEAVE_ERROR err = WEAVE_NO_ERROR;

    ExchangeContext *exchangeCtx = NULL;

    VerifyOrExit(mTunnelAgent->mExchangeMgr != NULL,
                 err = WEAVE_ERROR_INCORRECT_STATE);

    exchangeCtx = mTunnelAgent->mExchangeMgr->NewContext(aConnection, this);

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

    // Assign the appropriate message receipt handler to the callback.

    exchangeCtx->OnMessageReceived = onMsgRcvd;

    exchangeCtx->ResponseTimeout   = mCtrlResponseTimeout * nl::Weave::System::kTimerFactor_milli_per_unit;
    exchangeCtx->OnResponseTimeout = TunCtrlRespExpiryHandler;
    mServiceExchangeCtxt           = exchangeCtx;

exit:
    return err;
}

WEAVE_ERROR WeaveTunnelControl::VerifyAndParseStatusResponse(uint32_t profileId,
                                                             uint8_t msgType, PacketBuffer *payload,
                                                             StatusReport & outReport,
                                                             bool & outIsRoutingRestricted)
{
    WEAVE_ERROR err = WEAVE_NO_ERROR;

    // Verify that message is a StatusReport

    VerifyOrExit(profileId == kWeaveProfile_Common, err = WEAVE_ERROR_INVALID_PROFILE_ID);

    VerifyOrExit(msgType == Common::kMsgType_StatusReport, err = WEAVE_ERROR_INVALID_MESSAGE_TYPE);

    // Parse the StatusReport.

    err = StatusReport::parse(payload, outReport);
    SuccessOrExit(err);

    VerifyOrExit(outReport.mProfileId == kWeaveProfile_Common && outReport.mStatusCode == Common::kStatus_Success,
                 err = WEAVE_ERROR_STATUS_REPORT_RECEIVED);

    // Check if there is TLV data in the StatusReport.

    if (outReport.mAdditionalInfo.theLength > 0)
    {
        err = ParseTunnelTLVData(outReport, outIsRoutingRestricted);
        SuccessOrExit(err);
    }

exit:
    return err;
}

WEAVE_ERROR WeaveTunnelControl::ParseTunnelTLVData(StatusReport & report, bool & outIsRoutingRestricted)
{
    WEAVE_ERROR err = WEAVE_NO_ERROR;
    TLVReader tunReader;
    nl::Weave::TLV::TLVType OuterContainerType;
    const uint8_t *tlvData = NULL;
    uint16_t tlvDataLen;
    uint64_t tag = 0;

    tlvData = report.mAdditionalInfo.theData;
    tlvDataLen = report.mAdditionalInfo.theLength;

    // Verify that TLV data supplied by the Service is encapsulated in an anonymous
    // TLV structure. All anonymous TLV structures begin with an anonymous structure control
    // byte (0x15) and end with an end-of-container control byte (0x18).

    VerifyOrExit(tlvDataLen > 2, err = WEAVE_ERROR_INVALID_ARGUMENT);
    VerifyOrExit(tlvData[0] == kTLVElementType_Structure, err = WEAVE_ERROR_INVALID_ARGUMENT);
    VerifyOrExit(tlvData[tlvDataLen - 1] == kTLVElementType_EndOfContainer,
                 err = WEAVE_ERROR_INVALID_ARGUMENT);

    tunReader.Init(tlvData, tlvDataLen);

    err = tunReader.Next();
    SuccessOrExit(err);

    err = tunReader.EnterContainer(OuterContainerType);
    SuccessOrExit(err);

    err = tunReader.Next();
    SuccessOrExit(err);

    tag = tunReader.GetTag();
    VerifyOrExit(nl::Weave::TLV::IsProfileTag(tag),
                 err = WEAVE_ERROR_INVALID_TLV_TAG);

    VerifyOrExit(nl::Weave::TLV::ProfileIdFromTag(tag) == kWeaveProfile_Tunneling,
                 err = WEAVE_ERROR_INVALID_TLV_TAG);

    VerifyOrExit(nl::Weave::TLV::TagNumFromTag(tag) == kTag_TunnelRoutingRestricted,
                 err = WEAVE_ERROR_INVALID_TLV_TAG);

    err = tunReader.Get(outIsRoutingRestricted);
    SuccessOrExit(err);

exit:
    return err;
}

/* Handle received control messages */
void WeaveTunnelControl::HandleTunnelOpenResponse(ExchangeContext *ec, const IPPacketInfo *pktInfo,
                                                  const WeaveMessageInfo *msgInfo, uint32_t profileId,
                                                  uint8_t msgType, PacketBuffer *payload)
{
    WEAVE_ERROR err = WEAVE_NO_ERROR;
    StatusReport report;
    bool isRoutingRestricted = false;
    WeaveTunnelControl *tunControl = static_cast<WeaveTunnelControl *>(ec->AppState);
    WeaveTunnelConnectionMgr *connMgr = static_cast<WeaveTunnelConnectionMgr *>(ec->Con->AppState);

    err = VerifyAndParseStatusResponse(profileId, msgType, payload, report, isRoutingRestricted);

    // Free the payload buffer and close the ExchangeContext early to free up resources.

    tunControl->FreeBufferAndCloseExchange(payload, tunControl->mServiceExchangeCtxt);

    SuccessOrExit(err);

    // Received a Tunnel Open Ack; Set the connection state

    connMgr->mConnectionState = WeaveTunnelConnectionMgr::kState_TunnelOpen;

    // Reset the failed connection attempts after a successful TunnelOpen.

    connMgr->mTunFailedConnAttemptsInRow = 0;

#if WEAVE_CONFIG_TUNNEL_LIVENESS_SUPPORTED
    // Tunnel is up. Start the Tunnel Liveness timer

    connMgr->StartLivenessTimer();
#endif // WEAVE_CONFIG_TUNNEL_LIVENESS_SUPPORTED

    // Call the TunnelOpen post processing function.

    tunControl->mTunnelAgent->WeaveTunnelConnectionUp(msgInfo, connMgr, isRoutingRestricted);


exit:
    if (err != WEAVE_NO_ERROR)
    {
        WeaveLogError(WeaveTunnel, "HandleTunnelOpenResponse FAILED with error: %ld\n", (long)err);

        tunControl->TunnelCloseAndReportErrorStatus(connMgr, err, report);
    }

    return;
}

void WeaveTunnelControl::HandleTunnelCloseResponse(ExchangeContext *ec, const IPPacketInfo *pktInfo,
                                                   const WeaveMessageInfo *msgInfo, uint32_t profileId,
                                                   uint8_t msgType, PacketBuffer *payload)
{
    WEAVE_ERROR err = WEAVE_NO_ERROR;
    StatusReport report;
    bool isRoutingRestricted = false;
    WeaveTunnelControl *tunControl = static_cast<WeaveTunnelControl *>(ec->AppState);
    WeaveTunnelConnectionMgr *connMgr = static_cast<WeaveTunnelConnectionMgr *>(ec->Con->AppState);

    err = VerifyAndParseStatusResponse(profileId, msgType, payload, report, isRoutingRestricted);

    // Free the payload buffer and close the ExchangeContext early to free up resources.

    tunControl->FreeBufferAndCloseExchange(payload, tunControl->mServiceExchangeCtxt);

    SuccessOrExit(err);

    // Received successful response to a Tunnel control message


#if WEAVE_CONFIG_TUNNEL_LIVENESS_SUPPORTED
    // Tunnel is closed. Stop the Tunnel Liveness timer

    connMgr->StopLivenessTimer();
#endif // WEAVE_CONFIG_TUNNEL_LIVENESS_SUPPORTED

    // Close the connection; Do not restart the connection as we had proactively issued a
    // Tunnel Close to the peer. The application would need to start the tunnel explicitly.

    connMgr->StopServiceTunnelConn(WEAVE_NO_ERROR);

    // Received a Tunnel Close Ack: Call the TunnelClose post processing function.

    tunControl->mTunnelAgent->WeaveTunnelConnectionDown(connMgr, WEAVE_NO_ERROR);

exit:
    if (err != WEAVE_NO_ERROR)
    {
        WeaveLogError(WeaveTunnel, "HandleTunnelCloseResponse FAILED with error: %ld\n", (long)err);

        tunControl->TunnelCloseAndReportErrorStatus(connMgr, err, report);
    }

    return;
}

void WeaveTunnelControl::HandleTunnelRouteUpdateResponse(ExchangeContext *ec, const IPPacketInfo *pktInfo,
                                                         const WeaveMessageInfo *msgInfo, uint32_t profileId,
                                                         uint8_t msgType, PacketBuffer *payload)
{
    WEAVE_ERROR err = WEAVE_NO_ERROR;
    StatusReport report;
    bool isRoutingRestricted = false;
    WeaveTunnelControl *tunControl = static_cast<WeaveTunnelControl *>(ec->AppState);
    WeaveTunnelConnectionMgr *connMgr = static_cast<WeaveTunnelConnectionMgr *>(ec->Con->AppState);

    err = VerifyAndParseStatusResponse(profileId, msgType, payload, report, isRoutingRestricted);

    // Free the payload buffer and close the ExchangeContext early to free up resources.

    tunControl->FreeBufferAndCloseExchange(payload, tunControl->mServiceExchangeCtxt);

    SuccessOrExit(err);

    // Received successful response to a Tunnel control message

    // The connection state is kState_TunnelOpen

    connMgr->mConnectionState = WeaveTunnelConnectionMgr::kState_TunnelOpen;

    if (isRoutingRestricted)
    {
        // Although tunnel is restricted, it is still open but can only be
        // usable by the border gateway for itself to access a limited set of
        // Service endpoints. The device is put in this mode, typically, when
        // it is unpaired from the account.
        connMgr->mTunAgent->RemovePlatformTunnelRoute();

        WeaveLogDetail(WeaveTunnel, "Tunnel in restricted mode; Not operating as a Border Router\n");
    }

exit:
    if (err != WEAVE_NO_ERROR)
    {
        WeaveLogError(WeaveTunnel, "HandleTunnelRouteUpdateResponse FAILED with error: %ld\n", (long)err);

        tunControl->TunnelCloseAndReportErrorStatus(connMgr, err, report);
    }

    return;
}

#if WEAVE_CONFIG_TUNNEL_LIVENESS_SUPPORTED
void WeaveTunnelControl::HandleTunnelLivenessResponse(ExchangeContext *ec, const IPPacketInfo *pktInfo,
                                                      const WeaveMessageInfo *msgInfo, uint32_t profileId,
                                                      uint8_t msgType, PacketBuffer *payload)
{
    WEAVE_ERROR err = WEAVE_NO_ERROR;
    StatusReport report;
    bool isRoutingRestricted = false;
    WeaveTunnelControl *tunControl = static_cast<WeaveTunnelControl *>(ec->AppState);
    WeaveTunnelConnectionMgr *connMgr = static_cast<WeaveTunnelConnectionMgr *>(ec->Con->AppState);

    err = VerifyAndParseStatusResponse(profileId, msgType, payload, report, isRoutingRestricted);

    // Free the payload buffer and close the ExchangeContext early to free up resources.

    tunControl->FreeBufferAndCloseExchange(payload, tunControl->mServiceExchangeCtxt);

    SuccessOrExit(err);

    // Received successful response to a Tunnel control message

    // Tunnel is alive. Schedule the next Tunnel Liveness timer.

    connMgr->StartLivenessTimer();

    // Notify the application of the successful Liveness probe response.

    connMgr->mTunAgent->NotifyTunnelLiveness(connMgr->mTunType, WEAVE_NO_ERROR);

exit:
    if (err != WEAVE_NO_ERROR)
    {
        WeaveLogError(WeaveTunnel, "HandleTunnelLivenessResponse FAILED with error: %ld\n", (long)err);

        tunControl->TunnelCloseAndReportErrorStatus(connMgr, err, report);
    }

    return;
}
#endif // WEAVE_CONFIG_TUNNEL_LIVENESS_SUPPORTED

/**
 * Handler to reconnect with the peer node.
 *
 */
void WeaveTunnelControl::HandleTunnelReconnect(ExchangeContext *ec, const IPPacketInfo *pktInfo,
                                               const WeaveMessageInfo *msgInfo, uint32_t profileId,
                                               uint8_t msgType, PacketBuffer *payload)
{
    WEAVE_ERROR err = WEAVE_NO_ERROR;
    WeaveTunnelConnectionMgr *connMgr = NULL;
    WeaveTunnelControl *tunControl = static_cast<WeaveTunnelControl *>(ec->AppState);
    uint16_t hostPort = 0;
    char hostName[255]; // Per spec, max DNS name length is 253.
    uint8_t hostLen = sizeof(hostName);
    uint16_t payloadLen = 0;

    VerifyOrExit(ec->Con != NULL, err = WEAVE_ERROR_INVALID_ARGUMENT);

    connMgr = static_cast<WeaveTunnelConnectionMgr *>(ec->Con->AppState);

    payloadLen = payload->DataLength();

    // Set the connection state

    connMgr->mConnectionState = WeaveTunnelConnectionMgr::kState_ReconnectRecvd;

    // Send a status report

    err = SendStatusReport(ec, kWeaveProfile_Common, Common::kStatus_Success);
    SuccessOrExit(err);

    // Set the hostname to NULL string

    hostName[0] = '\0';

    if (payloadLen)
    {
        // Fetch the hostname and port

        err = tunControl->DecodeTunnelReconnect(hostPort, hostName, hostLen, payload);
        SuccessOrExit(err);
    }

#if WEAVE_CONFIG_ENABLE_SERVICE_DIRECTORY
    if (tunControl->mTunnelAgent->mServiceMgr)
    {
        if (0 == payloadLen)
        {
            // No hostname specified. Clear cache and force trip to directory server
            // during reconnect.

            tunControl->mTunnelAgent->mServiceMgr->clearCache();

        }
        else
        {
            // Received a new hostname and port. Add a new Service directory entry

            err = tunControl->mTunnelAgent->mServiceMgr->replaceOrAddCacheEntry(hostPort, hostName, hostLen,
                                                                                kServiceEndpoint_WeaveTunneling);
            SuccessOrExit(err);
        }
    }
    else
#endif // WEAVE_CONFIG_ENABLE_SERVICE_DIRECTORY
    {
        // Store the Service address for connecting directly if the hostname is
        // a DNS resolved IP address in string format.

        if (IPAddress::FromString(hostName, tunControl->mTunnelAgent->mServiceAddress))
        {
            // store the port also if the hostName is a resolved IP address string.

            tunControl->mTunnelAgent->mServicePort = hostPort;
        }
    }

    // Close the tunnel connection

    connMgr->StopServiceTunnelConn(WEAVE_NO_ERROR);

    // Reset the failed connection attempts counter as this is a fresh reconnect.

    connMgr->mTunFailedConnAttemptsInRow = 0;

    // Try reconnecting to the Service.

    connMgr->ScheduleConnect(CONNECT_NO_DELAY);

    tunControl->mTunnelAgent->WeaveTunnelServiceReconnectRequested(connMgr, hostName, hostPort);
exit:

    tunControl->FreeBufferAndCloseExchange(payload, ec);

    return;
}

void WeaveTunnelControl::TunnelCloseAndReportErrorStatus(WeaveTunnelConnectionMgr *connMgr,
                                                         WEAVE_ERROR err,
                                                         StatusReport report)
{

    ReconnectParam reconnParam;
#if WEAVE_CONFIG_TUNNEL_LIVENESS_SUPPORTED
     // Tunnel is being closed. Stop the Tunnel Liveness timer.

     connMgr->StopLivenessTimer();
#endif // WEAVE_CONFIG_TUNNEL_LIVENESS_SUPPORTED

    // Report the status

    if (OnTunStatusRcvd != NULL)
    {
        OnTunStatusRcvd(connMgr->mTunType, report);
    }

    if (connMgr->mConnectionState == WeaveTunnelConnectionMgr::kState_TunnelClosing)
    {
        // Close the connection

        connMgr->StopServiceTunnelConn(err);

        // Callback to WeaveTunnelAgent to notify application if it has already closed the tunnel.

        mTunnelAgent->WeaveTunnelConnectionDown(connMgr, err);
    }
    else
    {
        // Close the connection and reconnect

        reconnParam.PopulateReconnectParam(err,
                                           report.mProfileId,
                                           report.mStatusCode);

        connMgr->StopAndReconnectTunnelConn(reconnParam);
    }

    return;
}

void WeaveTunnelControl::FreeBufferAndCloseExchange(PacketBuffer *buf, ExchangeContext *&ec)
{
    // Free the payload buffer.

    if (buf)
    {
        PacketBuffer::Free(buf);
    }

    // Discard the exchange context.
    if (ec)
    {
        ec->Close();
        ec = NULL;
    }

    return;
}

/* Send a tunnel control status report message */
WEAVE_ERROR WeaveTunnelControl::SendStatusReport(ExchangeContext *ec, uint32_t profileId,
                                                 uint16_t tunStatusCode)
{
    WEAVE_ERROR     err;

    err = nl::Weave::WeaveServerBase::SendStatusReport(ec, profileId, tunStatusCode, WEAVE_NO_ERROR, 0);

    return err;
}


/* Send the Tunnel Route Control message of specified type */
WEAVE_ERROR WeaveTunnelControl::SendTunnelMessage(TunnelCtrlMsgType msgType,
                                                  WeaveTunnelConnectionMgr *conMgr,
                                                  uint64_t fabricId,
                                                  WeaveTunnelRoute *tunRoutes,
                                                  ExchangeContext::MessageReceiveFunct onMsgRcvd)
{
    WEAVE_ERROR     err        = WEAVE_NO_ERROR;
    PacketBuffer*   msgBuf     = NULL;
    uint8_t         *p         = NULL;

    // allocate buffer and send tunnel message

    msgBuf = PacketBuffer::New();

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

    // Create an ExchangeContext

    err = CreateContext(conMgr->mServiceCon, onMsgRcvd);
    SuccessOrExit(err);

    // A Tunnel Liveness is an empty tunnel control message.

    if (msgType != kMsgType_TunnelLiveness)
    {

        if (msgType == kMsgType_TunnelOpenV2)
        {
            p = msgBuf->Start();

            VerifyOrExit(msgBuf->AvailableDataLength() >= NL_TUNNEL_AGENT_ROLE_SIZE_IN_BYTES +
                         NL_TUNNEL_TYPE_SIZE_IN_BYTES + NL_TUNNEL_SRC_INTF_TYPE_SIZE_IN_BYTES +
                         NL_TUNNEL_LIVENESS_TYPE_SIZE_IN_BYTES + NL_TUNNEL_LIVENESS_MAX_TIMEOUT_SIZE_IN_BYTES,
                         err = WEAVE_ERROR_BUFFER_TOO_SMALL);

            // Encode the tunnel device role, tunnel type, and source interface type in the TunnelOpen message.

            Write8(p, conMgr->mTunAgent->mRole);

            Write8(p, conMgr->mTunType);

            Write8(p, conMgr->mSrcInterfaceType);

#if WEAVE_CONFIG_TUNNEL_LIVENESS_SUPPORTED
            Write8(p, kLiveness_TunnelControl);

            LittleEndian::Write16(p, conMgr->mTunnelLivenessInterval);
#elif WEAVE_CONFIG_TUNNEL_TCP_KEEPALIVE_SUPPORTED
            Write8(p, kLiveness_TCPKeepAlive);

            LittleEndian::Write16(p, conMgr->mKeepAliveIntervalSecs * (conMgr->mMaxNumProbes + 1));
#endif

            // Tunnel device role(1 byte) + Tunnel type(1 byte) + Tunnel source interface type(1 byte) +
            // Tunnel liveness strategy(1 byte) + Tunnel Liveness Max timeout(2 bytes)

            msgBuf->SetDataLength(1 + 1 + 1 + 1 + 2);
        }

        err = WeaveTunnelRoute::EncodeFabricTunnelRoutes(fabricId,
                                                         tunRoutes, msgBuf);
        SuccessOrExit(err);
    }

    err = mServiceExchangeCtxt->SendMessage(kWeaveProfile_Tunneling, msgType, msgBuf,
                                            ExchangeContext::kSendFlag_ExpectResponse);
    msgBuf = NULL;
    SuccessOrExit(err);

exit:
    if (NULL != msgBuf)
    {
        PacketBuffer::Free(msgBuf);
    }

    if (err != WEAVE_NO_ERROR && mServiceExchangeCtxt != NULL)
    {
        mServiceExchangeCtxt->Close();
        mServiceExchangeCtxt = NULL;
    }

    return err;

}

/* Tunnel connection closing handler for tunnel control message error paths and
 * response timeouts.
 */
void WeaveTunnelControl::TunCtrlRespExpiryHandler(ExchangeContext *ec)
{
    WeaveTunnelConnectionMgr *connMgr = NULL;
    WeaveTunnelControl *tunControl    = NULL;
    ReconnectParam reconnParam;

    if (ec)
    {
        tunControl = static_cast<WeaveTunnelControl *>(ec->AppState);

        if (ec->Con)
        {
            connMgr = static_cast<WeaveTunnelConnectionMgr *>(ec->Con->AppState);

            // Set the ExchangeContext for this connMgr to NULL;

            connMgr->mTunControl.mServiceExchangeCtxt = NULL;


            if (connMgr->mConnectionState == WeaveTunnelConnectionMgr::kState_TunnelClosing)
            {
                // Stop the connection.

                connMgr->StopServiceTunnelConn(WEAVE_ERROR_TIMEOUT);

                // Callback to WeaveTunnelAgent to notify application if it has already closed the tunnel.

                tunControl->mTunnelAgent->WeaveTunnelConnectionDown(connMgr, WEAVE_ERROR_TIMEOUT);
            }
            else
            {
                // Stop the connection and attempt to reconnect.

                reconnParam.PopulateReconnectParam(WEAVE_ERROR_TIMEOUT);

                connMgr->StopAndReconnectTunnelConn(reconnParam);
            }
        }

        // Close the ExchangeContext

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

}

/**
 * Decode the Tunnel Reconnect message from the Service and update the
 * Service Directory with the new Tunnel Endpoint hostname and port.
 *
 * @note
 *   hostNameLen is passed in with the size of the buffer hostName and
 *   is set to the length of the hostName(decoded from the PacketBuffer)
 *   by this function as output.
 *
 */
WEAVE_ERROR WeaveTunnelControl::DecodeTunnelReconnect(uint16_t &hostPort,
                                                      char *hostName,
                                                      uint8_t &hostNameLen,
                                                      PacketBuffer *msg)
{
    WEAVE_ERROR err = WEAVE_NO_ERROR;
    uint16_t msgLen = msg->DataLength();
    uint8_t *p = NULL;

    p = msg->Start();

    // Verify that we can read the port, which is 2 bytes.

    VerifyOrExit(msgLen > 2, err = WEAVE_ERROR_INVALID_MESSAGE_LENGTH);

    hostPort = LittleEndian::Read16(p);

    // Verify that the buffer has enough space for the hostname

    VerifyOrExit(hostNameLen > msgLen - 2, err = WEAVE_ERROR_INVALID_ARGUMENT);

    // Assign the actual length of the hostname.

    hostNameLen = msgLen - 2;

    // Read the hostname string into the buffer provided

    memcpy(hostName, p, hostNameLen);
    hostName[hostNameLen] = '\0';

exit:
    return err;
}
#endif // WEAVE_CONFIG_ENABLE_TUNNELING