/*
 *
 *    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 defines the classes corresponding to Weave Exchange management.
 *
 */

#ifndef WEAVE_EXCHANGE_MGR_H
#define WEAVE_EXCHANGE_MGR_H

#include <Weave/Support/NLDLLUtil.h>
#include <Weave/Core/WeaveWRMPConfig.h>
#include <Weave/Core/WeaveCore.h>

 #define EXCHANGE_CONTEXT_ID(x)     ((x)+1)

namespace nl {
namespace Weave {

using System::PacketBuffer;

struct WeaveMessageInfo;
class WeaveExchangeManager;
class WeaveMessageLayer;
class WeaveConnection;
class Binding;

/**
 *  @def WEAVE_TRICKLE_DEFAULT_PERIOD
 *
 *  @brief
 *    Defines Trickle algorithm's default period (in milliseconds) for periodic
 *    transmissions.
 *
 */
#define WEAVE_TRICKLE_DEFAULT_PERIOD 1000

/**
 *  @def WEAVE_TRICKLE_DEFAULT_THRESHOLD
 *
 *  @brief
 *    Defines Trickle algorithm's default value for the maximum number of received
 *    duplicate messages to wait before retransmission.
 *
 */
#define WEAVE_TRICKLE_DEFAULT_THRESHOLD 2

/**
 *  @class WeaveExchangeHeader
 *
 *  @brief
 *    This specifies the Weave profile and message type of a particular Weave message
 *    within an ExchangeContext.
 */
class WeaveExchangeHeader
{
public:
    uint8_t  Version;        /**< The version of the Weave Exchange Header format */
    uint8_t  Flags;          /**< Bit flag indicators for the type of Weave message */
    uint16_t ExchangeId;     /**< The Exchange identifier for the ExchangeContext */
    uint32_t ProfileId;      /**< The Profile identifier of the Weave message */
    uint8_t  MessageType;    /**< The Message type for the specified Weave profile */
#if WEAVE_CONFIG_ENABLE_RELIABLE_MESSAGING
    uint32_t AckMsgId;       /**< Optional; Message identifier being acknowledged.
                                  Specified when requiring acknowledgments. */
#endif
};

/**
 *  @brief
 *    The Weave Exchange header version.
 */
typedef enum WeaveExchangeVersion
{
    kWeaveExchangeVersion_V1 = 1
} WeaveExchangeVersion;

/**
 *  @brief
 *    The Weave Exchange header flag bits.
 */
typedef enum WeaveExchangeFlags
{
    kWeaveExchangeFlag_Initiator     = 0x1,  /**< Set when current message is sent by the initiator of an exchange */
    kWeaveExchangeFlag_AckId         = 0x2,  /**< Set when current message is an acknowledgment for a previously received message */
    kWeaveExchangeFlag_NeedsAck      = 0x4   /**< Set when current message is requesting an acknowledgment from the recipient. */
} WeaveExchangeFlags;

/**
 *  @class ExchangeContext
 *
 *  @brief
 *    This class represents an ongoing conversation (ExchangeContext) between two or more nodes.
 *    It defines methods for encoding and communicating Weave messages within an ExchangeContext
 *    over various transport mechanisms, for example, TCP, UDP, or Weave Reliable Messaging.
 *
 */
class NL_DLL_EXPORT ExchangeContext
{
    friend class WeaveExchangeManager;
    friend class WeaveMessageLayer;

public:

    typedef uint32_t Timeout;                   /**< Type used to express the timeout in this ExchangeContext, in milliseconds */

