/*
 *
 *    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 data types and objects for managing the
 *      active node state necessary to participate in a Weave fabric.
 *
 */

#ifndef WEAVE_FABRIC_STATE_H
#define WEAVE_FABRIC_STATE_H

#ifndef __STDC_FORMAT_MACROS
#define __STDC_FORMAT_MACROS
#endif

#ifndef __STDC_LIMIT_MACROS
#define __STDC_LIMIT_MACROS
#endif

#include <inttypes.h>

#include <Weave/Support/NLDLLUtil.h>
#include <Weave/Support/WeaveCounter.h>
#include <Weave/Support/PersistedCounter.h>
#include <Weave/Support/FlagUtils.hpp>
#include <Weave/Core/WeaveCore.h>
#include <Weave/Core/WeaveKeyIds.h>
#include <Weave/Profiles/security/WeaveSecurity.h>
#include <Weave/Profiles/security/WeaveApplicationKeys.h>

namespace nl {
namespace Weave {

class NL_DLL_EXPORT WeaveConnection;
class NL_DLL_EXPORT WeaveMessageLayer;
class NL_DLL_EXPORT WeaveExchangeManager;
struct WeaveMessageInfo;

// Special node id values.
enum
{
    kNodeIdNotSpecified                                 = 0ULL,
    kAnyNodeId                                          = 0xFFFFFFFFFFFFFFFFULL
};

// Special fabric id values.
enum
{
    kFabricIdNotSpecified                               = 0ULL,

    /** Default fabric ID, which should only be used for testing purposes. */
    kFabricIdDefaultForTest                             = 1ULL,

    // Ids >= kReservedFabricIdStart and <= kMaxFabricId are reserved for special uses.  The
    // meanings of values in this range are context-specific; e.g. in the IdentifyRequest
    // message, these value are used to match devices that are/are not members of a fabric.
    kReservedFabricIdStart                              = 0xFFFFFFFFFFFFFF00ULL,

    kMaxFabricId                                        = 0xFFFFFFFFFFFFFFFFULL
};

/** Identifies the purpose or application of certificate
 *
 * A certificate type is a label that describes a certificate's purpose or application.
 * Certificate types are not carried as attributes of the corresponding certificates, but
 * rather are derived from the certificate's structure and/or the context in which it is used.
 * The certificate type enumeration includes a set of pre-defined values describing commonly
 * used certificate applications.  Developers can also extend the certificate type value
 * range with application-specific types that described custom certificates or certificates
 * with unique security properties.
 *
 * Certificate types are primarily used in the implementation of access control policies,
 * where access to application features is influenced by the type of certificate presented
 * by a requester.
 *
 * @note Cert type is an API data type only; it should never be sent over-the-wire.
 */
enum
{
    // NOTE: When adding additional types, please update the PrintCertType() function.

    kCertType_NotSpecified                              = 0x00, /**< The certificate's type has not been specified. */
    kCertType_General                                   = 0x01, /**< The certificate is of a general or non-specific type. */
    kCertType_Device                                    = 0x02, /**< A Weave device certificate. */
    kCertType_ServiceEndpoint                           = 0x03, /**< A Weave service endpoint certificate. */
    kCertType_FirmwareSigning                           = 0x04, /**< A Weave firmware signing certificate. */
    kCertType_AccessToken                               = 0x05, /**< A Weave access token certificate. */
    kCertType_CA                                        = 0x06, /**< A CA certificate. */

    kCertType_AppDefinedBase                            = 0x7F, /**< Application-specific certificate types should have values >= this value. */

    kCertType_Max                                       = 0xFF, /**< Certificate types should not be greater than this value. */
};

/** Identifies the source for the password used in a password-based authentication protocol (e.g. Weave PASE)
 *
 * @note Password Source is protocol data type; do not renumber.
 */
enum
{
    kPasswordSource_NotSpecified                        = 0x0,
    kPasswordSource_PairingCode                         = 0x1,

