/*
 *
 *    Copyright (c) 2019 Google LLC.
 *    Copyright (c) 2013-2018 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 default compile-time configuration constants
 *      for Nest Weave.
 *
 *      Package integrators that wish to override these values should
 *      either use preprocessor definitions or create a project-
 *      specific WeaveProjectConfig.h header and then assert
 *      HAVE_WEAVEPROJECTCONFIG_H via the package configuration tool
 *      via --with-weave-project-includes=DIR where DIR is the
 *      directory that contains the header.
 *
 *  NOTE WELL: On some platforms, this header is included by C-language programs.
 *
 */

#ifndef WEAVE_CONFIG_H_
#define WEAVE_CONFIG_H_

#include <SystemLayer/SystemConfig.h>

/* COMING SOON: making the INET Layer optional entails making this inclusion optional. */
#include <InetLayer/InetConfig.h>

#if INET_CONFIG_ENABLE_TCP_ENDPOINT && INET_TCP_IDLE_CHECK_INTERVAL <= 0
#error "Weave SDK requires INET_TCP_IDLE_CHECK_INTERVAL > 0"
#endif // INET_CONFIG_ENABLE_TCP_ENDPOINT && INET_TCP_IDLE_CHECK_INTERVAL <= 0

/* Include a project-specific configuration file, if defined.
 *
 * An application or module that incorporates Weave can define a project configuration
 * file to override standard Weave configuration with application-specific values.
 * The WeaveProjectConfig.h file is typically located outside the OpenWeave source tree,
 * alongside the source code for the application.
 */
#ifdef WEAVE_PROJECT_CONFIG_INCLUDE
#include WEAVE_PROJECT_CONFIG_INCLUDE
#endif

/* Include a platform-specific configuration file, if defined.
 *
 * A platform configuration file contains overrides to standard Weave configuration
 * that are specific to the platform or OS on which Weave is running.  It is typically
 * provided as apart of an adaptation layer that adapts OpenWeave to the target
 * environment.  This adaptation layer may be included in the OpenWeave source tree
 * itself or implemented externally.
 */
#ifdef WEAVE_PLATFORM_CONFIG_INCLUDE
#include WEAVE_PLATFORM_CONFIG_INCLUDE
#endif

// clang-format off

/**
 *  @def WEAVE_CONFIG_PROVIDE_OBSOLESCENT_INTERFACES
 *
 *  @brief
 *    This boolean configuration option is (1) if the obsolescent interfaces
 *    of the Nest Weave layer are still available for transitional purposes.
 *
 */
#ifndef WEAVE_CONFIG_PROVIDE_OBSOLESCENT_INTERFACES
#define WEAVE_CONFIG_PROVIDE_OBSOLESCENT_INTERFACES         0
#endif //  WEAVE_CONFIG_PROVIDE_OBSOLESCENT_INTERFACES

// Profile-specific Configuration Headers

#include "WeaveBDXConfig.h"

#include "WeaveDMConfig.h"

#include "WeaveTimeConfig.h"

#include "WeaveTunnelConfig.h"

#include "WeaveEventLoggingConfig.h"

#include "WeaveWRMPConfig.h"

/**
 *  @def WEAVE_CONFIG_ERROR_TYPE
 *
 *  @brief
 *    This defines the data type used to represent errors for Weave.
 *
 */
#ifndef WEAVE_CONFIG_ERROR_TYPE
#include <stdint.h>

#define WEAVE_CONFIG_ERROR_TYPE                             int32_t
#endif // WEAVE_CONFIG_ERROR_TYPE

/**
 *  @def WEAVE_CONFIG_NO_ERROR
 *
 *  @brief
 *    This defines the Weave error code for no error or success.
 *
 */
#ifndef WEAVE_CONFIG_NO_ERROR
#define WEAVE_CONFIG_NO_ERROR                               0
#endif // WEAVE_CONFIG_NO_ERROR

/**
 *  @def WEAVE_CONFIG_ERROR_MIN
 *
 *  @brief
 *    This defines the base or minimum Weave error number range.
 *
 */
#ifndef WEAVE_CONFIG_ERROR_MIN
#define WEAVE_CONFIG_ERROR_MIN                              4000
#endif // WEAVE_CONFIG_ERROR_MIN

/**
 *  @def WEAVE_CONFIG_ERROR_MAX
 *
 *  @brief
 *    This defines the top or maximum Weave error number range.
 *
 */
#ifndef WEAVE_CONFIG_ERROR_MAX
#define WEAVE_CONFIG_ERROR_MAX                              4999
#endif // WEAVE_CONFIG_ERROR_MAX

/**
 *  @def _WEAVE_CONFIG_ERROR
 *
 *  @brief
 *    This defines a mapping function for Weave errors that allows
 *    mapping such errors into a platform- or system-specific manner.
 *
 */
#ifndef _WEAVE_CONFIG_ERROR
#define _WEAVE_CONFIG_ERROR(e)                              (WEAVE_ERROR_MIN + (e))
#endif // _WEAVE_CONFIG_ERROR

/**
 *  @def WEAVE_CONFIG_USE_OPENSSL_ECC
 *
 *  @brief
 *    Use the OpenSSL implementation of the elliptic curve primitives
 *    for Weave communication.
 *
 *    Note that this option is mutually exclusive with
 *    #WEAVE_CONFIG_USE_MICRO_ECC.
 */
#ifndef WEAVE_CONFIG_USE_OPENSSL_ECC
#define WEAVE_CONFIG_USE_OPENSSL_ECC                        1
#endif // WEAVE_CONFIG_USE_OPENSSL_ECC

/**
 *  @def WEAVE_CONFIG_USE_MICRO_ECC
 *
 *  @brief
 *    Use the Micro ECC implementation of the elliptic curve primitives
 *    for Weave communication.
 *
 *    Note that this option is mutually exclusive with
 *    #WEAVE_CONFIG_USE_OPENSSL_ECC.
 *
 */
#ifndef WEAVE_CONFIG_USE_MICRO_ECC
#define WEAVE_CONFIG_USE_MICRO_ECC                          0
#endif // WEAVE_CONFIG_USE_MICRO_ECC

#if WEAVE_CONFIG_USE_MICRO_ECC && WEAVE_CONFIG_USE_OPENSSL_ECC
#error "Please assert one of either WEAVE_CONFIG_USE_MICRO_ECC or WEAVE_CONFIG_USE_OPENSSL_ECC, but not both."
#endif // WEAVE_CONFIG_USE_MICRO_ECC && WEAVE_CONFIG_USE_OPENSSL_ECC

/**
 *  @name Weave Elliptic Curve Security Configuration
 *
 *  @brief
 *    The following definitions enable one or more of four potential
 *    elliptic curves:
 *
 *      * #WEAVE_CONFIG_SUPPORT_ELLIPTIC_CURVE_SECP160R1
 *      * #WEAVE_CONFIG_SUPPORT_ELLIPTIC_CURVE_SECP192R1
 *      * #WEAVE_CONFIG_SUPPORT_ELLIPTIC_CURVE_SECP224R1
 *      * #WEAVE_CONFIG_SUPPORT_ELLIPTIC_CURVE_SECP256R1
 *
 *  @{
 */

/**
 *  @def WEAVE_CONFIG_SUPPORT_ELLIPTIC_CURVE_SECP160R1
 *
 *  @brief
 *    Enable (1) or disable (0) support for the Standards for
 *    Efficient Cryptography Group (SECG) secp160r1 elliptic curve.
 *
 */
#ifndef WEAVE_CONFIG_SUPPORT_ELLIPTIC_CURVE_SECP160R1
#define WEAVE_CONFIG_SUPPORT_ELLIPTIC_CURVE_SECP160R1       0
#endif // WEAVE_CONFIG_SUPPORT_ELLIPTIC_CURVE_SECP160R1

/**
 *  @def WEAVE_CONFIG_SUPPORT_ELLIPTIC_CURVE_SECP192R1
 *
 *  @brief
 *    Enable (1) or disable (0) support for the Standards for
 *    Efficient Cryptography Group (SECG) secp192r1 elliptic curve.
 *
 */
#ifndef WEAVE_CONFIG_SUPPORT_ELLIPTIC_CURVE_SECP192R1
#define WEAVE_CONFIG_SUPPORT_ELLIPTIC_CURVE_SECP192R1       1
#endif // WEAVE_CONFIG_SUPPORT_ELLIPTIC_CURVE_SECP192R1

/**
 *  @def WEAVE_CONFIG_SUPPORT_ELLIPTIC_CURVE_SECP224R1
 *
 *  @brief
 *    Enable (1) or disable (0) support for the Standards for
 *    Efficient Cryptography Group (SECG) secp224r1 / National
 *    Institute of Standards (NIST) P-224 elliptic curve.
 *
 */
#ifndef WEAVE_CONFIG_SUPPORT_ELLIPTIC_CURVE_SECP224R1
#define WEAVE_CONFIG_SUPPORT_ELLIPTIC_CURVE_SECP224R1       1
#endif // WEAVE_CONFIG_SUPPORT_ELLIPTIC_CURVE_SECP224R1

/**
 *  @def WEAVE_CONFIG_SUPPORT_ELLIPTIC_CURVE_SECP256R1
 *
 *  @brief
 *    Enable (1) or disable (0) support for the Standards for
 *    Efficient Cryptography Group (SECG) secp256r1 / American
 *    National Standards Institute (ANSI) prime256v1 / National
 *    Institute of Standards (NIST) P-256 elliptic curve.
 *
 */
#ifndef WEAVE_CONFIG_SUPPORT_ELLIPTIC_CURVE_SECP256R1
#define WEAVE_CONFIG_SUPPORT_ELLIPTIC_CURVE_SECP256R1       1
#endif // WEAVE_CONFIG_SUPPORT_ELLIPTIC_CURVE_SECP256R1

/**
 *  @}
 */

/**
 *  @name Weave Password Authenticated Session Establishment (PASE) Configuration
 *
 *  @brief
 *    The following definitions define the configurations supported
 *    for Weave's Password Authenticated Session Establishment (PASE)
 *    protocol.
 *
 *    This protocol is used primarily for establishing a secure
 *    session for provisioning. Weave supports the following PASE
 *    configurations:
 *
 *    * #WEAVE_CONFIG_SUPPORT_PASE_CONFIG0_TEST_ONLY
 *    * #WEAVE_CONFIG_SUPPORT_PASE_CONFIG1
 *    * #WEAVE_CONFIG_SUPPORT_PASE_CONFIG2
 *    * #WEAVE_CONFIG_SUPPORT_PASE_CONFIG3
 *    * #WEAVE_CONFIG_SUPPORT_PASE_CONFIG4
 *    * #WEAVE_CONFIG_SUPPORT_PASE_CONFIG5
 *
 *    which are summarized in the table below:
 *
 *    | Configuration  |  J-PAKE Style   |   Curve   |  Test Only  | Notes                                |
 *    | :------------: | :-------------- | :-------: | :---------: | :----------------------------------- |
 *    | 0              | -               | -         | Y           | Test-only                            |
 *    | 1              | Finite Field    | -         | N           | Original Weave default configuration |
 *    | 2              | Elliptic Curve  | secp160r1 | N           |                                      |
 *    | 3              | Elliptic Curve  | secp192r1 | N           |                                      |
 *    | 4              | Elliptic Curve  | secp224r1 | N           | Future Weave default configuration   |
 *    | 5              | Elliptic Curve  | secp256r1 | N           |                                      |
 *
 *  @{
 *
 */

/**
 *  @def WEAVE_CONFIG_SUPPORT_PASE_CONFIG0_TEST_ONLY
 *
 *  @brief
 *    This Weave PASE configuration does not use the J-PAKE algorithm
 *    and sends deterministic messages over the communications
 *    channel. The size and structure of the messages are similar to
 *    #WEAVE_CONFIG_SUPPORT_PASE_CONFIG5.
 *
 *  @note The results of this configuration are insecure because the
 *        computational overhead of the cryptography has largely been
 *        disabled since the focus of this configuration is testing
 *        the overall PASE protocol exchange, independently of the
 *        cryptography.
 *
 */
#ifndef WEAVE_CONFIG_SUPPORT_PASE_CONFIG0_TEST_ONLY
#define WEAVE_CONFIG_SUPPORT_PASE_CONFIG0_TEST_ONLY         0
#endif // WEAVE_CONFIG_SUPPORT_PASE_CONFIG0_TEST_ONLY

/**
 *  @def WEAVE_CONFIG_SUPPORT_PASE_CONFIG1
 *
 *  @brief
 *    This Weave PASE configuration uses Finite Field J-PAKE and is
 *    the original, default Weave PASE configuration.
 *
 */
#ifndef WEAVE_CONFIG_SUPPORT_PASE_CONFIG1
#define WEAVE_CONFIG_SUPPORT_PASE_CONFIG1                   1
#endif // WEAVE_CONFIG_SUPPORT_PASE_CONFIG1

/**
 *  @def WEAVE_CONFIG_SUPPORT_PASE_CONFIG2
 *
 *  @brief
 *    This Weave PASE configuration uses Elliptic Curve J-PAKE with a
 *    SECG secp160r1 curve.
 *
 *    @note When this PASE configuration is enabled, the corresponding
 *          elliptic curve (i.e. #WEAVE_CONFIG_SUPPORT_ELLIPTIC_CURVE_SECP160R1)
 *          should also be enabled.
 *
 */
#ifndef WEAVE_CONFIG_SUPPORT_PASE_CONFIG2
#define WEAVE_CONFIG_SUPPORT_PASE_CONFIG2                   0
#endif // WEAVE_CONFIG_SUPPORT_PASE_CONFIG2