    WeaveExchangeManager *ExchangeMgr;          /**< [READ ONLY] Owning exchange manager. */
    uint16_t mMsgProtocolVersion;               /**< Message Protocol version for the ExchangeContext. */
    WeaveConnection *Con;                       /**< [READ ONLY] Associated Weave connection. */
    uint64_t PeerNodeId;                        /**< [READ ONLY] Node ID of peer node. */
    IPAddress PeerAddr;                         /**< [READ ONLY] IP address of peer node. */
    InterfaceId PeerIntf;                       /**< [READ ONLY] Interface over which peer can be reached. (Only meaningful for UDP.) */
    uint16_t PeerPort;                          /**< [READ ONLY] Port of peer node. */
    uint16_t ExchangeId;                        /**< [READ ONLY] Assigned exchange ID. */
    void *AppState;                             /**< Pointer to application-specific state object. */
    bool AllowDuplicateMsgs;                    /**< Boolean indicator of whether duplicate messages are allowed for a given exchange. */
    uint8_t EncryptionType;                     /**< Encryption type to use when sending a message. */
    uint16_t KeyId;                             /**< Encryption key to use when sending a message. */
    uint32_t RetransInterval;                   /**< Time between retransmissions (in milliseconds); 0 disables retransmissions. */
    Timeout ResponseTimeout;                    /**< Maximum time to wait for response (in milliseconds); 0 disables response timeout. */
#if WEAVE_CONFIG_ENABLE_RELIABLE_MESSAGING
    WRMPConfig mWRMPConfig;                     /**< WRMP configuration. */
#endif
    enum
    {
        kSendFlag_AutoRetrans            = 0x0001, /**< Used to indicate that automatic retransmission is enabled. */
        kSendFlag_ExpectResponse         = 0x0002, /**< Used to indicate that a response is expected within a specified timeout. */
        kSendFlag_RetransmissionTrickle  = 0x0004, /**< Used to indicate the requirement of retransmissions for Trickle. */
        kSendFlag_DelaySend              = 0x0008, /**< Used to indicate that the sending of the current message needs to be delayed. */
        kSendFlag_ReuseMessageId         = 0x0010, /**< Used to indicate that the message ID in the message header can be reused. */
        kSendFlag_ReuseSourceId          = 0x0020, /**< Used to indicate that the source node ID in the message header can be reused. */
        kSendFlag_RetainBuffer           = 0x0040, /**< Used to indicate that the message buffer should not be freed after sending. */
        kSendFlag_AlreadyEncoded         = 0x0080, /**< Used to indicate that the message is already encoded. */
        kSendFlag_MulticastFromLinkLocal = 0x0100, /**< Used to indicate that the source address of a multicast message should be link local. */
        kSendFlag_FromInitiator          = 0x0200, /**< Used to indicate that the current message is the initiator of the exchange. */
        kSendFlag_RequestAck             = 0x0400, /**< Used to send a WRM message requesting an acknowledgment. */
        kSendFlag_NoAutoRequestAck       = 0x0800, /**< Suppress the auto-request acknowledgment feature when sending a message. */
    };

    bool IsInitiator(void) const;
    bool IsConnectionClosed(void) const;
    bool IsResponseExpected(void) const;
    void SetInitiator(bool inInitiator);
    void SetConnectionClosed(bool inConnectionClosed);
#if WEAVE_CONFIG_ENABLE_RELIABLE_MESSAGING
    bool ShouldDropAck(void) const;
    bool IsAckPending(void) const;
    void SetDropAck(bool inDropAck);
    void SetAckPending(bool inAckPending);
    bool HasPeerRequestedAck(void) const;
    void SetPeerRequestedAck(bool inPeerRequestedAck);
    bool HasRcvdMsgFromPeer(void) const;
    void SetMsgRcvdFromPeer(bool inMsgRcvdFromPeer);
    WEAVE_ERROR WRMPFlushAcks(void);
    uint32_t GetCurrentRetransmitTimeout(void);
#endif
    void SetResponseExpected(bool inResponseExpected);
    bool AutoRequestAck() const;
    void SetAutoRequestAck(bool autoReqAck);
    bool GetAutoReleaseKey() const;
    void SetAutoReleaseKey(bool autoReleaseKey);

    WEAVE_ERROR SendMessage(uint32_t profileId, uint8_t msgType, PacketBuffer *msgPayload, uint16_t sendFlags = 0, void *msgCtxt = 0);
    WEAVE_ERROR SendMessage(uint32_t profileId, uint8_t msgType, PacketBuffer *msgBuf, uint16_t sendFlags, WeaveMessageInfo * msgInfo, void *msgCtxt = 0);
    WEAVE_ERROR SendCommonNullMessage(void);
    WEAVE_ERROR EncodeExchHeader(WeaveExchangeHeader *exchangeHeader, uint32_t profileId, uint8_t msgType, PacketBuffer *msgBuf, uint16_t sendFlags);
    void TeardownTrickleRetransmit(void);
    WEAVE_ERROR SetupTrickleRetransmit(uint32_t retransInterval=WEAVE_TRICKLE_DEFAULT_PERIOD, uint8_t threshold=WEAVE_TRICKLE_DEFAULT_THRESHOLD, uint32_t timeout=0);