    kPasswordSource_Max                                 = 0xF,
};


/** Identifies how a peer node is authenticated.
 *
 * WeaveAuthMode describes the means by which a peer node has been, or should be,
 * authenticated during a Weave message exchange.  In an initiating context,
 * applications use WeaveAuthMode to express a desired peer authentication mode
 * for an exchange, thereby instructing the Weave security and messaging layers
 * to achieve the desired mode or fail the communication.  In a responding context,
 * WeaveAuthMode identifies how the requesting node (the peer) was authenticated,
 * allowing the responding application to enforce access controls based on this
 * information.
 *
 * The WeaveAuthMode assigned to an incoming Weave message is related to the nature
 * of the key that was used to encrypt that message.  The WeaveAuthMode derives from
 * the mechanism by which the key was established and the criteria used to verify the
 * identities of the communicating parties at the time of key establishment.
 *
 * WeaveAuthMode includes a set of pre-defined values describing common
 * authentication modes.  These are broken down by the key agreement mechanism
 * (CASE, PASE, GroupKey, etc.).  Developers can extend WeaveAuthMode by defining
 * application-specific mode, which they can attach to specific encryption keys.
 *
 * @note WeaveAuthMode is an API data type only; it should never be sent over-the-wire.
 */
typedef uint16_t WeaveAuthMode;
enum
{
    kWeaveAuthMode_NotSpecified                         = 0x0000, /**< Authentication mode not specified. */

    // ===== Major authentication categories =====
    kWeaveAuthModeCategory_General                      = 0x0000, /**< Peer authenticated using one of a set of general mechanisms */
    kWeaveAuthModeCategory_PASE                         = 0x1000, /**< Peer authenticated using Weave PASE protocol */
    kWeaveAuthModeCategory_CASE                         = 0x2000, /**< Peer authenticated using Weave CASE protocol */
    kWeaveAuthModeCategory_TAKE                         = 0x3000, /**< Peer authenticated using Weave TAKE protocol */
    kWeaveAuthModeCategory_GroupKey                     = 0x4000, /**< Peer authenticated using a shared group key */
    kWeaveAuthModeCategory_AppDefinedBase               = 0xC000, /**< Base value for application-defined authentication categories */

    // ===== General authentication modes =====
    kWeaveAuthMode_Unauthenticated                      = kWeaveAuthModeCategory_General | 0x001,
                                                                  /**< Peer not authenticated. */

    // ===== PASE authentication modes =====
    kWeaveAuthMode_PASE_PairingCode                     = kWeaveAuthModeCategory_PASE | kPasswordSource_PairingCode,
                                                                  /**< Peer authenticated using PASE with device pairing code. */

    // ===== CASE authentication modes =====
    kWeaveAuthMode_CASE_AnyCert                         = kWeaveAuthModeCategory_CASE | kCertType_NotSpecified,
                                                                  /**< Peer authenticated using CASE with arbitrary certificate, or certificate of unknown type. */
    kWeaveAuthMode_CASE_GeneralCert                     = kWeaveAuthModeCategory_CASE | kCertType_General,
                                                                  /**< Peer authenticated using CASE with a general, or non-specific certificate type. */
    kWeaveAuthMode_CASE_Device                          = kWeaveAuthModeCategory_CASE | kCertType_Device,
                                                                  /**< Peer authenticated using CASE with Weave device certificate. */
    kWeaveAuthMode_CASE_ServiceEndPoint                 = kWeaveAuthModeCategory_CASE | kCertType_ServiceEndpoint,
                                                                  /**< Peer authenticated using CASE with Weave service endpoint certificate. */
    kWeaveAuthMode_CASE_AccessToken                     = kWeaveAuthModeCategory_CASE | kCertType_AccessToken,
                                                                  /**< Peer authenticated using CASE with Weave access token certificate. */

    // ===== TAKE authentication modes =====
    kWeaveAuthMode_TAKE_IdentificationKey               = kWeaveAuthModeCategory_TAKE | 0x001,
                                                                /**< Peer authenticated using TAKE with a token identification key. */