/**
 *  @def WEAVE_CONFIG_SUPPORT_PASE_CONFIG3
 *
 *  @brief
 *    This Weave PASE configuration uses Elliptic Curve J-PAKE with a
 *    SECG secp192r1 curve.
 *
 *    @note When this PASE configuration is enabled, the corresponding
 *          elliptic curve (i.e. #WEAVE_CONFIG_SUPPORT_ELLIPTIC_CURVE_SECP192R1)
 *          should also be enabled.
 *
 */
#ifndef WEAVE_CONFIG_SUPPORT_PASE_CONFIG3
#define WEAVE_CONFIG_SUPPORT_PASE_CONFIG3                   0
#endif // WEAVE_CONFIG_SUPPORT_PASE_CONFIG3

/**
 *  @def WEAVE_CONFIG_SUPPORT_PASE_CONFIG4
 *
 *  @brief
 *    This Weave PASE configuration uses Elliptic Curve J-PAKE with a
 *    SECG secp224r1 curve and will be the new, default Weave PASE
 *    configuration.
 *
 *    @note When this PASE configuration is enabled, the corresponding
 *          elliptic curve (i.e. #WEAVE_CONFIG_SUPPORT_ELLIPTIC_CURVE_SECP224R1)
 *          should also be enabled.
 *
 */
#ifndef WEAVE_CONFIG_SUPPORT_PASE_CONFIG4
#define WEAVE_CONFIG_SUPPORT_PASE_CONFIG4                   1
#endif // WEAVE_CONFIG_SUPPORT_PASE_CONFIG4

/**
 *  @def WEAVE_CONFIG_SUPPORT_PASE_CONFIG5
 *
 *  @brief
 *    This Weave PASE configuration uses Elliptic Curve J-PAKE with a
 *    SECG secp256r1 curve.
 *
 *    @note When this PASE configuration is enabled, the corresponding
 *          elliptic curve (i.e. #WEAVE_CONFIG_SUPPORT_ELLIPTIC_CURVE_SECP256R1)
 *          should also be enabled.
 *
 */
#ifndef WEAVE_CONFIG_SUPPORT_PASE_CONFIG5
#define WEAVE_CONFIG_SUPPORT_PASE_CONFIG5                   0
#endif // WEAVE_CONFIG_SUPPORT_PASE_CONFIG5

/**
 *  @}
 */

#if WEAVE_CONFIG_SUPPORT_PASE_CONFIG2 && !WEAVE_CONFIG_SUPPORT_ELLIPTIC_CURVE_SECP160R1
#error "Please assert WEAVE_CONFIG_SUPPORT_ELLIPTIC_CURVE_SECP160R1 when WEAVE_CONFIG_SUPPORT_PASE_CONFIG2 is asserted"
#endif // WEAVE_CONFIG_SUPPORT_PASE_CONFIG2 && !WEAVE_CONFIG_SUPPORT_ELLIPTIC_CURVE_SECP160R1

#if WEAVE_CONFIG_SUPPORT_PASE_CONFIG3 && !WEAVE_CONFIG_SUPPORT_ELLIPTIC_CURVE_SECP192R1
#error "Please assert WEAVE_CONFIG_SUPPORT_ELLIPTIC_CURVE_SECP192R1 when WEAVE_CONFIG_SUPPORT_PASE_CONFIG3 is asserted"
#endif // WEAVE_CONFIG_SUPPORT_PASE_CONFIG3 && !WEAVE_CONFIG_SUPPORT_ELLIPTIC_CURVE_SECP192R1

#if WEAVE_CONFIG_SUPPORT_PASE_CONFIG4 && !WEAVE_CONFIG_SUPPORT_ELLIPTIC_CURVE_SECP224R1
#error "Please assert WEAVE_CONFIG_SUPPORT_ELLIPTIC_CURVE_SECP224R1 when WEAVE_CONFIG_SUPPORT_PASE_CONFIG4 is asserted"
#endif // WEAVE_CONFIG_SUPPORT_PASE_CONFIG4 && !WEAVE_CONFIG_SUPPORT_ELLIPTIC_CURVE_SECP224R1

#if WEAVE_CONFIG_SUPPORT_PASE_CONFIG5 && !WEAVE_CONFIG_SUPPORT_ELLIPTIC_CURVE_SECP256R1
#error "Please assert WEAVE_CONFIG_SUPPORT_ELLIPTIC_CURVE_SECP256R1 when WEAVE_CONFIG_SUPPORT_PASE_CONFIG5 is asserted"
#endif // WEAVE_CONFIG_SUPPORT_PASE_CONFIG5 && !WEAVE_CONFIG_SUPPORT_ELLIPTIC_CURVE_SECP256R1

/**
 *  @def WEAVE_CONFIG_PASE_MESSAGE_PAYLOAD_ALIGNMENT
 *
 *  @brief
 *    Align payload on 4-byte boundary for PASE messages.
 *    Currently, payload alignment is required only when micro-ecc
 *    library is used and it is compiled with ARM assembly.
 *    If implementation guarantees that payload is always 4-byte
 *    aligned this option should stay deasserted to save code size.
 *
 */
#ifndef WEAVE_CONFIG_PASE_MESSAGE_PAYLOAD_ALIGNMENT
#if WEAVE_CONFIG_USE_MICRO_ECC
#define WEAVE_CONFIG_PASE_MESSAGE_PAYLOAD_ALIGNMENT         1
#else
#define WEAVE_CONFIG_PASE_MESSAGE_PAYLOAD_ALIGNMENT         0
#endif // WEAVE_CONFIG_USE_MICRO_ECC
#endif // WEAVE_CONFIG_PASE_MESSAGE_PAYLOAD_ALIGNMENT

/**
 *  @def WEAVE_CONFIG_PASE_RATE_LIMITER_TIMEOUT
 *
 *  @brief
 *    The amount of time (in milliseconds) in which the Security Manager
 *    is allowed to have maximum #WEAVE_CONFIG_PASE_RATE_LIMITER_MAX_ATTEMPTS
 *    counted PASE attempts.
 *
 */
#ifndef WEAVE_CONFIG_PASE_RATE_LIMITER_TIMEOUT
#define WEAVE_CONFIG_PASE_RATE_LIMITER_TIMEOUT              15000
#endif // WEAVE_CONFIG_PASE_RATE_LIMITER_TIMEOUT

/**
 *  @def WEAVE_CONFIG_PASE_RATE_LIMITER_MAX_ATTEMPTS
 *
 *  @brief
 *    The maximum number of PASE attempts after which the
 *    next PASE session establishment attempt will be allowed
 *    only after #WEAVE_CONFIG_PASE_RATE_LIMITER_TIMEOUT expires.
 *     * For PASE negotiations with key confirmation option enabled:
 *       only attempts that failed with key confirmation error are counted.
 *       Successful PASE negotiations do not reset the rate limiter.
 *     * For PASE negotiations with key confirmation option disabled:
 *       every PASE negotiation, successful or otherwise, is added
 *       to the rate limiter.
 *
 */
#ifndef WEAVE_CONFIG_PASE_RATE_LIMITER_MAX_ATTEMPTS
#define WEAVE_CONFIG_PASE_RATE_LIMITER_MAX_ATTEMPTS         3
#endif // WEAVE_CONFIG_PASE_RATE_LIMITER_MAX_ATTEMPTS

/**
 *  @name Weave Security Manager Memory Management Configuration
 *
 *  @brief
 *    The following definitions enable one of three potential Weave
 *    Security Manager memory-management options:
 *
 *      * #WEAVE_CONFIG_SECURITY_MGR_MEMORY_MGMT_PLATFORM
 *      * #WEAVE_CONFIG_SECURITY_MGR_MEMORY_MGMT_SIMPLE
 *      * #WEAVE_CONFIG_SECURITY_MGR_MEMORY_MGMT_MALLOC
 *
 *    Note that these options are mutually exclusive and only one
 *    of these options should be set.
 *
 *  @{
 */

/**
 *  @def WEAVE_CONFIG_SECURITY_MGR_MEMORY_MGMT_PLATFORM
 *
 *  @brief
 *    Enable (1) or disable (0) support for platform-specific
 *    implementation of Weave Security Manager memory-management
 *    functions.
 *
 *  @note This configuration is mutual exclusive with
 *        #WEAVE_CONFIG_SECURITY_MGR_MEMORY_MGMT_SIMPLE and
 *        #WEAVE_CONFIG_SECURITY_MGR_MEMORY_MGMT_MALLOC.
 *
 */
#ifndef WEAVE_CONFIG_SECURITY_MGR_MEMORY_MGMT_PLATFORM
#define WEAVE_CONFIG_SECURITY_MGR_MEMORY_MGMT_PLATFORM      0
#endif // WEAVE_CONFIG_SECURITY_MGR_MEMORY_MGMT_PLATFORM

/**
 *  @def WEAVE_CONFIG_SECURITY_MGR_MEMORY_MGMT_SIMPLE
 *
 *  @brief
 *    Enable (1) or disable (0) support for a Weave-provided
 *    implementation of Weave Security Manager memory-management
 *    functions based on temporary network buffer allocation /
 *    release.
 *
 *  @note This configuration is mutual exclusive with
 *        #WEAVE_CONFIG_SECURITY_MGR_MEMORY_MGMT_PLATFORM and
 *        #WEAVE_CONFIG_SECURITY_MGR_MEMORY_MGMT_MALLOC.
 *
 */
#ifndef WEAVE_CONFIG_SECURITY_MGR_MEMORY_MGMT_SIMPLE
#define WEAVE_CONFIG_SECURITY_MGR_MEMORY_MGMT_SIMPLE        0
#endif // WEAVE_CONFIG_SECURITY_MGR_MEMORY_MGMT_SIMPLE

/**
 *  @def WEAVE_CONFIG_SECURITY_MGR_MEMORY_MGMT_MALLOC
 *
 *  @brief
 *    Enable (1) or disable (0) support for a Weave-provided
 *    implementation of Weave Security Manager memory-management
 *    functions based on the C Standard Library malloc / free
 *    functions.
 *
 *  @note This configuration is mutual exclusive with
 *        #WEAVE_CONFIG_SECURITY_MGR_MEMORY_MGMT_PLATFORM and
 *        #WEAVE_CONFIG_SECURITY_MGR_MEMORY_MGMT_SIMPLE.
 *
 */
#ifndef WEAVE_CONFIG_SECURITY_MGR_MEMORY_MGMT_MALLOC
#define WEAVE_CONFIG_SECURITY_MGR_MEMORY_MGMT_MALLOC        1
#endif // WEAVE_CONFIG_SECURITY_MGR_MEMORY_MGMT_MALLOC

/**
 *  @}
 */

#if ((WEAVE_CONFIG_SECURITY_MGR_MEMORY_MGMT_PLATFORM + WEAVE_CONFIG_SECURITY_MGR_MEMORY_MGMT_SIMPLE + WEAVE_CONFIG_SECURITY_MGR_MEMORY_MGMT_MALLOC) != 1)
#error "Please assert exactly one of WEAVE_CONFIG_SECURITY_MGR_MEMORY_MGMT_PLATFORM, WEAVE_CONFIG_SECURITY_MGR_MEMORY_MGMT_SIMPLE, or WEAVE_CONFIG_SECURITY_MGR_MEMORY_MGMT_MALLOC."
#endif // ((WEAVE_CONFIG_SECURITY_MGR_MEMORY_MGMT_PLATFORM + WEAVE_CONFIG_SECURITY_MGR_MEMORY_MGMT_SIMPLE + WEAVE_CONFIG_SECURITY_MGR_MEMORY_MGMT_MALLOC) != 1)

/**
 *  @def WEAVE_CONFIG_SIMPLE_ALLOCATOR_USE_SMALL_BUFFERS
 *
 *  @brief
 *    Enable (1) or disable (0) simple memory allocator support
 *    for small size network buffers. When enabled, this configuration
 *    requires 4 network buffers with minimum available payload size of
 *    600 bytes.
 *
 *  @note This configuration is only relevant when
 *        #WEAVE_CONFIG_SECURITY_MGR_MEMORY_MGMT_SIMPLE is set and
 *        ignored otherwise.
 *
 */
#ifndef WEAVE_CONFIG_SIMPLE_ALLOCATOR_USE_SMALL_BUFFERS
#define WEAVE_CONFIG_SIMPLE_ALLOCATOR_USE_SMALL_BUFFERS     0
#endif // WEAVE_CONFIG_SIMPLE_ALLOCATOR_USE_SMALL_BUFFERS

/**
 *  @name Weave Security Manager Time-Consuming Crypto Alerts.
 *
 *  @brief
 *    The following definitions enable one of two potential Weave
 *    Security Manager time-consuming crypto alerts implementations:
 *
 *      * #WEAVE_CONFIG_SECURITY_MGR_TIME_ALERTS_DUMMY
 *      * #WEAVE_CONFIG_SECURITY_MGR_TIME_ALERTS_PLATFORM
 *
 *    Note that these options are mutually exclusive and only one
 *    of these options should be set.
 *
 *  @{
 */

/**
 *  @def WEAVE_CONFIG_SECURITY_MGR_TIME_ALERTS_DUMMY
 *
 *  @brief
 *    Enable (1) or disable (0) support for Weave-provided dummy
 *    implementation of Weave security manager time-consuming
 *    crypto alerts functions.
 *
 *  @note This configuration is mutual exclusive with
 *        #WEAVE_CONFIG_SECURITY_MGR_TIME_ALERTS_PLATFORM.
 *
 */
#ifndef WEAVE_CONFIG_SECURITY_MGR_TIME_ALERTS_DUMMY
#define WEAVE_CONFIG_SECURITY_MGR_TIME_ALERTS_DUMMY         1
#endif // WEAVE_CONFIG_SECURITY_MGR_TIME_ALERTS_DUMMY