    /**
     * This function is the application callback for handling a received Weave message.
     *
     *  @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 profile identifier of the received message.
     *
     *  @param[in]    msgType       The message type of the corresponding profile.
     *
     *  @param[in]    payload       A pointer to the PacketBuffer object holding the message payload.
     */
    typedef void (*MessageReceiveFunct)(ExchangeContext *ec, const IPPacketInfo *pktInfo, const WeaveMessageInfo *msgInfo, uint32_t profileId,
            uint8_t msgType, PacketBuffer *payload);
    MessageReceiveFunct OnMessageReceived;

    /**
     * This function is the application callback to invoke when the timeout for the receipt
     * of a response message has expired.
     *
     *  @param[in]    ec            A pointer to the ExchangeContext object.
     *
     */
    typedef void (*ResponseTimeoutFunct)(ExchangeContext *ec);
    ResponseTimeoutFunct OnResponseTimeout;

    /**
     * This function is the application callback to invoke when the timeout for the retransmission
     * of a previously sent message has expired.
     *
     *  @param[in]    ec            A pointer to the ExchangeContext object.
     *
     */
    typedef void (*RetransmissionTimeoutFunct)(ExchangeContext *ec);
    RetransmissionTimeoutFunct OnRetransmissionTimeout;

    /**
     * This function is the application callback to invoke when an existing Weave connection
     * has been closed.
     *
     *  @param[in]    ec            A pointer to the ExchangeContext object.
     *
     *  @param[in]    con           A pointer to the WeaveConnection object.
     *
     *  @param[in]    conErr        The WEAVE_ERROR type that was reported when the connection
     *                              was closed.
     *
     */
    typedef void (*ConnectionClosedFunct)(ExchangeContext *ec, WeaveConnection *con, WEAVE_ERROR conErr);
    ConnectionClosedFunct OnConnectionClosed;

    /**
     * Type of key error message handling function.
     *
     *  @param[in]    ec            A pointer to the ExchangeContext object.
     *
     *  @param[in]    keyErr        The WEAVE_ERROR type that was reported in the key error message.
     *
     */
    typedef void (*KeyErrorFunct)(ExchangeContext *ec, WEAVE_ERROR keyErr);

    /**
     * This function is the application callback to invoke when key error message has been received
     * from the peer.
     */
    KeyErrorFunct OnKeyError;

    void CancelRetrans(void);
    void HandleTrickleMessage(const IPPacketInfo *pktInfo, const WeaveMessageInfo *msgInfo);

#if WEAVE_CONFIG_ENABLE_RELIABLE_MESSAGING
    WEAVE_ERROR WRMPSendThrottleFlow(uint32_t PauseTimeMillis);
    WEAVE_ERROR WRMPSendDelayedDelivery(uint32_t PauseTimeMillis, uint64_t DelayedNodeId);

    /**
     * This function is the application callback to invoke when an Acknowledgment is received
     * for a Weave message that requested one as part of the Weave Reliable Messaging Protocol.
     *
     *  @param[in]    ec            A pointer to the ExchangeContext object.
     *
     *  @param[in]    msgCtxt       A pointer to some specific context object associated with
     *                              the original message being acknowledged.
     *
     */
    typedef void (*WRMPAckRcvdFunct)(ExchangeContext *ec, void *msgCtxt);

    /**
     * This function is the application callback to invoke when a Throttle message or Delayed
     * Delivery message is received as part of the Weave Reliable Messaging Protocol. Each of
     * these messages are accompanied with a time value (in milliseconds) that signifies the
     * time to pause sending of Weave messages on this ExchangeContext.
     *
     *  @param[in]    ec            A pointer to the ExchangeContext object.
     *
     *  @param[in]    pauseTime     Time to pause transmission (in milliseconds).
     *
     */
    typedef void (*WRMPPauseRcvdFunct)(ExchangeContext *ec, uint32_t pauseTime);

    /**
     * This function is the application callback to invoke when an error is encountered while
     * sending a Weave message.
     *
     *  @param[in]    ec            A pointer to the ExchangeContext object.
     *
     *  @param[in]    err           The WEAVE_ERROR type that was encountered during the
     *                              sending of the message.
     *
     *  @param[in]    msgCtxt       A pointer to some specific context object associated with
     *                              the original message being reported on.
     *
     */
    typedef void (*WRMPSendErrorFunct)(ExchangeContext *ec, WEAVE_ERROR err, void *msgCtxt);