    // ===== Subfield Masks =====
    kWeaveAuthModeCategory_Mask                         = 0xF000,
    kWeaveAuthMode_PASE_PasswordSourceMask              = kPasswordSource_Max,
    kWeaveAuthMode_CASE_CertTypeMask                    = kCertType_Max,
    kWeaveAuthMode_GroupKey_AppGroupLocalNumber         = WeaveKeyId::kGroupLocalNumber_Max,

    // ===== DEPRECATED ALIASES =====
    kWeaveAuthMode_None                                 = kWeaveAuthMode_Unauthenticated,
    kWeaveAuthMode_Password_PairingCode                 = kWeaveAuthMode_PASE_PairingCode,
    kWeaveAuthMode_Cert_Device                          = kWeaveAuthMode_CASE_Device,
    kWeaveAuthMode_Cert_ServiceEndPoint                 = kWeaveAuthMode_CASE_ServiceEndPoint,
};

/** True if the authentication mode is based on the Weave PASE protocol. */
inline bool IsPASEAuthMode(WeaveAuthMode authMode) { return (authMode & kWeaveAuthModeCategory_Mask) == kWeaveAuthModeCategory_PASE; }

/** True if the authentication mode is based on the Weave CASE protocol. */
inline bool IsCASEAuthMode(WeaveAuthMode authMode) { return (authMode & kWeaveAuthModeCategory_Mask) == kWeaveAuthModeCategory_CASE; }

/** True if the authentication mode is based on the Weave TAKE protocol. */
inline bool IsTAKEAuthMode(WeaveAuthMode authMode) { return (authMode & kWeaveAuthModeCategory_Mask) == kWeaveAuthModeCategory_TAKE; }

/** True if the authentication mode is based possession of a shared password. */
inline bool IsPasswordAuthMode(WeaveAuthMode authMode) { return IsPASEAuthMode(authMode); }

/** True if the authentication mode is based on possession of a private key associated with a certificate. */
inline bool IsCertAuthMode(WeaveAuthMode authMode) { return IsCASEAuthMode(authMode); }

/** True if the authentication mode is based on possession of a shared group key. */
inline bool IsGroupKeyAuthMode(WeaveAuthMode authMode) { return (authMode & kWeaveAuthModeCategory_Mask) == kWeaveAuthModeCategory_GroupKey; }

/** Returns the password source for the given authentication mode.
 *
 *  @note The result is only valid when the supplied mode is one of the password authentication modes.
 */
inline uint8_t PasswordSourceFromAuthMode(WeaveAuthMode authMode) { return (uint8_t)(authMode & kWeaveAuthMode_PASE_PasswordSourceMask); }

/** Returns the password source for the given authentication mode.
 *
 *  @note The result is only valid when the supplied mode is one of the certificate authentication modes.
 */
inline uint8_t CertTypeFromAuthMode(WeaveAuthMode authMode) { return (uint8_t)(authMode & kWeaveAuthMode_CASE_CertTypeMask); }

/** Returns the application group master key ID associated with the authentication mode.
 *
 *  @note The result is only valid when the supplied mode is one of the group key modes.
 */
inline uint8_t AppGroupMasterKeyIdFromAuthMode(WeaveAuthMode authMode) { return WeaveKeyId::MakeAppGroupMasterKeyId(authMode & kWeaveAuthMode_GroupKey_AppGroupLocalNumber); }

/** Returns a corresponding PASE authentication mode for a given password source. */
inline WeaveAuthMode PASEAuthMode(uint8_t pwSource) { return kWeaveAuthModeCategory_PASE | pwSource; }

/** Returns a corresponding CASE authentication mode for a given certificate type. */
inline WeaveAuthMode CASEAuthMode(uint8_t certType) { return kWeaveAuthModeCategory_CASE | certType; }

/** Returns a corresponding group key authentication mode for a given key ID.
 *
 *  @note The result is only valid when the supplied key ID is an application group key.
 */
inline WeaveAuthMode GroupKeyAuthMode(uint32_t keyId) { return kWeaveAuthModeCategory_GroupKey | WeaveKeyId::GetAppGroupLocalNumber(keyId); }


/**
 * @typedef FabricSecretScope
 *
 * @brief
 *   Identifies the category of devices that can possess and use fabric secret.
 *
 * @note FabricSecretScope is protocol data type; do not renumber.
 */
typedef uint8_t FabricSecretScope;
enum
{
    kFabricSecretScope_All                              = 0x00  /**< All devices can possess corresponding fabric secret. */
};

// Encryption key for the AES-128-CTR-SHA-1 message encryption type
class WeaveEncryptionKey_AES128CTRSHA1
{
public:
    enum
    {
        DataKeySize                                     = 16,
        DataKeySizeInWords                              = DataKeySize/sizeof(uint32_t),
        IntegrityKeySize                                = 20,
        KeySize                                         = DataKeySize + IntegrityKeySize
    };