/**
 *  @def WEAVE_CONFIG_SECURITY_MGR_TIME_ALERTS_PLATFORM
 *
 *  @brief
 *    Enable (1) or disable (0) support for a platform-specific
 *    implementation of Weave security manager time-consuming
 *    crypto alerts functions.
 *
 *  @note This configuration is mutual exclusive with
 *        #WEAVE_CONFIG_SECURITY_MGR_TIME_ALERTS_DUMMY.
 *
 */
#ifndef WEAVE_CONFIG_SECURITY_MGR_TIME_ALERTS_PLATFORM
#define WEAVE_CONFIG_SECURITY_MGR_TIME_ALERTS_PLATFORM      0
#endif // WEAVE_CONFIG_SECURITY_MGR_TIME_ALERTS_PLATFORM

/**
 *  @}
 */

#if ((WEAVE_CONFIG_SECURITY_MGR_TIME_ALERTS_DUMMY + WEAVE_CONFIG_SECURITY_MGR_TIME_ALERTS_PLATFORM) != 1)
#error "Please assert exactly one of WEAVE_CONFIG_SECURITY_MGR_TIME_ALERTS_DUMMY or WEAVE_CONFIG_SECURITY_MGR_TIME_ALERTS_PLATFORM."
#endif // ((WEAVE_CONFIG_SECURITY_MGR_TIME_ALERTS_DUMMY + WEAVE_CONFIG_SECURITY_MGR_TIME_ALERTS_PLATFORM) != 1)

/**
 *  @name Weave Random Number Generator (RNG) Implementation Configuration
 *
 *  @brief
 *    The following definitions enable one of three potential Weave
 *    RNG implementation options:
 *
 *      * #WEAVE_CONFIG_RNG_IMPLEMENTATION_PLATFORM
 *      * #WEAVE_CONFIG_RNG_IMPLEMENTATION_NESTDRBG
 *      * #WEAVE_CONFIG_RNG_IMPLEMENTATION_OPENSSL
 *
 *    Note that these options are mutually exclusive and only one of
 *    these options should be set.
 *
 *  @{
 */

/**
 *  @def WEAVE_CONFIG_RNG_IMPLEMENTATION_PLATFORM
 *
 *  @brief
 *    Enable (1) or disable (0) support for platform-specific
 *    implementation of the Weave Random Number Generator.
 *
 *  @note This configuration is mutual exclusive with
 *        #WEAVE_CONFIG_RNG_IMPLEMENTATION_NESTDRBG and
 *        #WEAVE_CONFIG_RNG_IMPLEMENTATION_OPENSSL.
 *
 */
#ifndef WEAVE_CONFIG_RNG_IMPLEMENTATION_PLATFORM
#define WEAVE_CONFIG_RNG_IMPLEMENTATION_PLATFORM            0
#endif // WEAVE_CONFIG_RNG_IMPLEMENTATION_PLATFORM

/**
 *  @def WEAVE_CONFIG_RNG_IMPLEMENTATION_NESTDRBG
 *
 *  @brief
 *    Enable (1) or disable (0) support for a Weave-provided
 *    implementation of the Weave Random Number Generator.
 *    This implementation is based on AES-CTR DRBG as
 *    specified in the NIST SP800-90A document.
 *
 *  @note This configuration is mutual exclusive with
 *        #WEAVE_CONFIG_RNG_IMPLEMENTATION_PLATFORM and
 *        #WEAVE_CONFIG_RNG_IMPLEMENTATION_OPENSSL.
 *
 */
#ifndef WEAVE_CONFIG_RNG_IMPLEMENTATION_NESTDRBG
#define WEAVE_CONFIG_RNG_IMPLEMENTATION_NESTDRBG            0
#endif // WEAVE_CONFIG_RNG_IMPLEMENTATION_NESTDRBG

/**
 *  @def WEAVE_CONFIG_RNG_IMPLEMENTATION_OPENSSL
 *
 *  @brief
 *    Enable (1) or disable (0) support for a standard OpenSSL
 *    implementation of the Weave Random Number Generator.
 *
 *  @note This configuration is mutual exclusive with
 *        #WEAVE_CONFIG_RNG_IMPLEMENTATION_PLATFORM and
 *        #WEAVE_CONFIG_RNG_IMPLEMENTATION_NESTDRBG.
 *
 */
#ifndef WEAVE_CONFIG_RNG_IMPLEMENTATION_OPENSSL
#define WEAVE_CONFIG_RNG_IMPLEMENTATION_OPENSSL             1
#endif // WEAVE_CONFIG_RNG_IMPLEMENTATION_OPENSSL

/**
 *  @}
 */

#if ((WEAVE_CONFIG_RNG_IMPLEMENTATION_PLATFORM + WEAVE_CONFIG_RNG_IMPLEMENTATION_NESTDRBG + WEAVE_CONFIG_RNG_IMPLEMENTATION_OPENSSL) != 1)
#error "Please assert exactly one of WEAVE_CONFIG_RNG_IMPLEMENTATION_PLATFORM, WEAVE_CONFIG_RNG_IMPLEMENTATION_NESTDRBG, or WEAVE_CONFIG_RNG_IMPLEMENTATION_OPENSSL."
#endif // ((WEAVE_CONFIG_RNG_IMPLEMENTATION_PLATFORM + WEAVE_CONFIG_RNG_IMPLEMENTATION_NESTDRBG + WEAVE_CONFIG_RNG_IMPLEMENTATION_OPENSSL) != 1)


/**
 *  @def WEAVE_CONFIG_DEV_RANDOM_DRBG_SEED
 *
 *  @brief
 *    Enable (1) or disable (0) a function for seeding the DRBG with
 *    entropy from the /dev/(u)random device.
 *
 *  @note When enabled along with #WEAVE_CONFIG_RNG_IMPLEMENTATION_NESTDRBG
 *        this function becomes the default seeding function for the DRBG if
 *        another isn't specified at initialization time.
 *
 */
#ifndef WEAVE_CONFIG_DEV_RANDOM_DRBG_SEED
#define WEAVE_CONFIG_DEV_RANDOM_DRBG_SEED              0
#endif // WEAVE_CONFIG_DEV_RANDOM_DRBG_SEED

/**
 *  @def WEAVE_CONFIG_DEV_RANDOM_DEVICE_NAME
 *
 *  @brief
 *    The device name used by the dev random entropy function.
 *
 *  @note Only meaningful when #WEAVE_CONFIG_DEV_RANDOM_DRBG_SEED is enabled.
 *
 */
#ifndef WEAVE_CONFIG_DEV_RANDOM_DEVICE_NAME
#define WEAVE_CONFIG_DEV_RANDOM_DEVICE_NAME                 "/dev/urandom"
#endif // WEAVE_CONFIG_DEV_RANDOM_DEVICE_NAME


/**
 *  @name Weave AES Block Cipher Algorithm Implementation Configuration.
 *
 *  @brief
 *    The following definitions enable one of the potential Weave
 *    AES implementation options:
 *
 *      * #WEAVE_CONFIG_AES_IMPLEMENTATION_PLATFORM
 *      * #WEAVE_CONFIG_AES_IMPLEMENTATION_OPENSSL
 *
 *    Note that these options are mutually exclusive and only one of
 *    these options should be set.
 *
 *  @{
 */

/**
 *  @def WEAVE_CONFIG_AES_IMPLEMENTATION_PLATFORM
 *
 *  @brief
 *    Enable (1) or disable (0) support for platform-specific
 *    implementation of the Weave AES functions.
 *
 *  @note This configuration is mutual exclusive with
 *        #WEAVE_CONFIG_AES_IMPLEMENTATION_OPENSSL and
 *        #WEAVE_CONFIG_AES_IMPLEMENTATION_AESNI
 *
 */
#ifndef WEAVE_CONFIG_AES_IMPLEMENTATION_PLATFORM
#define WEAVE_CONFIG_AES_IMPLEMENTATION_PLATFORM            0
#endif // WEAVE_CONFIG_AES_IMPLEMENTATION_PLATFORM

/**
 *  @def WEAVE_CONFIG_AES_IMPLEMENTATION_OPENSSL
 *
 *  @brief
 *    Enable (1) or disable (0) support for the OpenSSL
 *    implementation of the Weave AES functions.
 *
 *  @note This configuration is mutual exclusive with other
 *        WEAVE_CONFIG_AES_IMPLEMENTATION options.
 *
 */
#ifndef WEAVE_CONFIG_AES_IMPLEMENTATION_OPENSSL
#define WEAVE_CONFIG_AES_IMPLEMENTATION_OPENSSL             1
#endif // WEAVE_CONFIG_AES_IMPLEMENTATION_OPENSSL

/**
 *  @def WEAVE_CONFIG_AES_IMPLEMENTATION_AESNI
 *
 *  @brief
 *    Enable (1) or disable (0) support for an implementation
 *    of the Weave AES functions using Intel AES-NI intrinsics.
 *
 *  @note This configuration is mutual exclusive with other
 *        WEAVE_CONFIG_AES_IMPLEMENTATION options.
 *
 */
#ifndef WEAVE_CONFIG_AES_IMPLEMENTATION_AESNI
#define WEAVE_CONFIG_AES_IMPLEMENTATION_AESNI              0
#endif // WEAVE_CONFIG_AES_IMPLEMENTATION_AESNI

/**
 *  @def WEAVE_CONFIG_AES_IMPLEMENTATION_MBEDTLS
 *
 *  @brief
 *    Enable (1) or disable (0) support the mbed TLS
 *    implementation of the Weave AES functions.
 *
 *  @note This configuration is mutual exclusive with other
 *        WEAVE_CONFIG_AES_IMPLEMENTATION options.
 *
 */
#ifndef WEAVE_CONFIG_AES_IMPLEMENTATION_MBEDTLS
#define WEAVE_CONFIG_AES_IMPLEMENTATION_MBEDTLS              0
#endif // WEAVE_CONFIG_AES_IMPLEMENTATION_MBEDTLS

/**
 *  @}
 */

#if ((WEAVE_CONFIG_AES_IMPLEMENTATION_PLATFORM + \
      WEAVE_CONFIG_AES_IMPLEMENTATION_OPENSSL + \
      WEAVE_CONFIG_AES_IMPLEMENTATION_AESNI + \
      WEAVE_CONFIG_AES_IMPLEMENTATION_MBEDTLS) != 1)
#error "Please assert exactly one WEAVE_CONFIG_AES_IMPLEMENTATION_... option."
#endif

/**
 *  @def WEAVE_CONFIG_AES_USE_EXPANDED_KEY
 *
 *  @brief
 *    Defines whether AES key is used in its expanded (1) or native (0) form.
 *
 *  @note OpenSSL AES implementation uses its own AES key declaration
 *        and this configuration option is ignored when
 *        #WEAVE_CONFIG_AES_IMPLEMENTATION_OPENSSL is set.
 *
 */
#ifndef WEAVE_CONFIG_AES_USE_EXPANDED_KEY
#define WEAVE_CONFIG_AES_USE_EXPANDED_KEY                   0
#endif // WEAVE_CONFIG_AES_USE_EXPANDED_KEY


/**
 *  @name Weave SHA1 and SHA256 Hash Algorithms Implementation Configuration.
 *
 *  @brief
 *    The following definitions enable one of three potential Weave
 *    hash implementation options:
 *
 *      * #WEAVE_CONFIG_HASH_IMPLEMENTATION_PLATFORM
 *      * #WEAVE_CONFIG_HASH_IMPLEMENTATION_MINCRYPT
 *      * #WEAVE_CONFIG_HASH_IMPLEMENTATION_OPENSSL
 *      * #WEAVE_CONFIG_HASH_IMPLEMENTATION_MBEDTLS
 *
 *    Note that these options are mutually exclusive and only one of
 *    these options should be set.
 *
 *  @{
 */

/**
 *  @def WEAVE_CONFIG_HASH_IMPLEMENTATION_PLATFORM
 *
 *  @brief
 *    Enable (1) or disable (0) support for platform-specific
 *    implementation of the Weave SHA1 and SHA256 hashes.
 *
 *  @note This configuration is mutual exclusive with other
 *        WEAVE_CONFIG_HASH_IMPLEMENTATION options.
 *
 */
#ifndef WEAVE_CONFIG_HASH_IMPLEMENTATION_PLATFORM
#define WEAVE_CONFIG_HASH_IMPLEMENTATION_PLATFORM           0
#endif // WEAVE_CONFIG_HASH_IMPLEMENTATION_PLATFORM

/**
 *  @def WEAVE_CONFIG_HASH_IMPLEMENTATION_MINCRYPT
 *
 *  @brief
 *    Enable (1) or disable (0) support for a Weave-provided
 *    implementation of the Weave SHA1 and SHA256 hash functions.
 *    This implementation is using sha1 and sha256 engines from
 *    mincrypt library of Android core.
 *
 *  @note This configuration is mutual exclusive with other
 *        WEAVE_CONFIG_HASH_IMPLEMENTATION options.
 *
 */
#ifndef WEAVE_CONFIG_HASH_IMPLEMENTATION_MINCRYPT
#define WEAVE_CONFIG_HASH_IMPLEMENTATION_MINCRYPT           0
#endif // WEAVE_CONFIG_HASH_IMPLEMENTATION_MINCRYPT

/**
 *  @def WEAVE_CONFIG_HASH_IMPLEMENTATION_OPENSSL
 *
 *  @brief
 *    Enable (1) or disable (0) support for the OpenSSL
 *    implementation of the Weave SHA1 and SHA256 hash functions.
 *
 *  @note This configuration is mutual exclusive with other
 *        WEAVE_CONFIG_HASH_IMPLEMENTATION options.
 *
 */
#ifndef WEAVE_CONFIG_HASH_IMPLEMENTATION_OPENSSL
#define WEAVE_CONFIG_HASH_IMPLEMENTATION_OPENSSL            1
#endif // WEAVE_CONFIG_HASH_IMPLEMENTATION_OPENSSL

