Permalink
Cannot retrieve contributors at this time
/* | |
* | |
* 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_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_ */ |