    union {
        uint8_t DataKey[DataKeySize];
        uint32_t DataKeyWords[DataKeySizeInWords];
    };
    uint8_t IntegrityKey[IntegrityKeySize];
};

// Represents a key or key set used to encrypt Weave messages.
typedef union WeaveEncryptionKey
{
    WeaveEncryptionKey_AES128CTRSHA1 AES128CTRSHA1;
} WeaveEncryptionKey;

// AES128CTRSHA1 encryption and integrity test keys, which should only be used for testing purposes.
enum
{
    kTestKey_AES128CTRSHA1_DataKeyByte                  = 0xAB,  /**< Byte value that constructs encryption key, which is used only for testing. */
    kTestKey_AES128CTRSHA1_IntegrityKeyByte             = 0xBA   /**< Byte value that constructs integrity key, which is used only for testing. */
};

/**
 *  @class WeaveMsgEncryptionKey
 *
 *  @brief
 *    Contains information about Weave message encryption key.
 *
 */
class WeaveMsgEncryptionKey
{
public:
    uint16_t KeyId;                                     /**< The key ID. */
    uint8_t EncType;                                    /**< The encryption type supported by the key. */
    WeaveEncryptionKey EncKey;                          /**< The secret key material. */
};

// WeaveSessionState -- Conveys the communication state needed to send/receive messages with another node.
class WeaveSessionState
{
public:

    typedef uint16_t ReceiveFlagsType;

    enum
    {
        kReceiveFlags_NumMessageIdFlags                 = (sizeof(ReceiveFlagsType) * 8) - 1,
        kReceiveFlags_MessageIdSynchronized             = (1 << kReceiveFlags_NumMessageIdFlags),
        kReceiveFlags_MessageIdFlagsMask                = ~kReceiveFlags_MessageIdSynchronized
    };

    WeaveSessionState(void);
    WeaveSessionState(WeaveMsgEncryptionKey *msgEncKey, WeaveAuthMode authMode,
                      MonotonicallyIncreasingCounter *nextMsgId, uint32_t *maxRcvdMsgId, ReceiveFlagsType *rcvFlags);

    WeaveMsgEncryptionKey *MsgEncKey;
    WeaveAuthMode AuthMode;

    uint32_t NewMessageId(void);
    bool MessageIdNotSynchronized(void);
    bool IsDuplicateMessage(uint32_t msgId);

private:
    MonotonicallyIncreasingCounter *NextMsgId;
    uint32_t *MaxMsgIdRcvd;
    ReceiveFlagsType *RcvFlags;
};

// WeaveSessionKey -- Contains information about a Weave session key.
class WeaveSessionKey
{
public:
    enum FlagsEnum
    {
        kFlag_IsLocallyInitiated     = 0x01,            // The session was initiated by the local node.
        kFlag_IsSharedSession        = 0x02,            // The session is a shared session.
        kFlag_IsRemoveOnIdle         = 0x04,            // The session should be removed when idle (only applies to sessions
                                                        // that are not bound to a connection).
        kFlag_RecentlyActive         = 0x08,            // The session was recently active.
    };