/**
 *  @def WEAVE_CONFIG_HASH_IMPLEMENTATION_MBEDTLS
 *
 *  @brief
 *    Enable (1) or disable (0) support for the mbedTLS
 *    implementation of the Weave SHA1 and SHA256 hash functions.
 *
 *  @note This configuration is mutual exclusive with other
 *        WEAVE_CONFIG_HASH_IMPLEMENTATION options.
 *
 */
#ifndef WEAVE_CONFIG_HASH_IMPLEMENTATION_MBEDTLS
#define WEAVE_CONFIG_HASH_IMPLEMENTATION_MBEDTLS            0
#endif // WEAVE_CONFIG_HASH_IMPLEMENTATION_MBEDTLS

/**
 *  @}
 */

#if ((WEAVE_CONFIG_HASH_IMPLEMENTATION_PLATFORM + \
      WEAVE_CONFIG_HASH_IMPLEMENTATION_MINCRYPT + \
      WEAVE_CONFIG_HASH_IMPLEMENTATION_OPENSSL  + \
      WEAVE_CONFIG_HASH_IMPLEMENTATION_MBEDTLS) != 1)
#error "Please assert exactly one WEAVE_CONFIG_HASH_IMPLEMENTATION_... option."
#endif


/**
 *  @name Weave key export protocol configuration.
 *
 *  @brief
 *    The following definitions define the configurations supported
 *    for Weave's key export protocol.
 *
 *    This protocol is used to export secret key material from Weave device.
 *    Weave supports the following protocol configurations:
 *
 *    * #WEAVE_CONFIG_SUPPORT_KEY_EXPORT_CONFIG1
 *    * #WEAVE_CONFIG_SUPPORT_KEY_EXPORT_CONFIG2
 *
 *    which are summarized in the table below:
 *
 *    | Configuration  |   Curve   | Notes                   |
 *    | :------------: | :-------: | :---------------------- |
 *    | 1              | secp224r1 | Default configuration   |
 *    | 2              | secp256r1 |                         |
 *
 *  @{
 *
 */

/**
 *  @def WEAVE_CONFIG_SUPPORT_KEY_EXPORT_CONFIG1
 *
 *  @brief
 *    This Weave key export protocol configuration uses secp224r1
 *    Elliptic Curve.
 *
 */
#ifndef WEAVE_CONFIG_SUPPORT_KEY_EXPORT_CONFIG1
#define WEAVE_CONFIG_SUPPORT_KEY_EXPORT_CONFIG1            1
#endif // WEAVE_CONFIG_SUPPORT_KEY_EXPORT_CONFIG1

/**
 *  @def WEAVE_CONFIG_SUPPORT_KEY_EXPORT_CONFIG2
 *
 *  @brief
 *    This Weave key export protocol configuration uses secp256r1
 *    Elliptic Curve.
 *
 */
#ifndef WEAVE_CONFIG_SUPPORT_KEY_EXPORT_CONFIG2
#define WEAVE_CONFIG_SUPPORT_KEY_EXPORT_CONFIG2            1
#endif // WEAVE_CONFIG_SUPPORT_KEY_EXPORT_CONFIG2

/**
 *  @}
 */


/**
 *  @def WEAVE_CONFIG_ALLOW_NON_STANDARD_ELLIPTIC_CURVES
 *
 *  @brief
 *    Allow the use of elliptic curves beyond the standard ones
 *    supported by Weave.
 *
 */
#ifndef WEAVE_CONFIG_ALLOW_NON_STANDARD_ELLIPTIC_CURVES
#define WEAVE_CONFIG_ALLOW_NON_STANDARD_ELLIPTIC_CURVES     0
#endif // WEAVE_CONFIG_ALLOW_NON_STANDARD_ELLIPTIC_CURVES

/**
 *  @def WEAVE_CONFIG_MAX_EC_BITS
 *
 *  @brief
 *    The maximum size elliptic curve supported, in bits.
 *
 */
#ifndef WEAVE_CONFIG_MAX_EC_BITS
#define WEAVE_CONFIG_MAX_EC_BITS                            256
#endif // WEAVE_CONFIG_MAX_EC_BITS

/**
 *  @def WEAVE_CONFIG_MAX_RSA_BITS
 *
 *  @brief
 *    The maximum size RSA modulus supported, in bits.
 *
 */
#ifndef WEAVE_CONFIG_MAX_RSA_BITS
#define WEAVE_CONFIG_MAX_RSA_BITS                           4096
#endif // WEAVE_CONFIG_MAX_RSA_BITS

/**
 *  @def WEAVE_CONFIG_MAX_PEER_NODES
 *
 *  @brief
 *    Maximum number of peer nodes that the local node can communicate
 *    with.
 *
 */
#ifndef WEAVE_CONFIG_MAX_PEER_NODES
#define WEAVE_CONFIG_MAX_PEER_NODES                         128
#endif // WEAVE_CONFIG_MAX_PEER_NODES

/**
 *  @def WEAVE_CONFIG_MAX_CONNECTIONS
 *
 *  @brief
 *    Maximum number of simultaneously active connections.
 *
 */
#ifndef WEAVE_CONFIG_MAX_CONNECTIONS
#define WEAVE_CONFIG_MAX_CONNECTIONS                        INET_CONFIG_NUM_TCP_ENDPOINTS
#endif // WEAVE_CONFIG_MAX_CONNECTIONS

/**
 *  @def WEAVE_CONFIG_MAX_INCOMING_TCP_CONNECTIONS
 *
 *  @brief
 *    Maximum number of simultaneously active inbound TCP connections.
 *
 *    Regardless of what #WEAVE_CONFIG_MAX_INCOMING_TCP_CONNECTIONS
 *    is set to, the total number of inbound connections cannot exceed
 *    #WEAVE_CONFIG_MAX_CONNECTIONS, which is the overall limit for
 *    inbound and outbound connections.
 */
#ifndef WEAVE_CONFIG_MAX_INCOMING_TCP_CONNECTIONS
#define WEAVE_CONFIG_MAX_INCOMING_TCP_CONNECTIONS           (WEAVE_CONFIG_MAX_CONNECTIONS * 4 / 5)
#endif // WEAVE_CONFIG_MAX_INCOMING_TCP_CONNECTIONS

/**
 *  @def WEAVE_CONFIG_MAX_INCOMING_TCP_CON_FROM_SINGLE_IP
 *
 *  @brief
 *    Maximum number of simultaneously active inbound TCP connections
 *    from the single IP address.
 *
 *    Regardless of what #WEAVE_CONFIG_MAX_INCOMING_TCP_CON_FROM_SINGLE_IP
 *    is set to, the total number of inbound connections from a single IP
 *    address cannot exceed #WEAVE_CONFIG_MAX_CONNECTIONS or
 *    #WEAVE_CONFIG_MAX_INCOMING_TCP_CONNECTIONS.
 */
#ifndef WEAVE_CONFIG_MAX_INCOMING_TCP_CON_FROM_SINGLE_IP
#define WEAVE_CONFIG_MAX_INCOMING_TCP_CON_FROM_SINGLE_IP    2
#endif // WEAVE_CONFIG_MAX_INCOMING_TCP_CON_FROM_SINGLE_IP

/**
 *  @def WEAVE_CONFIG_MAX_TUNNELS
 *
 *  @brief
 *    Maximum number of simultaneously active connection tunnels.
 *
 */
#ifndef WEAVE_CONFIG_MAX_TUNNELS
#define WEAVE_CONFIG_MAX_TUNNELS                            1
#endif // WEAVE_CONFIG_MAX_TUNNELS

/**
 *  @def WEAVE_CONFIG_MAX_SESSION_KEYS
 *
 *  @brief
 *    Maximum number of simultaneously active session keys.
 *
 */
#ifndef WEAVE_CONFIG_MAX_SESSION_KEYS
#define WEAVE_CONFIG_MAX_SESSION_KEYS                       WEAVE_CONFIG_MAX_CONNECTIONS
#endif // WEAVE_CONFIG_MAX_SESSION_KEYS

/**
 *  @def WEAVE_CONFIG_MAX_APPLICATION_EPOCH_KEYS
 *
 *  @brief
 *    Maximum number of simultaneously supported application epoch keys.
 *    This define should be set to the maximum number of epoch keys
 *    that can be simultaneously provisioned on Weave node by Weave
 *    service. The maximum supported value is 8, however, in most cases
 *    only two such keys will exist on device at any given point in time.
 *
 */
#ifndef WEAVE_CONFIG_MAX_APPLICATION_EPOCH_KEYS
#define WEAVE_CONFIG_MAX_APPLICATION_EPOCH_KEYS             4
#endif // WEAVE_CONFIG_MAX_APPLICATION_EPOCH_KEYS

/**
 *  @def WEAVE_CONFIG_MAX_APPLICATION_GROUPS
 *
 *  @brief
 *    Maximum number of simultaneously supported application groups.
 *    This define should be set to the number of Weave application
 *    groups, in which associated Weave node has membership.
 *
 */
#ifndef WEAVE_CONFIG_MAX_APPLICATION_GROUPS
#define WEAVE_CONFIG_MAX_APPLICATION_GROUPS                 8
#endif // WEAVE_CONFIG_MAX_APPLICATION_GROUPS

/**
 *  @def WEAVE_CONFIG_USE_APP_GROUP_KEYS_FOR_MSG_ENC
 *
 *  @brief
 *    Enable (1) or disable (0) support for the application group keys
 *    used for Weave message encryption.
 *
 */
#ifndef WEAVE_CONFIG_USE_APP_GROUP_KEYS_FOR_MSG_ENC
#define WEAVE_CONFIG_USE_APP_GROUP_KEYS_FOR_MSG_ENC         1
#endif // WEAVE_CONFIG_USE_APP_GROUP_KEYS_FOR_MSG_ENC

/**
 *  @def WEAVE_CONFIG_MAX_CACHED_MSG_ENC_APP_KEYS
 *
 *  @brief
 *    Maximum number of simultaneously cached Weave message encryption
 *    application keys.
 *    Caching these keys speeds up message encoding/decoding processes
 *    and eliminates the need to retrieve constituent key material from
 *    the platform memory every time we derive these keys.
 *    This define can be set equal to the number of application groups
 *    (#WEAVE_CONFIG_MAX_APPLICATION_GROUPS) supported by the Weave node
 *    such that exactly one key can be cached for each application group.
 *    It might be a good idea to allocate few more entries in the key
 *    cache for the corner cases, where application group is having
 *    simultaneous conversations using an 'old' and a 'new' epoch key.
 *
 *  @note This configuration is only relevant when
 *        #WEAVE_CONFIG_USE_APP_GROUP_KEYS_FOR_MSG_ENC is set and
 *        ignored otherwise.
 *
 */
#ifndef WEAVE_CONFIG_MAX_CACHED_MSG_ENC_APP_KEYS
#define WEAVE_CONFIG_MAX_CACHED_MSG_ENC_APP_KEYS            (WEAVE_CONFIG_MAX_APPLICATION_GROUPS + 1)
#endif // WEAVE_CONFIG_MAX_CACHED_MSG_ENC_APP_KEYS

#if !(WEAVE_CONFIG_MAX_CACHED_MSG_ENC_APP_KEYS > 0 && WEAVE_CONFIG_MAX_CACHED_MSG_ENC_APP_KEYS < 256)
#error "Please set WEAVE_CONFIG_MAX_CACHED_MSG_ENC_APP_KEYS to a value greater than zero and smaller than 256."
#endif // !(WEAVE_CONFIG_MAX_CACHED_MSG_ENC_APP_KEYS > 0 && WEAVE_CONFIG_MAX_CACHED_MSG_ENC_APP_KEYS < 256)

/**
 *  @name Weave Encrypted Passcode Configuration
 *
 *  @brief
 *    The following definitions enable (1) or disable (0) supported for
 *    Weave encrypted passcode configurations. Each configuration
 *    uniquely specifies how Weave passcode was encrypted, authenticated,
 *    and structured. Weave supports the following passcode
 *    configurations:
 *
 *    * #WEAVE_CONFIG_SUPPORT_PASSCODE_CONFIG1_TEST_ONLY
 *    * #WEAVE_CONFIG_SUPPORT_PASSCODE_CONFIG2
 *
 *    which are summarized in the table below:
 *
 *    | Configuration | Encryption | Authentication | Fingerprint | Notes                 |
 *    | :-----------: | :--------: | :------------: | :---------: | :-------------------- |
 *    | 1             | -          | SHA1 Hash      | SHA1 Hash   | Test-only             |
 *    | 2             | AES128-ECB | SHA1 HMAC      | SHA1 HMAC   | Default configuration |
 *
 *  @{
 *
 */

/**
 *  @def WEAVE_CONFIG_SUPPORT_PASSCODE_CONFIG1_TEST_ONLY
 *
 *  @brief
 *    This Weave passcode configuration does not encrypt the passcode
 *    and doesn't use secret keys to authenticate and uniquely identify
 *    (fingerprint) the passcode.
 *
 *  @note For this configuration the computational overhead of the
 *        cryptography has largely been disabled since the focus
 *        of this configuration is testing the overall passcode
 *        encryption/decryption protocol, independently of the
 *        cryptography.
 *
 */
#ifndef WEAVE_CONFIG_SUPPORT_PASSCODE_CONFIG1_TEST_ONLY
#define WEAVE_CONFIG_SUPPORT_PASSCODE_CONFIG1_TEST_ONLY     0
#endif // WEAVE_CONFIG_SUPPORT_PASSCODE_CONFIG1_TEST_ONLY

/**
 *  @def WEAVE_CONFIG_SUPPORT_PASSCODE_CONFIG2
 *
 *  @brief
 *    This Weave passcode configuration uses AES128 algorithm in ECB
 *    mode to encrypt passcodes. It also uses SHA1 Hash-based Message
 *    Authentication Code (HMAC) to authenticate and uniquely identify
 *    (fingerprint) the passcode.
 *
 */