    WRMPPauseRcvdFunct OnThrottleRcvd;            /**< Application callback for received Throttle message. */
    WRMPPauseRcvdFunct OnDDRcvd;                  /**< Application callback for received Delayed Delivery message. */
    WRMPSendErrorFunct OnSendError;               /**< Application callback for error while sending. */
    WRMPAckRcvdFunct   OnAckRcvd;                 /**< Application callback for received acknowledgment. */
#endif // WEAVE_CONFIG_ENABLE_RELIABLE_MESSAGING

    /*
     * in order to use reference counting (see refCount below)
     * we use a hold/free paradigm where users of the exchange
     * can hold onto it while it's out of their direct control
     * to make sure it isn't closed before everyone's ready.
     */
    void AddRef(void);
    void Close(void);
    void Abort(void);
    void Release(void);
    WEAVE_ERROR StartTimerT(void);
private:
    PacketBuffer *msg;                            // If we are re-transmitting, then this is the pointer to the message being retransmitted
    // Trickle-controlled retransmissions:
    uint32_t backoff;                           // backoff for sampling the numner of messages
    uint32_t currentBcastMsgID;
    uint8_t msgsReceived;                       // number of messages heard during the backoff period
    uint8_t rebroadcastThreshold;               // re-broadcast threshold

    uint16_t mFlags;                            // Internal state flags

    WEAVE_ERROR ResendMessage(void);
    bool MatchExchange(WeaveConnection *msgCon, const WeaveMessageInfo *msgInfo, const WeaveExchangeHeader *exchangeHeader);
    static void TimerTau(System::Layer* aSystemLayer, void* aAppState, System::Error aError);
    static void CancelRetransmissionTimer(System::Layer* aSystemLayer, void* aAppState, System::Error aError);
    static void TimerT(System::Layer* aSystemLayer, void* aAppState, System::Error aError);

    WEAVE_ERROR StartResponseTimer(void);
    void CancelResponseTimer(void);
    static void HandleResponseTimeout(System::Layer* aSystemLayer, void* aAppState, System::Error aError);

    uint32_t mPendingPeerAckId;
#if WEAVE_CONFIG_ENABLE_RELIABLE_MESSAGING
    uint16_t mWRMPNextAckTime;                  //Next time for triggering Solo Ack
    uint16_t mWRMPThrottleTimeout;              //Timeout until when Throttle is On when WRMPThrottleEnabled is set
#endif
    void DoClose(bool clearRetransTable);
    WEAVE_ERROR HandleMessage(WeaveMessageInfo *msgInfo, const WeaveExchangeHeader *exchHeader, PacketBuffer *msgBuf);
    WEAVE_ERROR HandleMessage(WeaveMessageInfo *msgInfo, const WeaveExchangeHeader *exchHeader, PacketBuffer *msgBuf,
                              ExchangeContext::MessageReceiveFunct umhandler);

#if WEAVE_CONFIG_ENABLE_RELIABLE_MESSAGING
    bool WRMPCheckAndRemRetransTable(uint32_t msgId, void **rCtxt);
    WEAVE_ERROR WRMPHandleRcvdAck(const WeaveExchangeHeader *exchHeader, const WeaveMessageInfo *msgInfo);
    WEAVE_ERROR WRMPHandleNeedsAck(const WeaveMessageInfo *msgInfo);
    WEAVE_ERROR HandleThrottleFlow(uint32_t PauseTimeMillis);
#endif

    uint8_t mRefCount;
};

/**
 *  @class WeaveExchangeManager
 *
 *  @brief
 *    This class is used to manage ExchangeContexts with other Weave nodes.
 *    It works on behalf of higher layers, creating ExchangeContexts and
 *    handling the registration/unregistration of unsolicited message handlers.
 *
 */
class NL_DLL_EXPORT WeaveExchangeManager
{
    friend class Binding;
    friend class ExchangeContext;
    friend class WeaveMessageLayer;
    friend class WeaveConnection;
    friend class WeaveSecurityManager;
    friend class WeaveFabricState;

public:
    enum State
    {
        kState_NotInitialized = 0,              /**< Used to indicate that the WeaveExchangeManager is not initialized */
        kState_Initialized = 1                  /**< Used to indicate that the WeaveExchangeManager is initialized */
    };