    uint64_t NodeId;                                    // The id of the node with which the session key is shared.
    MonotonicallyIncreasingCounter NextMsgId;           // The next message id to be used under the session key.
    uint32_t MaxRcvdMsgId;                              // The maximum message id received under the session key.
    WeaveConnection *BoundCon;                          // The connection to which the key is bound.
    WeaveSessionState::ReceiveFlagsType RcvFlags;       // Flags tracking messages received under the key.
    WeaveAuthMode AuthMode;                             // The means by which the peer node was authenticated during session establishment.
    WeaveMsgEncryptionKey MsgEncKey;                    // The Weave message encryption key.
    uint8_t ReserveCount;                               // Number of times the session key has been reserved.
    uint8_t Flags;                                      // Various flags associated with the session.

    void Init(void);
    void Clear(void);

    bool IsAllocated() const            { return MsgEncKey.KeyId != WeaveKeyId::kNone; }
    bool IsKeySet() const               { return MsgEncKey.EncType != 0; }
    bool IsLocallyInitiated() const     { return GetFlag(Flags, kFlag_IsLocallyInitiated); }
    void SetLocallyInitiated(bool val)  { SetFlag(Flags, kFlag_IsLocallyInitiated, val); }
    bool IsSharedSession() const        { return GetFlag(Flags, kFlag_IsSharedSession); }
    void SetSharedSession(bool val)     { SetFlag(Flags, kFlag_IsSharedSession, val); }
    bool IsRemoveOnIdle() const         { return GetFlag(Flags, kFlag_IsRemoveOnIdle); }
    void SetRemoveOnIdle(bool val)      { SetFlag(Flags, kFlag_IsRemoveOnIdle, val); }
    bool IsRecentlyActive() const       { return GetFlag(Flags, kFlag_RecentlyActive); }
    void MarkRecentlyActive()           { SetFlag(Flags, kFlag_RecentlyActive); }
    void ClearRecentlyActive()          { ClearFlag(Flags, kFlag_RecentlyActive); }
};

// Key cache for Weave message encryption keys.
class WeaveMsgEncryptionKeyCache
{
public:
    void Init(void);
    void Reset(void);
    void Shutdown(void);

    WeaveMsgEncryptionKey *FindOrAllocateKeyEntry(uint16_t keyId, uint8_t encType);

private:
    // Array of Weave message encryption keys.
    WeaveMsgEncryptionKey mKeyCache[WEAVE_CONFIG_MAX_CACHED_MSG_ENC_APP_KEYS];
    // Array of key entry indexes in sorted order from most- to least- recently used.
    uint8_t mMostRecentlyUsedKeyEntries[WEAVE_CONFIG_MAX_CACHED_MSG_ENC_APP_KEYS];

    void Clear(uint8_t keyEntryIndex);
};

/**
 *  @brief
 *    Key diversifier used for Weave message encryption key derivation. This value
 *    represents first 4 bytes of the SHA-1 HASH of "Nest Weave Message EK and AK" phrase.
 */
extern const uint8_t kWeaveMsgEncAppKeyDiversifier[4];

/**
 * Weave message encryption application key diversifier size.
 */
enum
{
    kWeaveMsgEncAppKeyDiversifierSize         = sizeof(kWeaveMsgEncAppKeyDiversifier) + sizeof(uint8_t)
};

// Forward declaration of WeaveFabricState
class WeaveFabricState;

/**
 *  This abstract delegate class communicates fabric state changes.
 */
class FabricStateDelegate
{
public:
    /**
     * This method is called when WeaveFabricState joins or creates a new fabric.
     *
     * @param[in] fabricState: A pointer to WeaveFabricState that was changed.
     * @param[in] newFabricId: The new fabric ID of the WeaveFabricState.
     *
     * @retval None.
     */
    virtual void DidJoinFabric(WeaveFabricState *fabricState, uint64_t newFabricId) = 0;