#ifndef WEAVE_CONFIG_SUPPORT_PASSCODE_CONFIG2
#define WEAVE_CONFIG_SUPPORT_PASSCODE_CONFIG2               1
#endif // WEAVE_CONFIG_SUPPORT_PASSCODE_CONFIG2

/**
 *  @}
 */

/**
 *  @def WEAVE_CONFIG_DEFAULT_SECURITY_SESSION_ESTABLISHMENT_TIMEOUT
 *
 *  @brief
 *    The default amount of time, in milliseconds, after which an in-progess
 *    session establishment will fail due to a timeout.
 *
 */
#ifndef WEAVE_CONFIG_DEFAULT_SECURITY_SESSION_ESTABLISHMENT_TIMEOUT
#define WEAVE_CONFIG_DEFAULT_SECURITY_SESSION_ESTABLISHMENT_TIMEOUT  30000
#endif // WEAVE_CONFIG_DEFAULT_SECURITY_SESSION_ESTABLISHMENT_TIMEOUT

/**
 *  @def WEAVE_CONFIG_DEFAULT_SECURITY_SESSION_IDLE_TIMEOUT
 *
 *  @brief
 *    The default minimum amount of time, in milliseconds, that an unreserved and idle
 *    security session will be allowed to exist before being destroyed.  In practice,
 *    unreserved idle sessions can exist for up to twice this value.
 *
 */
#ifndef WEAVE_CONFIG_DEFAULT_SECURITY_SESSION_IDLE_TIMEOUT
#define WEAVE_CONFIG_DEFAULT_SECURITY_SESSION_IDLE_TIMEOUT           15000
#endif // WEAVE_CONFIG_DEFAULT_SECURITY_SESSION_IDLE_TIMEOUT

/**
 *  @def WEAVE_CONFIG_NUM_MESSAGE_BUFS
 *
 *  @brief
 *    Total number of message buffers. Only used for the BSD sockets
 *    configuration.
 *
 */
#ifndef WEAVE_CONFIG_NUM_MESSAGE_BUFS
#define WEAVE_CONFIG_NUM_MESSAGE_BUFS                       16
#endif // WEAVE_CONFIG_NUM_MESSAGE_BUFS

/**
 *  @def WEAVE_CONFIG_MAX_UNSOLICITED_MESSAGE_HANDLERS
 *
 *  @brief
 *    Maximum number of simultaneously active unsolicited message
 *    handlers.
 *
 */
#ifndef WEAVE_CONFIG_MAX_UNSOLICITED_MESSAGE_HANDLERS
#define WEAVE_CONFIG_MAX_UNSOLICITED_MESSAGE_HANDLERS       32
#endif // WEAVE_CONFIG_MAX_UNSOLICITED_MESSAGE_HANDLERS

/**
 *  @def WEAVE_CONFIG_MAX_EXCHANGE_CONTEXTS
 *
 *  @brief
 *    Maximum number of simultaneously active exchange contexts.
 *
 */
#ifndef WEAVE_CONFIG_MAX_EXCHANGE_CONTEXTS
#define WEAVE_CONFIG_MAX_EXCHANGE_CONTEXTS                  16
#endif // WEAVE_CONFIG_MAX_EXCHANGE_CONTEXTS

/**
 *  @def WEAVE_CONFIG_MAX_BINDINGS
 *
 *  @brief
 *    Maximum number of simultaneously active bindings per WeaveExchangeManager
 *    The new single source TimeSync client takes one binding.
 *    Every WDM one-way subscription takes one binding. Mutual subscription counts as two one-way subscriptions.
 *    A reserved slot is needed to take an incoming subscription request.
 *    For a device with 2 mutual subscriptions, and one single source time sync client, it needs 2 x 2 + 1 = 5 bindings at least.
 *    At least six is needed if it still wants to take new WDM subscriptions under this load.
 */
#ifndef WEAVE_CONFIG_MAX_BINDINGS
#define WEAVE_CONFIG_MAX_BINDINGS                           6
#endif // WEAVE_CONFIG_MAX_BINDINGS

/**
 *  @def WEAVE_CONFIG_CONNECT_IP_ADDRS
 *
 *  @brief
 *    Maximum number of IP addresses tried when connecting to a
 *    hostname.
 *
 */
#ifndef WEAVE_CONFIG_CONNECT_IP_ADDRS
#define WEAVE_CONFIG_CONNECT_IP_ADDRS                       4
#endif // WEAVE_CONFIG_CONNECT_IP_ADDRS

/**
 *  @def WEAVE_CONFIG_DEFAULT_UDP_MTU_SIZE
 *
 *  @brief
 *    The default MTU size for an IPv6 datagram carrying UDP. This is useful
 *    for senders who want to send UDP Weave messages that fit within a single
 *    IPv6 datagram.
 *
 *    1280 is the guaranteed minimum IPv6 MTU.
 *
 */
#ifndef WEAVE_CONFIG_DEFAULT_UDP_MTU_SIZE
#define WEAVE_CONFIG_DEFAULT_UDP_MTU_SIZE                   1280
#endif // WEAVE_CONFIG_DEFAULT_UDP_MTU_SIZE

/**
 *  @def WEAVE_HEADER_RESERVE_SIZE
 *
 *  @brief
 *    The number of bytes to reserve in a network packet buffer to contain the
 *    Weave message and exchange headers.
 *
 *    This number was calculated as follows:
 *
 *      Weave Message Header:
 *
 *          2 -- Frame Length
 *          2 -- Message Header
 *          4 -- Message Id
 *          8 -- Source Node Id
 *          8 -- Destination Node Id
 *          2 -- Key Id
 *
 *      Weave Exchange Header:
 *
 *          1 -- Application Version
 *          1 -- Message Type
 *          2 -- Exchange Id
 *          4 -- Profile Id
 *          4 -- Acknowleged Message Id
 *
 *    @note A number of these fields are optional or not presently used.
 *          So most headers will be considerably smaller than this.
 *
 */
#ifndef WEAVE_HEADER_RESERVE_SIZE
#define WEAVE_HEADER_RESERVE_SIZE                           38
#endif // WEAVE_HEADER_RESERVE_SIZE

/**
 *  @def WEAVE_TRAILER_RESERVE_SIZE
 *
 *  @brief
 *    TODO
 *
 */
#ifndef WEAVE_TRAILER_RESERVE_SIZE
#define WEAVE_TRAILER_RESERVE_SIZE                          20
#endif // WEAVE_TRAILER_RESERVE_SIZE

/**
 *  @def WEAVE_PORT
 *
 *  @brief
 *    Weave TCP/UDP port for secured Weave traffic.
 *
 */
#ifndef WEAVE_PORT
#define WEAVE_PORT                                          11095
#endif // WEAVE_PORT

/**
 *  @def WEAVE_UNSECURED_PORT
 *
 *  @brief
 *    Weave TCP/UDP port for unsecured Weave traffic.
 *
 */
#ifndef WEAVE_UNSECURED_PORT
#define WEAVE_UNSECURED_PORT                                11096
#endif // WEAVE_UNSECURED_PORT

/**
 *  @def WEAVE_CONFIG_ENABLE_EPHEMERAL_UDP_PORT
 *
 *  @brief
 *    Enable use of an ephemeral UDP source port for locally initiated Weave exchanges.
 */
#ifndef WEAVE_CONFIG_ENABLE_EPHEMERAL_UDP_PORT
#define WEAVE_CONFIG_ENABLE_EPHEMERAL_UDP_PORT              0
#endif // WEAVE_CONFIG_ENABLE_EPHEMERAL_UDP_PORT

/**
 *  @def WEAVE_CONFIG_SECURITY_TEST_MODE
 *
 *  @brief
 *    Enable various features that make it easier to debug secure Weave communication.
 *
 *  @note
 *    WARNING: This option makes it possible to circumvent basic Weave security functionality,
 *    including message encryption. Because of this it SHOULD NEVER BE ENABLED IN PRODUCTION BUILDS.
 */
#ifndef WEAVE_CONFIG_SECURITY_TEST_MODE
#define WEAVE_CONFIG_SECURITY_TEST_MODE                     0
#endif // WEAVE_CONFIG_SECURITY_TEST_MODE

/**
 *  @def WEAVE_CONFIG_ENABLE_DNS_RESOLVER
 *
 *  @brief
 *    Enable support for resolving hostnames with a DNS resolver.
 */
#ifndef WEAVE_CONFIG_ENABLE_DNS_RESOLVER
#define WEAVE_CONFIG_ENABLE_DNS_RESOLVER                    (INET_CONFIG_ENABLE_DNS_RESOLVER)
#endif // WEAVE_CONFIG_ENABLE_DNS_RESOLVER

/**
 *  @def WEAVE_CONFIG_RESOLVE_IPADDR_LITERAL
 *
 *  @brief
 *    Enable support for resolving hostnames as literal IP addresses without a DNS resolver.
 *
 *    For historical reasons, the default is \c TRUE where \c WEAVE_SYSTEM_CONFIG_USE_SOCKETS=1,
 *    and \c FALSE otherwise. The exception in the LwIP-only case was originally made to facilitate
 *    integration and change management with existing development lines. The default may
 *    change in the future to \c TRUE in all cases.
 */
#ifndef WEAVE_CONFIG_RESOLVE_IPADDR_LITERAL
#define WEAVE_CONFIG_RESOLVE_IPADDR_LITERAL                 (WEAVE_SYSTEM_CONFIG_USE_SOCKETS)
#endif // WEAVE_CONFIG_RESOLVE_IPADDR_LITERAL

/**
 *  @def WEAVE_CONFIG_ENABLE_TARGETED_LISTEN
 *
 *  @brief
 *    Enable support for listening on particular addresses/interfaces.
 *
 *    This allows testing multiple instances of the Weave stack
 *    running on a single host.
 *
 */
#ifndef WEAVE_CONFIG_ENABLE_TARGETED_LISTEN
#define WEAVE_CONFIG_ENABLE_TARGETED_LISTEN                 (!WEAVE_SYSTEM_CONFIG_USE_LWIP)
#endif // WEAVE_CONFIG_ENABLE_TARGETED_LISTEN

/**
 *  @def WEAVE_CONFIG_ENABLE_UNSECURED_TCP_LISTEN
 *
 *  @brief
 *    Enable support for receiving TCP connections over an unsecured
 *    network layer (for example, from a device that is provisionally joined
 *    to a 6LowPAN network but does not possess the 802.15.4 network
 *    keys).
 *
 */
#ifndef WEAVE_CONFIG_ENABLE_UNSECURED_TCP_LISTEN
#define WEAVE_CONFIG_ENABLE_UNSECURED_TCP_LISTEN            0
#endif // WEAVE_CONFIG_ENABLE_UNSECURED_TCP_LISTEN

/**
 *  @def WEAVE_CONFIG_DEBUG_CERT_VALIDATION
 *
 *  @brief
 *    Enable support for debugging output from certificate validation.
 *
 */
#ifndef WEAVE_CONFIG_DEBUG_CERT_VALIDATION
#define WEAVE_CONFIG_DEBUG_CERT_VALIDATION                  1
#endif // WEAVE_CONFIG_DEBUG_CERT_VALIDATION

/**
 *  @def WEAVE_CONFIG_OPERATIONAL_DEVICE_CERT_CURVE_ID
 *
 *  @brief
 *    EC curve to be used to generate Weave operational device certificate.
 *
 */
#ifndef WEAVE_CONFIG_OPERATIONAL_DEVICE_CERT_CURVE_ID
#define WEAVE_CONFIG_OPERATIONAL_DEVICE_CERT_CURVE_ID       (nl::Weave::Profiles::Security::kWeaveCurveId_prime256v1)
#endif // WEAVE_CONFIG_OPERATIONAL_DEVICE_CERT_CURVE_ID

/**
 *  @def WEAVE_CONFIG_OP_DEVICE_CERT_VALID_DATE_NOT_BEFORE
 *
 *  @brief
 *    This is a packed valid date to be encoded in the Weave
 *    operational device certificate. Any date before
 *    that date the certificate is considered invalid.
 *    The following functions can be used to calculate packed
 *    date/time: PackCertTime() and PackedCertTimeToDate().
 *    Weave packed certificate dates are limited to representing
 *    dates that are on or after 2000/01/01.
 *    Mathematical expression to calculate packed date is:
 *        (((year - 2000) * 12 + (mon - 1)) * 31 + (day - 1))
 *    Currently encoded value corresponds to 2019/01/01.
 *
 */
#ifndef WEAVE_CONFIG_OP_DEVICE_CERT_VALID_DATE_NOT_BEFORE
#define WEAVE_CONFIG_OP_DEVICE_CERT_VALID_DATE_NOT_BEFORE   0x1B9C
#endif // WEAVE_CONFIG_OP_DEVICE_CERT_VALID_DATE_NOT_BEFORE

/**
 *  @def WEAVE_CONFIG_OP_DEVICE_CERT_VALID_DATE_NOT_AFTER
 *
 *  @brief
 *    This is the valid date to be encoded in the Weave
 *    operational device certificate. Any date after
 *    that date the certificate is considered invalid.
 *    The following functions can be used to calculate packed
 *    date/time: PackCertTime() and PackedCertTimeToDate().
 *    Weave packed certificate dates are limited to representing
 *    dates that are on or after 2000/01/01.
 *    Mathematical expression to calculate packed date is:
 *        (((year - 2000) * 12 + (mon - 1)) * 31 + (day - 1))
 *    Currently encoded value corresponds to 2069/01/01.
 *
 */
#ifndef WEAVE_CONFIG_OP_DEVICE_CERT_VALID_DATE_NOT_AFTER
#define WEAVE_CONFIG_OP_DEVICE_CERT_VALID_DATE_NOT_AFTER    0x6444
#endif // WEAVE_CONFIG_OP_DEVICE_CERT_VALID_DATE_NOT_AFTER