    WeaveExchangeManager(void);

    WeaveMessageLayer *MessageLayer;            /**< [READ ONLY] The associated WeaveMessageLayer object. */
    WeaveFabricState *FabricState;              /**< [READ ONLY] The associated FabricState object. */
    uint8_t State;                              /**< [READ ONLY] The state of the WeaveExchangeManager object. */

    WEAVE_ERROR Init(WeaveMessageLayer *msgLayer);
    WEAVE_ERROR Shutdown(void);

#if WEAVE_CONFIG_TEST
    size_t ExpireExchangeTimers(void);
#endif

    ExchangeContext *NewContext(const uint64_t &peerNodeId, void *appState = NULL);
    ExchangeContext *NewContext(const uint64_t &peerNodeId, const IPAddress &peerAddr, void *appState = NULL);
    ExchangeContext *NewContext(const uint64_t &peerNodeId, const IPAddress &peerAddr, uint16_t peerPort, InterfaceId sendIntfId, void *appState = NULL);
    ExchangeContext *NewContext(WeaveConnection *con, void *appState = NULL);

    ExchangeContext *FindContext(uint64_t peerNodeId, WeaveConnection *con, void *appState, bool isInitiator);

    Binding * NewBinding(Binding::EventCallback eventCallback = Binding::DefaultEventHandler, void *appState = NULL);

    WEAVE_ERROR RegisterUnsolicitedMessageHandler(uint32_t profileId, ExchangeContext::MessageReceiveFunct handler,
            void *appState);
    WEAVE_ERROR RegisterUnsolicitedMessageHandler(uint32_t profileId, ExchangeContext::MessageReceiveFunct handler,
            bool allowDups, void *appState);
    WEAVE_ERROR RegisterUnsolicitedMessageHandler(uint32_t profileId, uint8_t msgType,
            ExchangeContext::MessageReceiveFunct handler, void *appState);
    WEAVE_ERROR RegisterUnsolicitedMessageHandler(uint32_t profileId, uint8_t msgType,
            ExchangeContext::MessageReceiveFunct handler, bool allowDups, void *appState);
    WEAVE_ERROR RegisterUnsolicitedMessageHandler(uint32_t profileId, uint8_t msgType, WeaveConnection *con,
            ExchangeContext::MessageReceiveFunct handler, void *appState);
    WEAVE_ERROR RegisterUnsolicitedMessageHandler(uint32_t profileId, uint8_t msgType, WeaveConnection *con,
            ExchangeContext::MessageReceiveFunct handler, bool allowDups, void *appState);
    WEAVE_ERROR UnregisterUnsolicitedMessageHandler(uint32_t profileId);
    WEAVE_ERROR UnregisterUnsolicitedMessageHandler(uint32_t profileId, uint8_t msgType);
    WEAVE_ERROR UnregisterUnsolicitedMessageHandler(uint32_t profileId, uint8_t msgType, WeaveConnection *con);

    void AllowUnsolicitedMessages(WeaveConnection *con);

#if WEAVE_CONFIG_ENABLE_RELIABLE_MESSAGING
    void ClearMsgCounterSyncReq(uint64_t peerNodeId);
#endif

private:
    uint16_t NextExchangeId;
#if WEAVE_CONFIG_ENABLE_RELIABLE_MESSAGING
    uint64_t mWRMPTimeStampBase;    //WRMP timer base value to add offsets to evaluate timeouts
    uint16_t mWRMPTimerInterval;    //WRMP Timer tick period
    /**
     *  @class RetransTableEntry
     *
     *  @brief
     *    This class is part of the Weave Reliable Messaging Protocol and is used
     *    to keep track of Weave messages that have been sent and are expecting an
     *    acknowledgment back. If the acknowledgment is not received within a
     *    specific timeout, the message would be retransmitted from this table.
     *
     */
    class RetransTableEntry
    {
      public:
       uint32_t             msgId;              /**< The message identifier of the Weave message awaiting acknowledgment. */
       ExchangeContext      *exchContext;       /**< The ExchangeContext for the stored Weave message. */
       PacketBuffer         *msgBuf;            /**< A pointer to the PacketBuffer object holding the Weave message. */
       void                 *msgCtxt;           /**< A pointer to an application level context object associated with the message. */
       uint16_t             nextRetransTime;    /**< A counter representing the next retransmission time for the message. */
       uint8_t              sendCount;          /**< A counter representing the number of times the message has been sent. */
    };
    void     WRMPExecuteActions(void);
    void     WRMPExpireTicks(void);
    void     WRMPStartTimer(void);
    void     WRMPStopTimer(void);
    void     WRMPProcessDDMessage(uint32_t PauseTimeMillis, uint64_t DelayedNodeId);
    uint32_t GetTickCounterFromTimeDelta (uint64_t newTime,
                                          uint64_t oldTime);
    static void WRMPTimeout(System::Layer* aSystemLayer, void* aAppState, System::Error aError);
    static bool isLaterInWRMP(uint64_t t2, uint64_t t1);
    bool IsSendErrorCritical(WEAVE_ERROR err) const;
    WEAVE_ERROR AddToRetransTable(ExchangeContext *ec, PacketBuffer *inetBuff, uint32_t msgId, void *msgCtxt, RetransTableEntry **rEntry);
    WEAVE_ERROR SendFromRetransTable(RetransTableEntry *entry);
    void ClearRetransmitTable(ExchangeContext *ec);
    void ClearRetransmitTable(RetransTableEntry &rEntry);
    void FailRetransmitTableEntries(ExchangeContext *ec, WEAVE_ERROR err);
    void RetransPendingAppGroupMsgs(uint64_t peerNodeId);