    /**
     * This method is called when WeaveFabricState leaves a fabric (i.e., fabric state
     * is cleared).
     *
     * @param[in] fabricState: A pointer to the WeaveFabricState that was changed.
     * @param[in] oldFabricId: The old fabric ID that was cleared.
     *
     * @retval None.
     */
    virtual void DidLeaveFabric(WeaveFabricState *fabricState, uint64_t oldFabricId) = 0;
};

class NL_DLL_EXPORT WeaveFabricState
{
public:

#if WEAVE_CONFIG_MAX_PEER_NODES <= UINT8_MAX
    typedef uint8_t PeerIndexType;
#else
    typedef uint16_t PeerIndexType;
#endif

    enum State
    {
        kState_NotInitialized = 0, kState_Initialized = 1
    };

    WeaveFabricState(void);

    WeaveMessageLayer *MessageLayer;                    // [READ ONLY] The associated WeaveMessageLayer object.
    uint64_t FabricId;                                  // [READ ONLY] Node's Fabric Id (0 means node is not a member of a fabric).
    uint64_t LocalNodeId;
    const char *PairingCode;
    uint16_t DefaultSubnet;
    uint8_t State;                                      // [READ ONLY] State of the Weave Fabric State object
    nl::Weave::Profiles::Security::AppKeys::GroupKeyStoreBase *GroupKeyStore;

#if WEAVE_CONFIG_SECURITY_TEST_MODE
    uint64_t DebugFabricId;
    bool LogKeys;
    bool UseTestKey; // DEPRECATED -- Temporarily retained for API compaibility
    bool AutoCreateKeys; // DEPRECATED -- Temporarily retained for API compaibility
#endif

#if WEAVE_CONFIG_ENABLE_TARGETED_LISTEN
    IPAddress ListenIPv4Addr;
    IPAddress ListenIPv6Addr;
#endif


    WEAVE_ERROR Init(void);
    WEAVE_ERROR Init(nl::Weave::Profiles::Security::AppKeys::GroupKeyStoreBase *groupKeyStore);
    WEAVE_ERROR Shutdown(void);

    WEAVE_ERROR AllocSessionKey(uint64_t peerNodeId, uint16_t keyId, WeaveConnection *boundCon, WeaveSessionKey *& sessionKey);
    WEAVE_ERROR SetSessionKey(uint16_t keyId, uint64_t peerNodeId, uint8_t encType, WeaveAuthMode authMode, const WeaveEncryptionKey *encKey);
    void SetSessionKey(WeaveSessionKey *sessionKey, uint8_t encType, WeaveAuthMode authMode, const WeaveEncryptionKey *encKey);
    WEAVE_ERROR GetSessionKey(uint16_t keyId, uint64_t peerNodeId, WeaveSessionKey *& outSessionKey);
    WEAVE_ERROR FindSessionKey(uint16_t keyId, uint64_t peerNodeId, bool create, WeaveSessionKey *& retRec);
    WEAVE_ERROR RemoveSessionKey(uint16_t keyId, uint64_t peerNodeId);
    void RemoveSessionKey(WeaveSessionKey *sessionKey, bool wasIdle = false);
    bool RemoveIdleSessionKeys();

    WeaveSessionKey *FindSharedSession(uint64_t terminatingNodeId, WeaveAuthMode authMode, uint8_t encType);
    bool IsSharedSession(uint16_t keyId, uint64_t peerNodeId);
    WEAVE_ERROR AddSharedSessionEndNode(uint64_t endNodeId, uint64_t terminatingNodeId, uint16_t keyId);
    WEAVE_ERROR AddSharedSessionEndNode(WeaveSessionKey *sessionKey, uint64_t endNodeId);
    WEAVE_ERROR GetSharedSessionEndNodeIds(const WeaveSessionKey *sessionKey, uint64_t *endNodeIds,
                                           uint8_t endNodeIdsBufSize, uint8_t& endNodeIdsCount);