/**
 *  @def WEAVE_CONFIG_ENABLE_PASE_INITIATOR
 *
 *  @brief
 *    Enable support for initiating PASE sessions.
 *
 */
#ifndef WEAVE_CONFIG_ENABLE_PASE_INITIATOR
#define WEAVE_CONFIG_ENABLE_PASE_INITIATOR                  1
#endif // WEAVE_CONFIG_ENABLE_PASE_INITIATOR

/**
 *  @def WEAVE_CONFIG_ENABLE_PASE_RESPONDER
 *
 *  @brief
 *    Enable support for responding to PASE sessions initiated by
 *    other nodes.
 *
 */
#ifndef WEAVE_CONFIG_ENABLE_PASE_RESPONDER
#define WEAVE_CONFIG_ENABLE_PASE_RESPONDER                  1
#endif // WEAVE_CONFIG_ENABLE_PASE_RESPONDER

/**
 *  @def WEAVE_CONFIG_ENABLE_CASE_INITIATOR
 *
 *  @brief
 *    Enable support for initiating CASE sessions.
 *
 */
#ifndef WEAVE_CONFIG_ENABLE_CASE_INITIATOR
#define WEAVE_CONFIG_ENABLE_CASE_INITIATOR                  1
#endif // WEAVE_CONFIG_ENABLE_CASE_INITIATOR

/**
 *  @def WEAVE_CONFIG_ENABLE_CASE_RESPONDER
 *
 *  @brief
 *    Enable support for responding to CASE sessions initiated by other nodes.
 *
 */
#ifndef WEAVE_CONFIG_ENABLE_CASE_RESPONDER
#define WEAVE_CONFIG_ENABLE_CASE_RESPONDER                  1
#endif // WEAVE_CONFIG_ENABLE_CASE_RESPONDER

/**
 *  @def WEAVE_CONFIG_SUPPORT_CASE_CONFIG1
 *
 *  @brief
 *    Enable use of CASE protocol configuration 1.
 *
 *  @note CASE config 1 uses SHA-1 for message signatures, which is deprecated.
 *
 */
#ifndef WEAVE_CONFIG_SUPPORT_CASE_CONFIG1
#define WEAVE_CONFIG_SUPPORT_CASE_CONFIG1                   1
#endif // WEAVE_CONFIG_SUPPORT_CASE_CONFIG1

/**
 *  @def WEAVE_CONFIG_DEFAULT_CASE_CURVE_ID
 *
 *  @brief
 *    Default ECDH curve to be used when initiating a CASE session, if not overridden by the application.
 *
 */
#ifndef WEAVE_CONFIG_DEFAULT_CASE_CURVE_ID
#if WEAVE_CONFIG_SUPPORT_ELLIPTIC_CURVE_SECP224R1
#define WEAVE_CONFIG_DEFAULT_CASE_CURVE_ID                  (nl::Weave::Profiles::Security::kWeaveCurveId_secp224r1)
#elif WEAVE_CONFIG_SUPPORT_ELLIPTIC_CURVE_SECP256R1
#define WEAVE_CONFIG_DEFAULT_CASE_CURVE_ID                  (nl::Weave::Profiles::Security::kWeaveCurveId_prime256v1)
#elif WEAVE_CONFIG_SUPPORT_ELLIPTIC_CURVE_SECP192R1
#define WEAVE_CONFIG_DEFAULT_CASE_CURVE_ID                  (nl::Weave::Profiles::Security::kWeaveCurveId_prime192v1)
#else
#define WEAVE_CONFIG_DEFAULT_CASE_CURVE_ID                  (nl::Weave::Profiles::Security::kWeaveCurveId_secp160r1)
#endif
#endif // WEAVE_CONFIG_DEFAULT_CASE_CURVE_ID

/**
 *  @def WEAVE_CONFIG_DEFAULT_CASE_ALLOWED_CURVES
 *
 *  @brief
 *    Default set of ECDH curves allowed to be used in a CASE session (initiating or responding), if not overridden by the application.
 *
 */
#ifndef WEAVE_CONFIG_DEFAULT_CASE_ALLOWED_CURVES
#if WEAVE_CONFIG_SUPPORT_ELLIPTIC_CURVE_SECP224R1 || WEAVE_CONFIG_SUPPORT_ELLIPTIC_CURVE_SECP256R1
#define WEAVE_CONFIG_DEFAULT_CASE_ALLOWED_CURVES            (nl::Weave::Profiles::Security::kWeaveCurveSet_secp224r1|nl::Weave::Profiles::Security::kWeaveCurveSet_prime256v1)
#else
#define WEAVE_CONFIG_DEFAULT_CASE_ALLOWED_CURVES            (nl::Weave::Profiles::Security::kWeaveCurveSet_All)
#endif
#endif // WEAVE_CONFIG_DEFAULT_CASE_ALLOWED_CURVES

/**
 * @def WEAVE_CONFIG_LEGACY_CASE_AUTH_DELEGATE
 *
 * @brief
 *   Enable use of the legacy WeaveCASEAuthDelegate interface.
 */
#ifndef WEAVE_CONFIG_LEGACY_CASE_AUTH_DELEGATE
#define WEAVE_CONFIG_LEGACY_CASE_AUTH_DELEGATE 1
#endif

/**
 *  @def WEAVE_CONFIG_MAX_SHARED_SESSIONS_END_NODES
 *
 *  @brief
 *    The maximum number of end nodes simultaneously supported
 *    for all active shared sessions.
 *
 */
#ifndef WEAVE_CONFIG_MAX_SHARED_SESSIONS_END_NODES
#define WEAVE_CONFIG_MAX_SHARED_SESSIONS_END_NODES          10
#endif // WEAVE_CONFIG_MAX_SHARED_SESSIONS_END_NODES

/**
 *  @def WEAVE_CONFIG_MAX_END_NODES_PER_SHARED_SESSION
 *
 *  @brief
 *    The maximum number of end nodes simultaneously supported
 *    per active shared session.
 *
 */
#ifndef WEAVE_CONFIG_MAX_END_NODES_PER_SHARED_SESSION
#define WEAVE_CONFIG_MAX_END_NODES_PER_SHARED_SESSION       10
#endif // WEAVE_CONFIG_MAX_END_NODES_PER_SHARED_SESSION

/**
 *  @def WEAVE_CONFIG_ENABLE_TAKE_INITIATOR
 *
 *  @brief
 *    Enable support for initiating TAKE sessions.
 *
 */
#ifndef WEAVE_CONFIG_ENABLE_TAKE_INITIATOR
#define WEAVE_CONFIG_ENABLE_TAKE_INITIATOR                  0
#endif // WEAVE_CONFIG_ENABLE_TAKE_INITIATOR

/**
 *  @def WEAVE_CONFIG_ENABLE_TAKE_RESPONDER
 *
 *  @brief
 *    Enable support for responding to TAKE sessions initiated by other nodes.
 *
 */
#ifndef WEAVE_CONFIG_ENABLE_TAKE_RESPONDER
#define WEAVE_CONFIG_ENABLE_TAKE_RESPONDER                  0
#endif // WEAVE_CONFIG_ENABLE_TAKE_RESPONDER

/**
 *  @def WEAVE_CONFIG_ENABLE_KEY_EXPORT_INITIATOR
 *
 *  @brief
 *    Enable support for initiating key export request.
 *
 */
#ifndef WEAVE_CONFIG_ENABLE_KEY_EXPORT_INITIATOR
#define WEAVE_CONFIG_ENABLE_KEY_EXPORT_INITIATOR            1
#endif // WEAVE_CONFIG_ENABLE_KEY_EXPORT_INITIATOR

/**
 *  @def WEAVE_CONFIG_ENABLE_KEY_EXPORT_RESPONDER
 *
 *  @brief
 *    Enable support for responding to key export request initiated by other nodes.
 *
 */
#ifndef WEAVE_CONFIG_ENABLE_KEY_EXPORT_RESPONDER
#define WEAVE_CONFIG_ENABLE_KEY_EXPORT_RESPONDER            1
#endif // WEAVE_CONFIG_ENABLE_KEY_EXPORT_RESPONDER

/**
 * @def WEAVE_CONFIG_LEGACY_KEY_EXPORT_DELEGATE
 *
 * @brief
 *   Enable use of the legacy WeaveKeyExportDelegate interface.
 */
#ifndef WEAVE_CONFIG_LEGACY_KEY_EXPORT_DELEGATE
#define WEAVE_CONFIG_LEGACY_KEY_EXPORT_DELEGATE 1
#endif

/**
 *  @def WEAVE_CONFIG_REQUIRE_AUTH
 *
 *  @brief
 *    Enable (1) or disable (0) support for client requests via an
 *    authenticated session.
 *
 *    This broadly controls whether or not a number of Weave servers
 *    require client requests to be sent via an authenticated session
 *    and provides a default configuration value to these related
 *    definitions:
 *
 *      * #WEAVE_CONFIG_REQUIRE_AUTH_DEVICE_CONTROL
 *      * #WEAVE_CONFIG_REQUIRE_AUTH_FABRIC_PROV
 *      * #WEAVE_CONFIG_REQUIRE_AUTH_NETWORK_PROV
 *      * #WEAVE_CONFIG_REQUIRE_AUTH_SERVICE_PROV
 *
 *    @note These configurations shall be deasserted for development
 *          and testing purposes only. No Weave-enabled device shall
 *          be certified without these asserted.
 *
 */
#ifndef WEAVE_CONFIG_REQUIRE_AUTH
#define WEAVE_CONFIG_REQUIRE_AUTH                           1
#endif // WEAVE_CONFIG_REQUIRE_AUTH

/**
 *  @def WEAVE_CONFIG_REQUIRE_AUTH_DEVICE_CONTROL
 *
 *  @brief
 *    Enable (1) or disable (0) support for client requests to the
 *    Weave Device Control server via an authenticated session. See
 *    also #WEAVE_CONFIG_REQUIRE_AUTH.
 *
 *    @note This configuration shall be deasserted for development
 *          and testing purposes only. No Weave-enabled device shall
 *          be certified without this asserted.
 *
 */
#ifndef WEAVE_CONFIG_REQUIRE_AUTH_DEVICE_CONTROL
#define WEAVE_CONFIG_REQUIRE_AUTH_DEVICE_CONTROL            WEAVE_CONFIG_REQUIRE_AUTH
#endif // WEAVE_CONFIG_REQUIRE_AUTH_DEVICE_CONTROL

/**
 *  @def WEAVE_CONFIG_REQUIRE_AUTH_FABRIC_PROV
 *
 *  @brief
 *    Enable (1) or disable (0) support for client requests to the
 *    Weave Fabric Provisioning server via an authenticated
 *    session. See also #WEAVE_CONFIG_REQUIRE_AUTH.
 *
 *    @note This configuration shall be deasserted for development
 *          and testing purposes only. No Weave-enabled device shall
 *          be certified without this asserted.
 *
 */
#ifndef WEAVE_CONFIG_REQUIRE_AUTH_FABRIC_PROV
#define WEAVE_CONFIG_REQUIRE_AUTH_FABRIC_PROV               WEAVE_CONFIG_REQUIRE_AUTH
#endif // WEAVE_CONFIG_REQUIRE_AUTH_FABRIC_PROV

/**
 *  @def WEAVE_CONFIG_REQUIRE_AUTH_NETWORK_PROV
 *
 *  @brief
 *    Enable (1) or disable (0) support for client requests to the
 *    Weave Network Provisioning server via an authenticated
 *    session. See also #WEAVE_CONFIG_REQUIRE_AUTH.
 *
 *    @note This configuration shall be deasserted for development
 *          and testing purposes only. No Weave-enabled device shall
 *          be certified without this asserted.
 *
 */
#ifndef WEAVE_CONFIG_REQUIRE_AUTH_NETWORK_PROV
#define WEAVE_CONFIG_REQUIRE_AUTH_NETWORK_PROV              WEAVE_CONFIG_REQUIRE_AUTH
#endif // WEAVE_CONFIG_REQUIRE_AUTH_NETWORK_PROV

/**
 *  @def WEAVE_CONFIG_REQUIRE_AUTH_SERVICE_PROV
 *
 *  @brief
 *    Enable (1) or disable (0) support for client requests to the
 *    Weave Service Provisioning server via an authenticated
 *    session. See also #WEAVE_CONFIG_REQUIRE_AUTH.
 *
 *    @note This configuration shall be deasserted for development
 *          and testing purposes only. No Weave-enabled device shall
 *          be certified without this asserted.
 *
 */
#ifndef WEAVE_CONFIG_REQUIRE_AUTH_SERVICE_PROV
#define WEAVE_CONFIG_REQUIRE_AUTH_SERVICE_PROV              WEAVE_CONFIG_REQUIRE_AUTH
#endif // WEAVE_CONFIG_REQUIRE_AUTH_SERVICE_PROV

/**
 *  @def WEAVE_CONFIG_ENABLE_PROVISIONING_BUNDLE_SUPPORT
 *
 *  @brief
 *    Enable (1) or disable (0) support for the handling of Weave
 *    Provisioning Bundles.
 *
 *    Weave Provisioning Bundles are a Weave TLV payload containing
 *    the Weave certificate, corresponding private key, and pairing
 *    code / entry key that a Weave device would have otherwise
 *    received at its time of manufacture.
 *
 *    Enable this if your family of device needs to support in-field
 *    provisioning (IFP). IFP for Weave devices is neither generally
 *    supported nor recommended.
 *
 */
#ifndef WEAVE_CONFIG_ENABLE_PROVISIONING_BUNDLE_SUPPORT
#define WEAVE_CONFIG_ENABLE_PROVISIONING_BUNDLE_SUPPORT     1
#endif // WEAVE_CONFIG_ENABLE_PROVISIONING_BUNDLE_SUPPORT