    void TicklessDebugDumpRetransTable(const char *log);

    //WRMP Global tables for timer context
    RetransTableEntry RetransTable[WEAVE_CONFIG_WRMP_RETRANS_TABLE_SIZE];
#endif // WEAVE_CONFIG_ENABLE_RELIABLE_MESSAGING

    class UnsolicitedMessageHandler
    {
    public:
        ExchangeContext::MessageReceiveFunct Handler;
        void *AppState;
        uint32_t ProfileId;
        WeaveConnection *Con; // NULL means any connection, or no connection (i.e. UDP)
        int16_t MessageType; // -1 represents any message type
        bool AllowDuplicateMsgs;
    };


    ExchangeContext ContextPool[WEAVE_CONFIG_MAX_EXCHANGE_CONTEXTS];
    size_t mContextsInUse;

    Binding BindingPool[WEAVE_CONFIG_MAX_BINDINGS];
    size_t mBindingsInUse;

    UnsolicitedMessageHandler UMHandlerPool[WEAVE_CONFIG_MAX_UNSOLICITED_MESSAGE_HANDLERS];
    void (*OnExchangeContextChanged)(size_t numContextsInUse);

    ExchangeContext *AllocContext(void);

    void HandleConnectionReceived(WeaveConnection *con);
    void HandleConnectionClosed(WeaveConnection *con, WEAVE_ERROR conErr);
    void DispatchMessage(WeaveMessageInfo *msgInfo, PacketBuffer *msgBuf);
    WEAVE_ERROR RegisterUMH(uint32_t profileId, int16_t msgType, WeaveConnection *con, bool allowDups,
            ExchangeContext::MessageReceiveFunct handler, void *appState);
    WEAVE_ERROR UnregisterUMH(uint32_t profileId, int16_t msgType, WeaveConnection *con);

    static void HandleAcceptError(WeaveMessageLayer *msgLayer, WEAVE_ERROR err);
    static void HandleMessageReceived(WeaveMessageLayer *msgLayer, WeaveMessageInfo *msgInfo, PacketBuffer *msgBuf);
    static void HandleMessageReceived(WeaveConnection *con, WeaveMessageInfo *msgInfo, PacketBuffer *msgBuf);
    static WEAVE_ERROR PrependHeader(WeaveExchangeHeader *exchangeHeader, PacketBuffer *buf);
    static WEAVE_ERROR DecodeHeader(WeaveExchangeHeader *exchangeHeader, PacketBuffer *buf);

    void InitBindingPool(void);
    Binding * AllocBinding(void);
    void FreeBinding(Binding *binding);
    uint16_t GetBindingLogId(const Binding * const binding) const;

    void NotifySecurityManagerAvailable();
    void NotifyKeyFailed(uint64_t peerNodeId, uint16_t keyId, WEAVE_ERROR keyErr);

    WeaveExchangeManager(const WeaveExchangeManager&); // not defined
};


} // namespace Weave
} // namespace nl

#endif // WEAVE_EXCHANGE_MGR_H