    WEAVE_ERROR GetSessionState(uint64_t remoteNodeId, uint16_t keyId, uint8_t encType, WeaveConnection *con, WeaveSessionState& outSessionState);

    /**
     * This method returns an IPAddress representing the ULA of a Thread Node.
     * This variant allows for a subnet to be specified.
     *
     * @param[in] nodeId            The Node ID number of the node in question.
     *
     * @param[in] subnet            The desired subnet of the ULA.
     *
     * @retval IPAddress            An IPAddress object.
     */
    IPAddress SelectNodeAddress(uint64_t nodeId, uint16_t subnet) const;

    /**
     * This method returns an IPAddress representing the ULA of a Thread Node.
     * This variant uses the fabric state's default subnet.
     *
     * @param[in] nodeId            The Node ID number of the node in question.
     *
     * @retval IPAddress            An IPAddress object.
     */
    IPAddress SelectNodeAddress(uint64_t nodeId) const;

    /**
     * This method returns true if the given IP Address represents a node
     * within the local fabric.
     *
     * @param[in] addr              The IP Address being checked.
     *
     * @retval bool                 Whether or not the IP represents a
     *                              node in the local fabric.
     */
    bool IsFabricAddress(const IPAddress &addr) const;

    WEAVE_ERROR GetPassword(uint8_t pwSrc, const char *& ps, uint16_t& pwLen);

    WEAVE_ERROR CreateFabric(void);
    void ClearFabricState(void);
    WEAVE_ERROR GetFabricState(uint8_t *buf, uint32_t bufSize, uint32_t &fabricStateLen);
    WEAVE_ERROR JoinExistingFabric(const uint8_t *fabricState, uint32_t fabricStateLen);

    void HandleConnectionClosed(WeaveConnection *con);

    /**
     * This method sets the delegate object.
     * The callback methods of delegate are invoked whenever the FabricId is changed,
     * i.e., when we join/create a fabric, or when we leave a fabric (clear fabric state)
     *
     * If the delegate is previously set, then a second call to this method will overwrite
     * the previous delegate.
     *
     * @param[in] aDelegate                     The delegate object. It can be NULL if no
     *                                          delegate is required.
     * @retval None.
     */
    void SetDelegate(FabricStateDelegate *aDelegate);

#if WEAVE_CONFIG_USE_APP_GROUP_KEYS_FOR_MSG_ENC
    void OnMsgCounterSyncRespRcvd(uint64_t peerNodeId, uint32_t peerMsgId, uint32_t requestorMsgCounter);
    void OnMsgCounterSyncReqSent(uint32_t messageId);

    /**
     * This method returns true if at least one peer's message counter
     * synchronization request is in progress.
     *
     * @retval bool                 Whether or not peer's message counter synchronization
     *                              is in progress.
     */
    bool IsMsgCounterSyncReqInProgress(void)
    {
        return (MsgCounterSyncStatus & kFlag_ReqInProgress) != 0;
    }

    WEAVE_ERROR GetMsgEncKeyIdForAppGroup(uint32_t appGroupGlobalId, uint32_t rootKeyId, bool useRotatingKey, uint32_t& keyId);

    WEAVE_ERROR CheckMsgEncForAppGroup(const WeaveMessageInfo *msgInfo, uint32_t appGroupGlobalId, uint32_t rootKeyId, bool requireRotatingKey);

#endif // WEAVE_CONFIG_USE_APP_GROUP_KEYS_FOR_MSG_ENC

private:
    PeerIndexType PeerCount;
    MonotonicallyIncreasingCounter NextUnencUDPMsgId;
    MonotonicallyIncreasingCounter NextUnencTCPMsgId;
    WeaveSessionKey SessionKeys[WEAVE_CONFIG_MAX_SESSION_KEYS];
#if WEAVE_CONFIG_USE_APP_GROUP_KEYS_FOR_MSG_ENC
    PersistedCounter NextGroupKeyMsgId;