/**
 *  @def WEAVE_ERROR_LOGGING
 *
 *  @brief
 *    If asserted (1), enable logging of all messages in the
 *    nl::Weave::Logging::LogCategory::kLogCategory_Error category.
 *
 */
#ifndef WEAVE_ERROR_LOGGING
#define WEAVE_ERROR_LOGGING                                 1
#endif // WEAVE_ERROR_LOGGING

/**
 *  @def WEAVE_PROGRESS_LOGGING
 *
 *  @brief
 *    If asserted (1), enable logging of all messages in the
 *    nl::Weave::Logging::LogCategory::kLogCategory_Progress category.
 *
 */
#ifndef WEAVE_PROGRESS_LOGGING
#define WEAVE_PROGRESS_LOGGING                              1
#endif // WEAVE_PROGRESS_LOGGING

/**
 *  @def WEAVE_DETAIL_LOGGING
 *
 *  @brief
 *    If asserted (1), enable logging of all messages in the
 *    nl::Weave::Logging::kLogCategory_Detail category.
 *
 */
#ifndef WEAVE_DETAIL_LOGGING
#define WEAVE_DETAIL_LOGGING                                1
#endif // WEAVE_DETAIL_LOGGING

/**
 *  @def WEAVE_RETAIN_LOGGING
 *
 *  @brief
 *    If asserted (1), enable logging of all messages in the
 *    nl::Weave::Logging::LogCategory::kLogCategory_Retain category.
 *    If not defined by the application, by default WEAVE_RETAIN_LOGGING is
 *    remapped to WEAVE_PROGRESS_LOGGING
 *
 */


/**
 *  @def WEAVE_CONFIG_ENABLE_FUNCT_ERROR_LOGGING
 *
 *  @brief
 *    If asserted (1), enable logging of errors at function exit via the
 *    WeaveLogFunctError() macro.
 */
#ifndef WEAVE_CONFIG_ENABLE_FUNCT_ERROR_LOGGING
#define WEAVE_CONFIG_ENABLE_FUNCT_ERROR_LOGGING 0
#endif // WEAVE_CONFIG_ENABLE_FUNCT_ERROR_LOGGING


/**
 *  @def WEAVE_CONFIG_ENABLE_CONDITION_LOGGING
 *
 *  @brief
 *    If asserted (1), enable logging of failed conditions via the
 *    WeaveLogIfFalse() macro.
 */
#ifndef WEAVE_CONFIG_ENABLE_CONDITION_LOGGING
#define WEAVE_CONFIG_ENABLE_CONDITION_LOGGING 0
#endif // WEAVE_CONFIG_ENABLE_CONDITION_LOGGING

/**
 *  @def WEAVE_CONFIG_PERSIST_SUBSCRIPTION_STATE
 *
 *  @brief
 *    If set to (1), use of the persistent subscription state
 *    implementation is enabled. Default value is (0) or disabled.
 *
 *  @note
 *    Enabling this profile allows applications using Weave to
 *    persist the mutual subscription states between device and service
 *    across device reboots.
 *
 */
#ifndef WEAVE_CONFIG_PERSIST_SUBSCRIPTION_STATE
#define WEAVE_CONFIG_PERSIST_SUBSCRIPTION_STATE               0
#endif // WEAVE_CONFIG_PERSIST_SUBSCRIPTION_STATE

/**
 *  @def WEAVE_CONFIG_ENABLE_SERVICE_DIRECTORY
 *
 *  @brief
 *    If set to (1), use of the ServiceDirectory implementation
 *    is enabled. Default value is (1) or enabled.
 *
 *  @note
 *    Enabling this profile allows applications using Weave to
 *    request a connection to a particular Weave service using
 *    a predefined service endpoint. It is relevant for
 *    applications that run on devices that interact with the
 *    Service over a direct TCP/IPv4 connection rather than those
 *    that use the Weave Tunnel through a gateway device. For
 *    devices of the latter category, the Service Directory
 *    profile can be disabled via this compilation switch.
 *
 */
#ifndef WEAVE_CONFIG_ENABLE_SERVICE_DIRECTORY
#define WEAVE_CONFIG_ENABLE_SERVICE_DIRECTORY               1
#endif // WEAVE_CONFIG_ENABLE_SERVICE_DIRECTORY

/**
 *  @def WEAVE_CONFIG_PERSIST_SERVICE_DIRECTORY
 *
 *  @brief
 *    If set to (1), persistent service directory is enabled.
 *    Default value is (0) or disabled.
 *
 *  @note
 *    Enabling this feature flag persists the service directory
 *    cache retrieved from the directory server and use it to
 *    populate the in-memory cache at initialization time.
 *
 */
#ifndef WEAVE_CONFIG_PERSIST_SERVICE_DIRECTORY
#define WEAVE_CONFIG_PERSIST_SERVICE_DIRECTORY               0
#endif // WEAVE_CONFIG_PERSIST_SERVICE_DIRECTORY

/**
 *  @def WEAVE_CONFIG_SERVICE_DIR_CONNECT_TIMEOUT_MSECS
 *
 *  @brief
 *    This is the default timeout for the connect call to the
 *    directory server to wait for success or being notified
 *    of an error.
 *
 */
#ifndef WEAVE_CONFIG_SERVICE_DIR_CONNECT_TIMEOUT_MSECS
#define WEAVE_CONFIG_SERVICE_DIR_CONNECT_TIMEOUT_MSECS      (10000)
#endif // WEAVE_CONFIG_SERVICE_DIR_CONNECT_TIMEOUT_MSECS

/**
 *  @def WEAVE_CONFIG_DEFAULT_INCOMING_CONNECTION_IDLE_TIMEOUT
 *
 *  @brief
 *    The maximum amount of time, in milliseconds, that an idle inbound
 *    Weave connection will be allowed to exist before being closed.
 *
 *    This is a default value that can be overridden at runtime by the
 *    application.
 *
 *    A value of 0 disables automatic closing of idle connections.
 *
 */
#ifndef WEAVE_CONFIG_DEFAULT_INCOMING_CONNECTION_IDLE_TIMEOUT
#define WEAVE_CONFIG_DEFAULT_INCOMING_CONNECTION_IDLE_TIMEOUT        15000
#endif // WEAVE_CONFIG_DEFAULT_INCOMING_CONNECTION_IDLE_TIMEOUT

/**
 *  @def WEAVE_CONFIG_MSG_COUNTER_SYNC_RESP_TIMEOUT
 *
 *  @brief
 *    The amount of time (in milliseconds) which a peer is given
 *    to respond to a message counter synchronization request.
 *    Depending on when the request is sent, peers may
 *    actually have up to twice this time.
 *
 */
#ifndef WEAVE_CONFIG_MSG_COUNTER_SYNC_RESP_TIMEOUT
#define WEAVE_CONFIG_MSG_COUNTER_SYNC_RESP_TIMEOUT          2000
#endif // WEAVE_CONFIG_MSG_COUNTER_SYNC_RESP_TIMEOUT

/**
 *  @def WEAVE_CONFIG_TEST
 *
 *  @brief
 *    If asserted (1), enable APIs that help implement
 *    unit and integration tests.
 *
 */
#ifndef WEAVE_CONFIG_TEST
#define WEAVE_CONFIG_TEST                                   0
#endif // WEAVE_CONFIG_TEST

/**
 *  @def WEAVE_CONFIG_SHORT_ERROR_STR
 *
 *  @brief
 *    If asserted (1), produce shorter error strings that only carry a
 *    minimum of information.
 *
 */
#ifndef WEAVE_CONFIG_SHORT_ERROR_STR
#define WEAVE_CONFIG_SHORT_ERROR_STR                        0
#endif // WEAVE_CONFIG_SHORT_ERROR_STR

/**
 *  @def WEAVE_CONFIG_ERROR_STR_SIZE
 *
 *  @brief
 *    This defines the size of the buffer to store a formatted error string.
 *    If the formatting of an error string exceeds this size it will be truncated.
 *
 *    The default size varies based on the WEAVE_CONFIG_SHORT_ERROR_STR option.
 *
 *    When WEAVE_CONFIG_SHORT_ERROR_STR is 0, a large default buffer size is used
 *    to accommodate descriptive text summarizing the cause of the error. E.g.:
 *
 *         "Weave Error 4047 (0x00000FCF): Invalid Argument"
 *
 *    When WEAVE_CONFIG_SHORT_ERROR_STR is 1, the buffer size is set to accommodate
 *    a minimal error string consisting of a 10 character subsystem name followed
 *    by an 8 character error number, plus boilerplate. E.g.:
 *
 *         "Error Weave:0x00000FCF"
 *
 */
#ifndef WEAVE_CONFIG_ERROR_STR_SIZE
#if WEAVE_CONFIG_SHORT_ERROR_STR
#define WEAVE_CONFIG_ERROR_STR_SIZE                         (5 + 1 + 10 + 3 + 8 + 1)
#else // WEAVE_CONFIG_SHORT_ERROR_STR
#define WEAVE_CONFIG_ERROR_STR_SIZE                         256
#endif // WEAVE_CONFIG_SHORT_ERROR_STR
#endif // WEAVE_CONFIG_ERROR_STR_SIZE

/**
 *  @def WEAVE_CONFIG_CUSTOM_ERROR_FORMATTER
 *
 *  @brief
 *    If asserted (1), suppress definition of the standard error formatting function
 *    (#nl::FormatError()) allowing an application-specific implementation to be used.
 *
 */
#ifndef WEAVE_CONFIG_CUSTOM_ERROR_FORMATTER
#define WEAVE_CONFIG_CUSTOM_ERROR_FORMATTER                 0
#endif // WEAVE_CONFIG_CUSTOM_ERROR_FORMATTER

/**
 *  @def WEAVE_CONFIG_SHORT_FORM_ERROR_VALUE_FORMAT
 *
 *  @brief
 *    The printf-style format string used to format error values.
 *
 *  On some platforms, the structure of error values makes them more convenient to
 *  read in either hex or decimal format.  This option can be used to override
 *  the default hex format.
 *
 *  Note that this option only affects short-form error strings (i.e. when
 *  WEAVE_CONFIG_SHORT_ERROR_STR == 1).  Long form error strings always show both hex
 *  and decimal values
 */
#ifndef WEAVE_CONFIG_SHORT_FORM_ERROR_VALUE_FORMAT
#define WEAVE_CONFIG_SHORT_FORM_ERROR_VALUE_FORMAT          "0x%08" PRIX32
#endif // WEAVE_CONFIG_SHORT_FORM_ERROR_VALUE_FORMAT

/**
 *  @def WEAVE_CONFIG_BLE_PKT_RESERVED_SIZE
 *
 *  @brief
 *    The number of bytes that Weave should reserve at the front of
 *    every outgoing BLE packet for the sake of the underlying BLE
 *    stack.
 *
 */
#ifndef WEAVE_CONFIG_BLE_PKT_RESERVED_SIZE
#define WEAVE_CONFIG_BLE_PKT_RESERVED_SIZE                  0
#endif // WEAVE_CONFIG_BLE_PKT_RESERVED_SIZE

/**
 *  @def WEAVE_CONFIG_ENABLE_SECURITY_DEBUG_FUNCS
 *
 *  @brief
 *    Enable (1) or disable (0) support for utility functions for
 *    decoding and outputing information related to Weave security.
 *
 */
#ifndef WEAVE_CONFIG_ENABLE_SECURITY_DEBUG_FUNCS
#define WEAVE_CONFIG_ENABLE_SECURITY_DEBUG_FUNCS            1
#endif // WEAVE_CONFIG_ENABLE_SECURITY_DEBUG_FUNCS

/**
 *  @def WEAVE_CONFIG_IsPlatformErrorNonCritical(CODE)
 *
 *  This macro checks if a platform generated error is critical and
 *  needs to be reported to the application/caller. The criticality
 *  of an error (in the context of that platform) is determined by how
 *  it impacts the logic flow, i.e., whether or not the current flow
 *  can continue despite the error or it needs to be reported back
 *  resulting in a potential stoppage.
 *
 *  @note
 *  This is a default set of platform errors which are configured as
 *  non-critical from the context of that platform. Any new error that
 *  the platforms deem as non-critical could be added by overriding
 *  this default macro definition after careful thought towards its
 *  implication in the logic flow in that platform.
 *
 *  @param[in]    CODE    The #WEAVE_ERROR being checked for criticality.
 *
 *  @return    true if the error is non-critical; false otherwise.
 *
 */
#ifndef WEAVE_CONFIG_IsPlatformErrorNonCritical
#if WEAVE_SYSTEM_CONFIG_USE_LWIP
#define _WEAVE_CONFIG_IsPlatformLwIPErrorNonCritical(CODE)         \
    ((CODE) == nl::Weave::System::MapErrorLwIP(ERR_RTE)         || \
     (CODE) == nl::Weave::System::MapErrorLwIP(ERR_MEM))
#else // !WEAVE_SYSTEM_CONFIG_USE_LWIP
#define _WEAVE_CONFIG_IsPlatformLwIPErrorNonCritical(CODE)  0
#endif // !WEAVE_SYSTEM_CONFIG_USE_LWIP

#if WEAVE_SYSTEM_CONFIG_USE_SOCKETS
#define _WEAVE_CONFIG_IsPlatformPOSIXErrorNonCritical(CODE)        \
    ((CODE) == nl::Weave::System::MapErrorPOSIX(EHOSTUNREACH)   || \
     (CODE) == nl::Weave::System::MapErrorPOSIX(ENETUNREACH)    || \
     (CODE) == nl::Weave::System::MapErrorPOSIX(EADDRNOTAVAIL)  || \
     (CODE) == nl::Weave::System::MapErrorPOSIX(EPIPE))
#else // !WEAVE_SYSTEM_CONFIG_USE_SOCKETS
#define _WEAVE_CONFIG_IsPlatformPOSIXErrorNonCritical(CODE)  0
#endif // !WEAVE_SYSTEM_CONFIG_USE_SOCKETS

#define WEAVE_CONFIG_IsPlatformErrorNonCritical(CODE)              \
    (_WEAVE_CONFIG_IsPlatformPOSIXErrorNonCritical(CODE)        || \
     _WEAVE_CONFIG_IsPlatformLwIPErrorNonCritical(CODE))
#endif // WEAVE_CONFIG_IsPlatformErrorNonCritical

/**
 *  @def WEAVE_CONFIG_WILL_OVERRIDE_PLATFORM_MATH_FUNCS
 *
 *  @brief
 *    Enable (1) or disable (0) replacing math functions
 *    which may not be available in the standard/intrinsic library,
 *    and hence require special support from the platform.
 *
 */
#ifndef WEAVE_CONFIG_WILL_OVERRIDE_PLATFORM_MATH_FUNCS
#define WEAVE_CONFIG_WILL_OVERRIDE_PLATFORM_MATH_FUNCS   0
#endif // WEAVE_CONFIG_WILL_OVERRIDE_PLATFORM_MATH_FUNCS

/**
 * @def WEAVE_CONFIG_SERIALIZATION_USE_MALLOC
 *
 * @brief If turned on, then schema event serialization and
 *   deserialization will use the stdlib implementations of malloc,
 *   free, and realloc by default (if no other implementations have
 *   been provided).  We will fail at compile time if the stdlib
 *   implementations are not present.
 */
#ifndef WEAVE_CONFIG_SERIALIZATION_USE_MALLOC
#define WEAVE_CONFIG_SERIALIZATION_USE_MALLOC 0
#endif

/**
 * @def WEAVE_CONFIG_SERIALIZATION_DEBUG_LOGGING
 *
 * @brief Enable debug logging for the serialization/deserialization APIs.
 */
#ifndef WEAVE_CONFIG_SERIALIZATION_DEBUG_LOGGING
#define WEAVE_CONFIG_SERIALIZATION_DEBUG_LOGGING 0
#endif

/**
 * @def WEAVE_CONFIG_SERIALIZATION_ENABLE_DESERIALIZATION
 *
 * @brief Enable deserialization as well as serialization APIs.  We
 *   make deserialization configurable because it requires some extra
 *   memory that a highly resource-constrained platform could preserve
 *   if it doesn't consume WDM events or otherwise has no need to
 *   deserialize.
 */
#ifndef WEAVE_CONFIG_SERIALIZATION_ENABLE_DESERIALIZATION
#define WEAVE_CONFIG_SERIALIZATION_ENABLE_DESERIALIZATION 1
#endif

/**
 * @def WEAVE_CONFIG_SERIALIZATION_LOG_FLOATS
 *
 * @brief Enable debug logging of floats and doubles for the
 *   serialization/deserialization APIs.  Not all platforms
 *   support these types, and may not compile if there are
 *   any references to them.  Only matters if
 *   WEAVE_CONFIG_SERIALIZATION_DEBUG_LOGGING is enabled.
 */
#ifndef WEAVE_CONFIG_SERIALIZATION_LOG_FLOATS
#define WEAVE_CONFIG_SERIALIZATION_LOG_FLOATS 1
#endif

/**
 * @def WEAVE_CONFIG_PERSISTED_STORAGE_KEY_TYPE
 *
 * @brief
 *   The data type used to represent the key of a persistedly-stored
 *   key/value pair.
 */
#ifndef WEAVE_CONFIG_PERSISTED_STORAGE_KEY_TYPE
#define WEAVE_CONFIG_PERSISTED_STORAGE_KEY_TYPE const char *
#endif

/**
 *  @def WEAVE_CONFIG_PERSISTED_STORAGE_ENC_MSG_CNTR_ID
 *
 *  @brief
 *    The group key message counter persisted storage Id.
 *
 */
#ifndef WEAVE_CONFIG_PERSISTED_STORAGE_ENC_MSG_CNTR_ID
#define WEAVE_CONFIG_PERSISTED_STORAGE_ENC_MSG_CNTR_ID      "EncMsgCntr"
#endif // WEAVE_CONFIG_PERSISTED_STORAGE_ENC_MSG_CNTR_ID

/**
 *  @def WEAVE_CONFIG_PERSISTED_STORAGE_ENC_MSG_CNTR_EPOCH
 *
 *  @brief
 *    The group key message counter persisted storage epoch.
 *
 */
#ifndef WEAVE_CONFIG_PERSISTED_STORAGE_ENC_MSG_CNTR_EPOCH
#define WEAVE_CONFIG_PERSISTED_STORAGE_ENC_MSG_CNTR_EPOCH   0x1000
#endif // WEAVE_CONFIG_PERSISTED_STORAGE_ENC_MSG_CNTR_EPOCH

/**
 * @def WEAVE_CONFIG_PERSISTED_STORAGE_MAX_KEY_LENGTH
 *
 * @brief The maximum length of the key in a key/value pair
 *   stored in the platform's persistent storage.
 */
#ifndef WEAVE_CONFIG_PERSISTED_STORAGE_MAX_KEY_LENGTH
#define WEAVE_CONFIG_PERSISTED_STORAGE_MAX_KEY_LENGTH 16
#endif

/**
 * @def WEAVE_CONFIG_PERSISTED_STORAGE_MAX_VALUE_LENGTH
 *
 * @brief The maximum length of the value in a key/value pair
 *   stored in the platform's persistent storage.
 */
#ifndef WEAVE_CONFIG_PERSISTED_STORAGE_MAX_VALUE_LENGTH
#define WEAVE_CONFIG_PERSISTED_STORAGE_MAX_VALUE_LENGTH 256
#endif

/**
 * @def WEAVE_CONFIG_PERSISTED_COUNTER_DEBUG_LOGGING
 *
 * @brief Enable debug logging for the PersistedCounter API.
 */
#ifndef WEAVE_CONFIG_PERSISTED_COUNTER_DEBUG_LOGGING
#define WEAVE_CONFIG_PERSISTED_COUNTER_DEBUG_LOGGING 0
#endif

/**
 * @def WEAVE_CONFIG_EVENT_LOGGING_VERBOSE_DEBUG_LOGS
 *
 * @brief Enable verbose debug logging for the EventLogging API.
 * This setting is incompatible with platforms that route console
 * logs into event logging, as it would result in circular logic.
 */
#ifndef WEAVE_CONFIG_EVENT_LOGGING_VERBOSE_DEBUG_LOGS
#define WEAVE_CONFIG_EVENT_LOGGING_VERBOSE_DEBUG_LOGS 1
#endif

/**
 * @def WEAVE_CONFIG_ENABLE_ARG_PARSER
 *
 * @brief Enable support functions for parsing command-line arguments
 */
#ifndef WEAVE_CONFIG_ENABLE_ARG_PARSER
#define WEAVE_CONFIG_ENABLE_ARG_PARSER 0
#endif

/**
 * @def WEAVE_CONFIG_ENABLE_ARG_PARSER_SANTIY_CHECK
 *
 * @brief Enable santiy checking of command-line argument definitions.
 */
#ifndef WEAVE_CONFIG_ENABLE_ARG_PARSER_SANTIY_CHECK
#define WEAVE_CONFIG_ENABLE_ARG_PARSER_SANTIY_CHECK 1
#endif

/**
 * @def WEAVE_CONFIG_SERVICE_PROV_RESPONSE_TIMEOUT
 *
 * @brief
 *    The amount of time (in milliseconds) which the service is given
 *    to respond to a pair device to account request.
 */
#ifndef WEAVE_CONFIG_SERVICE_PROV_RESPONSE_TIMEOUT
#define WEAVE_CONFIG_SERVICE_PROV_RESPONSE_TIMEOUT 60000
#endif

/**
 *  @def WEAVE_CONFIG_SUPPORT_LEGACY_ADD_NETWORK_MESSAGE
 *
 *  @brief
 *    Enable (1) or disable (0) support for the depricated
 *    version of AddNetwork() message in the Network Provisioning
 *    profile.
 *    This option should be enabled to support pairing with Nest
 *    legacy devices that don't have latest SW.
 *
 */
#ifndef WEAVE_CONFIG_SUPPORT_LEGACY_ADD_NETWORK_MESSAGE
#define WEAVE_CONFIG_SUPPORT_LEGACY_ADD_NETWORK_MESSAGE     1
#endif // WEAVE_CONFIG_SUPPORT_LEGACY_ADD_NETWORK_MESSAGE

/**
 *  @def WEAVE_CONFIG_ALWAYS_USE_LEGACY_ADD_NETWORK_MESSAGE
 *
 *  @brief
 *    Enable (1) or disable (0) the exclusive use of the deprecated
 *    version of AddNetwork() message in the Network Provisioning
 *    profile.
 *    This option should be enabled when exclusively pairing with Nest
 *    legacy devices that don't have latest SW.
 *    This option requires that
 *    WEAVE_CONFIG_SUPPORT_LEGACY_ADD_NETWORK_MESSAGE is enabled.
 *
 */
#ifndef WEAVE_CONFIG_ALWAYS_USE_LEGACY_ADD_NETWORK_MESSAGE
#define WEAVE_CONFIG_ALWAYS_USE_LEGACY_ADD_NETWORK_MESSAGE     0
#endif // WEAVE_CONFIG_ALWAYS_USE_LEGACY_ADD_NETWORK_MESSAGE

/**
 * @def WEAVE_CONFIG_ENABLE_IFJ_SERVICE_FABRIC_JOIN
 *
 * @brief Enable the Service Provisioning profile message
 * for notification of successful in-field joining of the
 * Weave fabric.
 */
#ifndef WEAVE_CONFIG_ENABLE_IFJ_SERVICE_FABRIC_JOIN
#define WEAVE_CONFIG_ENABLE_IFJ_SERVICE_FABRIC_JOIN         0
#endif // WEAVE_CONFIG_ENABLE_IFJ_SERVICE_FABRIC_JOIN

/**
 *  @def WEAVE_CONFIG_DEVICE_MGR_DEMAND_ENABLE_UDP
 *
 *  @brief
 *    Demand enable UDP as needed in the WeaveDeviceManager
 *
 *  When this option is enabled, the WeaveDeviceManager will automatically enable
 *  listening for Weave messages over UDP whenever required to perform a device
 *  management operation, and disable it when the operation completes.
 *
 *  This feature can be used to reduce competition for UDP listening ports the
 *  WeaveDeviceManager is used in multiple processes on the same host.
 *
 */
#ifndef WEAVE_CONFIG_DEVICE_MGR_DEMAND_ENABLE_UDP
#define WEAVE_CONFIG_DEVICE_MGR_DEMAND_ENABLE_UDP     0
#endif // WEAVE_CONFIG_DEVICE_MGR_DEMAND_ENABLE_UDP

/**
 *  @def WEAVE_CONFIG_MAX_SOFTWARE_VERSION_LENGTH
 *
 *  @brief
 *    Maximum length of the software version field
 *    in DeviceDescription.
 *
 */
#ifndef WEAVE_CONFIG_MAX_SOFTWARE_VERSION_LENGTH
#define WEAVE_CONFIG_MAX_SOFTWARE_VERSION_LENGTH           32
#endif // WEAVE_CONFIG_MAX_SOFTWARE_VERSION_LENGTH

/**
 *  @def WEAVE_CONFIG_ENABLE_OFFLOAD_EVENTS_FIRST
 *
 *  @brief
 *    Enable offloading of events before trait properties
 *
 *  When this option is enabled, WeaveDataManagement will first
 *  attempt to pack events from the eventlist into the NotifyRequest
 *  message before adding modified trait data properties from
 *  the datalist.
 *
 *  This feature can be useful in systems that might need
 *  the events to be dispatched as early as possible.
 *
 */
#ifndef WEAVE_CONFIG_ENABLE_OFFLOAD_EVENTS_FIRST
#define WEAVE_CONFIG_ENABLE_OFFLOAD_EVENTS_FIRST            0
#endif // WEAVE_CONFIG_ENABLE_OFFLOAD_EVENTS_FIRST

/**
 * @def WEAVE_CONFIG_TCP_CONN_REPAIR_SUPPORTED
 *
 * @brief
 *   When this option is enabled, Weave will try to restore the TCP connection
 *   first before attempting to establish a new one.
 *
 */
#ifndef WEAVE_CONFIG_TCP_CONN_REPAIR_SUPPORTED
#define WEAVE_CONFIG_TCP_CONN_REPAIR_SUPPORTED            (INET_CONFIG_TCP_CONN_REPAIR_SUPPORTED)
#endif // WEAVE_CONFIG_TCP_CONN_REPAIR_SUPPORTED

/**
 * @def WEAVE_NON_PRODUCTION_MARKER
 *
 * @brief Defines the name of a mark symbol whose presence signals that the Weave code
 * includes development/testing features that should never be used in production contexts.
 */
#ifndef WEAVE_NON_PRODUCTION_MARKER
#if (WEAVE_CONFIG_SECURITY_TEST_MODE || \
     WEAVE_CONFIG_SUPPORT_PASE_CONFIG0_TEST_ONLY || \
     WEAVE_CONFIG_SUPPORT_PASSCODE_CONFIG1_TEST_ONLY || \
     (!WEAVE_CONFIG_REQUIRE_AUTH) || \
     WEAVE_FUZZING_ENABLED)
#define WEAVE_NON_PRODUCTION_MARKER WARNING__DO_NOT_SHIP__CONTAINS_NON_PRODUCTION_WEAVE_CODE
#endif
#endif

#ifdef WEAVE_NON_PRODUCTION_MARKER
extern const char WEAVE_NON_PRODUCTION_MARKER[];
#endif

// clang-format on

#endif /* WEAVE_CONFIG_H_ */