    // The earliest message id that will be considered "fresh" in a message counter synchronization
    // response, but only if kReqInProgressFlag is true when the response is received.
    uint32_t GroupKeyMsgIdFreshWindowStart;

    // Status flags to control message counter synchronization protocol flow and the fresh window width.
    uint16_t MsgCounterSyncStatus;
    enum
    {
        // Flag indicates if there may be outstanding request for which we may receive a response.
        kFlag_ReqInProgress                             = 0x8000,

        // Flag indicates if request has been sent in the current timeout period.
        kFlag_ReqSentThisPeriod                         = 0x4000,

        // Mask for fresh group message counter window width.
        kMask_GroupKeyMsgIdFreshWindowWidth             = 0x3FFF,
    };

    WeaveMsgEncryptionKeyCache AppKeyCache;
#endif // WEAVE_CONFIG_USE_APP_GROUP_KEYS_FOR_MSG_ENC
    struct
    {
        uint64_t NodeId[WEAVE_CONFIG_MAX_PEER_NODES];
        uint32_t MaxUnencUDPMsgIdRcvd[WEAVE_CONFIG_MAX_PEER_NODES];
#if WEAVE_CONFIG_USE_APP_GROUP_KEYS_FOR_MSG_ENC
        uint32_t MaxGroupKeyMsgIdRcvd[WEAVE_CONFIG_MAX_PEER_NODES];
        WeaveSessionState::ReceiveFlagsType GroupKeyRcvFlags[WEAVE_CONFIG_MAX_PEER_NODES];
#endif
        WeaveSessionState::ReceiveFlagsType UnencRcvFlags[WEAVE_CONFIG_MAX_PEER_NODES];
        // Array of peer indexes in sorted order from most- to least- recently used.
        PeerIndexType MostRecentlyUsedIndexes[WEAVE_CONFIG_MAX_PEER_NODES];
    } PeerStates;
    FabricStateDelegate *Delegate;

    // This structure contains information about shared session end node.
    struct SharedSessionEndNode
    {
        uint64_t EndNodeId;
        WeaveSessionKey *SessionKey;
    };
    // Record of all active shared session end nodes.
    SharedSessionEndNode SharedSessionsNodes[WEAVE_CONFIG_MAX_SHARED_SESSIONS_END_NODES];

    bool FindSharedSessionEndNode(uint64_t endNodeId, const WeaveSessionKey *sessionKey);

#if WEAVE_CONFIG_USE_APP_GROUP_KEYS_FOR_MSG_ENC
    void StartMsgCounterSyncTimer(void);
    static void OnMsgCounterSyncRespTimeout(System::Layer* aSystemLayer, void* aAppState, System::Error aError);
#endif

    bool FindOrAllocPeerEntry(uint64_t peerNodeId, bool allocEntry, PeerIndexType& retPeerIndex);
    WEAVE_ERROR FindMsgEncAppKey(uint16_t keyId, uint8_t encType, WeaveMsgEncryptionKey *& retRec);
    WEAVE_ERROR DeriveMsgEncAppKey(uint32_t keyId, uint8_t encType, WeaveMsgEncryptionKey & appKey, uint32_t& appGroupGlobalId);
};


#if WEAVE_CONFIG_SECURITY_TEST_MODE

enum
{
    kMaxEncKeyStringSize   =   WeaveEncryptionKey_AES128CTRSHA1::DataKeySize * 2      // Hex digits for data key
                             + 1                                                      // Field separator (,)
                             + WeaveEncryptionKey_AES128CTRSHA1::IntegrityKeySize * 2 // Hex digits for integrity key
                             + 1,                                                     // Null terminator
};

extern void WeaveEncryptionKeyToString(uint8_t encType, const WeaveEncryptionKey& key, char *buf, size_t bufSize);

#endif // WEAVE_CONFIG_SECURITY_TEST_MODE


} // namespace nl
} // namespace Weave

#endif // WEAVE_FABRIC_STATE_H