blob: 0b2ec5c382516de60b34ef0672efd0716e2726ab [file] [log] [blame]
/*
*
* Copyright (c) 2020-2021 Project CHIP Authors
* Copyright (c) 2016-2018 Nest Labs, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/**
* @file
* This file contains default compile-time configuration
* constants for the CHIP System Layer, a common
* abstraction layer for the system networking components
* underlying the various CHIP target network layers.
*
* Package integrators that wish to override these values should
* either use preprocessor definitions or create a project-
* specific SystemProjectConfig.h header and then assert
* HAVE_SYSTEMPROJECTCONFIG_H via the package configuration tool
* via --with-chip-system-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.
*/
#pragma once
/* Platform include headers */
#if CHIP_HAVE_CONFIG_H
#include <system/SystemBuildConfig.h>
#endif
/* Include a CHIP project-specific configuration file, if defined.
*
* An application or module that incorporates CHIP can define a project
* configuration file to override standard CHIP configuration with
* application-specific values. The CHIPProjectConfig.h file is typically
* located outside the CHIP source tree, alongside the source code for the
* application. The config file is included here to enable certain system-wide
* configuration options, primarily related to logging and error reporting.
*/
#ifdef CHIP_PROJECT_CONFIG_INCLUDE
#include CHIP_PROJECT_CONFIG_INCLUDE
#endif
/* Include a CHIP platform-specific configuration file, if defined.
*
* A platform configuration file contains overrides to standard CHIP
* configuration that are specific to the platform or OS on which CHIP is
* running. It is typically provided as apart of an adaptation layer that
* adapts CHIP to the target environment. This adaptation layer may be
* included in the CHIP source tree itself or implemented externally. The
* config file is included here to enable certain system-wide configuration
* options, primarily related to logging and error reporting.
*/
#ifdef CHIP_PLATFORM_CONFIG_INCLUDE
#include CHIP_PLATFORM_CONFIG_INCLUDE
#endif
/* Include a System::Layer project-specific configuration file, if defined.
*
* An application or module that incorporates CHIP can define a project configuration
* file to override standard System Layer configuration with application-specific values.
* The project config file is typically located outside the CHIP source tree,
* alongside the source code for the application.
*/
#ifdef SYSTEM_PROJECT_CONFIG_INCLUDE
#include SYSTEM_PROJECT_CONFIG_INCLUDE
#endif // SYSTEM_PROJECT_CONFIG_INCLUDE
/* Include a System::Layer platform-specific configuration file, if defined.
*
* A platform configuration file contains overrides to standard System Layer configuration
* that are specific to the platform or OS on which CHIP is running. It is typically
* provided as apart of an adaptation layer that adapts CHIP to the target
* environment. This adaptation layer may be included in the CHIP source tree
* itself or implemented externally.
*/
#ifdef SYSTEM_PLATFORM_CONFIG_INCLUDE
#include SYSTEM_PLATFORM_CONFIG_INCLUDE
#endif
/*--- Sanity check on the build configuration logic. ---*/
#if !(CHIP_SYSTEM_CONFIG_USE_LWIP || CHIP_SYSTEM_CONFIG_USE_SOCKETS || CHIP_SYSTEM_CONFIG_USE_NETWORK_FRAMEWORK)
#error "REQUIRED: CHIP_SYSTEM_CONFIG_USE_LWIP || CHIP_SYSTEM_CONFIG_USE_SOCKETS || CHIP_SYSTEM_CONFIG_USE_NETWORK_FRAMEWORK"
#endif // !(CHIP_SYSTEM_CONFIG_USE_LWIP || CHIP_SYSTEM_CONFIG_USE_SOCKETS || CHIP_SYSTEM_USE_NETWORK_FRAMEWORK)
#if CHIP_SYSTEM_CONFIG_USE_LWIP && CHIP_SYSTEM_CONFIG_USE_SOCKETS
#error "FORBIDDEN: CHIP_SYSTEM_CONFIG_USE_LWIP && CHIP_SYSTEM_CONFIG_USE_SOCKETS"
#endif // CHIP_SYSTEM_CONFIG_USE_LWIP && CHIP_SYSTEM_CONFIG_USE_SOCKETS
#if CHIP_SYSTEM_CONFIG_USE_LWIP && CHIP_SYSTEM_CONFIG_USE_NETWORK_FRAMEWORK
#error "FORBIDDEN: CHIP_SYSTEM_CONFIG_USE_LWIP && CHIP_SYSTEM_CONFIG_USE_NETWORK_FRAMEWORK"
#endif // CHIP_SYSTEM_CONFIG_USE_LWIP && CHIP_SYSTEM_CONFIG_USE_NETWORK_FRAMEWORK
#if CHIP_SYSTEM_CONFIG_USE_NETWORK_FRAMEWORK && CHIP_SYSTEM_CONFIG_USE_SOCKETS
#error "FORBIDDEN: CHIP_SYSTEM_CONFIG_USE_NETWORK_FRAMEWORK && CHIP_SYSTEM_CONFIG_USE_SOCKETS"
#endif // CHIP_SYSTEM_CONFIG_USE_NETWORK_FRAMEWORK && CHIP_SYSTEM_CONFIG_USE_SOCKETS
// clang-format off
/**
* @def CHIP_SYSTEM_CONFIG_TRANSFER_INETLAYER_PROJECT_CONFIGURATION
*
* @brief
* Define as 1 to transfer the project configuration variable definitions from InetProjectConfig.h into the corresponding
* variables for the CHIP System Layer.
*/
#ifndef CHIP_SYSTEM_CONFIG_TRANSFER_INETLAYER_PROJECT_CONFIGURATION
#define CHIP_SYSTEM_CONFIG_TRANSFER_INETLAYER_PROJECT_CONFIGURATION 0
#endif // CHIP_SYSTEM_CONFIG_TRANSFER_INETLAYER_PROJECT_CONFIGURATION
#if CHIP_SYSTEM_CONFIG_TRANSFER_INETLAYER_PROJECT_CONFIGURATION
#ifdef INET_PROJECT_CONFIG_INCLUDE
#include INET_PROJECT_CONFIG_INCLUDE
#endif // INET_PROJECT_CONFIG_INCLUDE
#if !defined(CHIP_SYSTEM_CONFIG_POSIX_LOCKING) && defined(INET_CONFIG_POSIX_LOCKING)
#define CHIP_SYSTEM_CONFIG_POSIX_LOCKING INET_CONFIG_POSIX_LOCKING
#endif // !defined(CHIP_SYSTEM_CONFIG_POSIX_LOCKING) && defined(INET_CONFIG_POSIX_LOCKING)
#if !defined(CHIP_SYSTEM_CONFIG_FREERTOS_LOCKING) && defined(INET_CONFIG_FREERTOS_LOCKING)
#define CHIP_SYSTEM_CONFIG_FREERTOS_LOCKING INET_CONFIG_FREERTOS_LOCKING
#endif // !defined(CHIP_SYSTEM_CONFIG_FREERTOS_LOCKING) && defined(INET_CONFIG_FREERTOS_LOCKING)
#if !defined(CHIP_SYSTEM_CONFIG_MBED_LOCKING) && defined(INET_CONFIG_MBED_LOCKING)
#define CHIP_SYSTEM_CONFIG_MBED_LOCKING INET_CONFIG_MBED_LOCKING
#endif // !defined(CHIP_SYSTEM_CONFIG_MBED_LOCKING) && defined(INET_CONFIG_MBED_LOCKING)
#if !defined(CHIP_SYSTEM_CONFIG_PACKETBUFFER_POOL_SIZE) && defined(INET_CONFIG_NUM_BUFS)
#define CHIP_SYSTEM_CONFIG_PACKETBUFFER_POOL_SIZE INET_CONFIG_NUM_BUFS
#endif // !defined(CHIP_SYSTEM_CONFIG_PACKETBUFFER_POOL_SIZE) && defined(INET_CONFIG_NUM_BUFS)
#if !defined(CHIP_SYSTEM_CONFIG_NUM_TIMERS) && defined(INET_CONFIG_NUM_TIMERS)
#define CHIP_SYSTEM_CONFIG_NUM_TIMERS INET_CONFIG_NUM_TIMERS
#endif // !defined(CHIP_SYSTEM_CONFIG_NUM_TIMERS) && defined(INET_CONFIG_NUM_TIMERS)
#endif // CHIP_SYSTEM_CONFIG_TRANSFER_INETLAYER_PROJECT_CONFIGURATION
#if CHIP_SYSTEM_CONFIG_USE_LWIP
#ifdef TARGET_MCU_STM32L4
// [ MBED HACK ]
// We have to undefine |SUCCESS| here to prevent compilation error due to
// conflict with |ErrorStatus| enum type values defined in CMSIS/stm32l4xx.h.
// This problem is only related for when tests are build and nlunit-test.h is used.
#undef SUCCESS
#endif
#include <lwip/opt.h>
#endif // CHIP_SYSTEM_CONFIG_USE_LWIP
/* Configuration option variables defined below */
/**
* @def CHIP_SYSTEM_CONFIG_NO_LOCKING
*
* @brief
* Disable the use of locking within the system layer.
*
* Unless you are simulating an LwIP-based system on a Unix-style host, this value should be left at its default.
*/
#ifndef CHIP_SYSTEM_CONFIG_NO_LOCKING
#define CHIP_SYSTEM_CONFIG_NO_LOCKING 0
#endif /* CHIP_SYSTEM_CONFIG_NO_LOCKING */
/**
* @def CHIP_SYSTEM_CONFIG_POSIX_LOCKING
*
* @brief
* Use POSIX locking. This is enabled by default when not compiling for BSD sockets.
*
* Unless you are simulating an LwIP-based system on a Unix-style host, this value should be left at its default.
*/
#ifndef CHIP_SYSTEM_CONFIG_POSIX_LOCKING
#define CHIP_SYSTEM_CONFIG_POSIX_LOCKING 1
#endif /* CHIP_SYSTEM_CONFIG_POSIX_LOCKING */
/**
* @def CHIP_SYSTEM_CONFIG_FREERTOS_LOCKING
*
* @brief
* Use FreeRTOS locking.
*
* This should be generally asserted (1) for FreeRTOS + LwIP-based systems and deasserted (0) for BSD sockets-based systems.
*
* However, if you are simulating an LwIP-based system atop POSIX threads and BSD sockets, this should also be deasserted (0).
*/
#ifndef CHIP_SYSTEM_CONFIG_FREERTOS_LOCKING
#define CHIP_SYSTEM_CONFIG_FREERTOS_LOCKING 0
#endif /* CHIP_SYSTEM_CONFIG_FREERTOS_LOCKING */
/**
* @def CHIP_SYSTEM_CONFIG_MBED_LOCKING
*
* @brief
* Use Mbed OS locking.
*
* This should be generally asserted (1) for Mbed OS.
*
* However, if you are simulating an LwIP-based system atop POSIX threads and BSD sockets, this should also be deasserted (0).
*/
#ifndef CHIP_SYSTEM_CONFIG_MBED_LOCKING
#define CHIP_SYSTEM_CONFIG_MBED_LOCKING 0
#endif /* CHIP_SYSTEM_CONFIG_MBED_LOCKING */
/**
* @def CHIP_SYSTEM_CONFIG_POOL_USE_HEAP
*
* @brief
* Allocate Pool from Heap for large systems (e.g. Linux).
*/
#ifndef CHIP_SYSTEM_CONFIG_POOL_USE_HEAP
#define CHIP_SYSTEM_CONFIG_POOL_USE_HEAP 0
#endif /* CHIP_SYSTEM_CONFIG_POOL_USE_HEAP */
/**
* @def CHIP_SYSTEM_CONFIG_NO_LOCKING
*
* @brief
* Disable the use of locking within the system layer.
*
* This value is mutually exclusive with CHIP_SYSTEM_CONFIG_POSIX_LOCKING and CHIP_SYSTEM_CONFIG_FREERTOS_LOCKING and CHIP_SYSTEM_CONFIG_MBED_LOCKING.
*/
#ifndef CHIP_SYSTEM_CONFIG_NO_LOCKING
#define CHIP_SYSTEM_CONFIG_NO_LOCKING 0
#endif /* CHIP_SYSTEM_CONFIG_NO_LOCKING */
#if !(CHIP_SYSTEM_CONFIG_POSIX_LOCKING || CHIP_SYSTEM_CONFIG_FREERTOS_LOCKING || CHIP_SYSTEM_CONFIG_MBED_LOCKING || CHIP_SYSTEM_CONFIG_NO_LOCKING)
#error "REQUIRED: CHIP_SYSTEM_CONFIG_POSIX_LOCKING || CHIP_SYSTEM_CONFIG_FREERTOS_LOCKING || CHIP_SYSTEM_CONFIG_MBED_LOCKING || CHIP_SYSTEM_CONFIG_NO_LOCKING"
#endif // !(CHIP_SYSTEM_CONFIG_POSIX_LOCKING || CHIP_SYSTEM_CONFIG_FREERTOS_LOCKING || CHIP_SYSTEM_CONFIG_MBED_LOCKING || CHIP_SYSTEM_CONFIG_NO_LOCKING)
#if CHIP_SYSTEM_CONFIG_NO_LOCKING && (CHIP_SYSTEM_CONFIG_POSIX_LOCKING || CHIP_SYSTEM_CONFIG_FREERTOS_LOCKING || CHIP_SYSTEM_CONFIG_MBED_LOCKING)
#error "FORBIDDEN: CHIP_SYSTEM_CONFIG_NO_LOCKING && (CHIP_SYSTEM_CONFIG_POSIX_LOCKING || CHIP_SYSTEM_CONFIG_FREERTOS_LOCKING || CHIP_SYSTEM_CONFIG_MBED_LOCKING)"
#endif // CHIP_SYSTEM_CONFIG_NO_LOCKING && (CHIP_SYSTEM_CONFIG_POSIX_LOCKING || CHIP_SYSTEM_CONFIG_FREERTOS_LOCKING || CHIP_SYSTEM_CONFIG_MBED_LOCKING)
#if CHIP_SYSTEM_CONFIG_POSIX_LOCKING && CHIP_SYSTEM_CONFIG_FREERTOS_LOCKING
#error "FORBIDDEN: CHIP_SYSTEM_CONFIG_POSIX_LOCKING && CHIP_SYSTEM_CONFIG_FREERTOS_LOCKING"
#endif // CHIP_SYSTEM_CONFIG_POSIX_LOCKING && CHIP_SYSTEM_CONFIG_FREERTOS_LOCKING
#if CHIP_SYSTEM_CONFIG_POSIX_LOCKING && CHIP_SYSTEM_CONFIG_MBED_LOCKING
#error "FORBIDDEN: CHIP_SYSTEM_CONFIG_POSIX_LOCKING && CHIP_SYSTEM_CONFIG_MBED_LOCKING"
#endif // CHIP_SYSTEM_CONFIG_POSIX_LOCKING && CHIP_SYSTEM_CONFIG_MBED_LOCKING
#if CHIP_SYSTEM_CONFIG_FREERTOS_LOCKING && CHIP_SYSTEM_CONFIG_MBED_LOCKING
#error "FORBIDDEN: CHIP_SYSTEM_CONFIG_FREERTOS_LOCKING && CHIP_SYSTEM_CONFIG_MBED_LOCKING"
#endif // CHIP_SYSTEM_CONFIG_FREERTOS_LOCKING && CHIP_SYSTEM_CONFIG_MBED_LOCKING
/**
* @def CHIP_SYSTEM_HEADER_RESERVE_SIZE
*
* @brief
* The number of bytes to reserve in a network packet buffer to contain
* the CHIP message and exchange headers.
*
* This number was calculated as follows:
*
* CHIP Crypto Header:
*
* 4 -- Length of encrypted block
* 4 -- Reserve
* 8 -- Initialization Vector
* 8 -- Encryption Tag
*/
#ifndef CHIP_SYSTEM_CRYPTO_HEADER_RESERVE_SIZE
#define CHIP_SYSTEM_CRYPTO_HEADER_RESERVE_SIZE 24
#endif
/**
* @def CHIP_SYSTEM_HEADER_RESERVE_SIZE
*
* @brief
* The number of bytes to reserve in a network packet buffer to contain
* the CHIP message and exchange headers.
*
* This number was calculated as follows:
*
* CHIP Message Header:
*
* 2 -- Frame Length
* 2 -- Message Header
* 4 -- Message Id
* 8 -- Source Node Id
* 8 -- Destination Node Id
* 2 -- Key Id
*
* CHIP 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 CHIP_SYSTEM_HEADER_RESERVE_SIZE
#define CHIP_SYSTEM_HEADER_RESERVE_SIZE (38 + CHIP_SYSTEM_CRYPTO_HEADER_RESERVE_SIZE)
#endif /* CHIP_SYSTEM_HEADER_RESERVE_SIZE */
/**
* @def CHIP_SYSTEM_CONFIG_PACKETBUFFER_POOL_SIZE
*
* @brief
* This is the total number of packet buffers for the BSD sockets configuration.
*
* This may be set to zero (0) to enable unbounded dynamic allocation using malloc.
*/
#ifndef CHIP_SYSTEM_CONFIG_PACKETBUFFER_POOL_SIZE
#define CHIP_SYSTEM_CONFIG_PACKETBUFFER_POOL_SIZE 15
#endif /* CHIP_SYSTEM_CONFIG_PACKETBUFFER_POOL_SIZE */
/**
* @def CHIP_SYSTEM_CONFIG_PACKETBUFFER_CAPACITY_MAX
*
* @brief
* The maximum size an application can use with \c PacketBuffer. This is not the raw memory size consumed by
* a \c PacketBuffer object.
*
* @note
* Only socket platforms can override the default value. On LwIP-based platforms, the size is derived from the PBUF size
* and overriding the value will result in a compile-time error.
*
* This value should be set large enough to accomodate the usage of PacketBuffer in the system. In particular, for the use
* in CHIP, the value should be set to accomodate the desired path MTU (i.e. the largest IP packet that can be sent over
* the network interface) plus any protocol overhead.
*
* For example, sending an IP packet over the tunnel requires additional overheads that depend on platform's network
* interface. On socket platforms, the tunnel protocol overhead is 47 bytes; on LwIP platforms the overhead is 101 bytes,
* plus any "sub-Ethernet" data structure space (e.g. the linked list pointers used by some interfaces to queue packets).
*
* The overheads are calculated as follows:
*
* (variable) -- "Sub-Ethernet" data structures (LwIP-only)
* 14 -- Ethernet Header (LwIP-only)
* 20 -- IPv4 Header (LwIP-only)
* 20 -- TCP Header (LwIP-only)
* 2 -- CHIP Message Length
* 24 -- CHIP Header
* 1 -- Tunnel Header
* 20 -- Crypto Trailer
*
* The size of PacketBuffer structure does not need to be included in this value.
*/
#if CHIP_SYSTEM_CONFIG_USE_LWIP && !defined(DOXYGEN)
#ifdef CHIP_SYSTEM_CONFIG_PACKETBUFFER_CAPACITY_MAX
#error "CHIP_SYSTEM_CONFIG_PACKETBUFFER_CAPACITY_MAX cannot be defined on an LwIP-based platform."
#endif /* CHIP_SYSTEM_CONFIG_PACKETBUFFER_CAPACITY_MAX */
#else /* !CHIP_SYSTEM_CONFIG_USE_LWIP */
#ifndef CHIP_SYSTEM_CONFIG_PACKETBUFFER_CAPACITY_MAX
#define CHIP_SYSTEM_CONFIG_PACKETBUFFER_CAPACITY_MAX 1583
#endif /* CHIP_SYSTEM_CONFIG_PACKETBUFFER_CAPACITY_MAX */
/**
* @def _CHIP_SYSTEM_CONFIG_LWIP_EVENT
*
* @brief
* This defines a mapping function for CHIP System Layer codes for describing the types of events for the LwIP dispatcher,
* which allows mapping such event types into a platform- or system-specific range.
*/
#ifndef _CHIP_SYSTEM_CONFIG_LWIP_EVENT
#define _CHIP_SYSTEM_CONFIG_LWIP_EVENT(e) (e)
#endif /* _CHIP_SYSTEM_CONFIG_LWIP_EVENT */
#endif /* !CHIP_SYSTEM_CONFIG_USE_LWIP */
/**
* @def CHIP_SYSTEM_CONFIG_EVENT_TYPE
*
* @brief
* This defines the type for CHIP System Layer event types, typically an integral type.
*/
#ifndef CHIP_SYSTEM_CONFIG_EVENT_TYPE
#define CHIP_SYSTEM_CONFIG_EVENT_TYPE int
#endif /* CHIP_SYSTEM_CONFIG_EVENT_TYPE */
/**
* @def CHIP_SYSTEM_CONFIG_EVENT_OBJECT_TYPE
*
* @brief
* This defines the type of CHIP System Layer event objects or "messages".
*
* Such types are not directly used by the CHIP System Layer but are "passed through". Consequently a forward declaration and
* a const pointer or reference are appropriate.
*/
#ifndef CHIP_SYSTEM_CONFIG_EVENT_OBJECT_TYPE
#if CHIP_SYSTEM_CONFIG_USE_LWIP
namespace chip {
namespace System {
struct LwIPEvent;
} // namespace System
} // namespace chip
#define CHIP_SYSTEM_CONFIG_EVENT_OBJECT_TYPE const struct chip::System::LwIPEvent*
#else /* CHIP_SYSTEM_CONFIG_USE_LWIP */
#define CHIP_SYSTEM_CONFIG_EVENT_OBJECT_TYPE const struct ::chip::DeviceLayer::ChipDeviceEvent *
#endif /* CHIP_SYSTEM_CONFIG_USE_LWIP */
#endif /* CHIP_SYSTEM_CONFIG_EVENT_OBJECT_TYPE */
#if CHIP_SYSTEM_CONFIG_USE_LWIP
/**
* @def _CHIP_SYSTEM_CONFIG_LWIP_EVENT
*
* @brief
* This defines a mapping function for CHIP System Layer codes for describing the types of events for the LwIP dispatcher,
* which allows mapping such event types into a platform- or system-specific range.
*/
#ifndef _CHIP_SYSTEM_CONFIG_LWIP_EVENT
#define _CHIP_SYSTEM_CONFIG_LWIP_EVENT(e) (e)
#endif /* _CHIP_SYSTEM_CONFIG_LWIP_EVENT */
#endif /* CHIP_SYSTEM_CONFIG_USE_LWIP */
/**
* @def CHIP_SYSTEM_CONFIG_NUM_TIMERS
*
* @brief
* This is the total number of available timers, for configurations that use a fixed timer pool.
*/
#ifndef CHIP_SYSTEM_CONFIG_NUM_TIMERS
#define CHIP_SYSTEM_CONFIG_NUM_TIMERS 32
#endif /* CHIP_SYSTEM_CONFIG_NUM_TIMERS */
/**
* @def CHIP_SYSTEM_CONFIG_USE_TIMER_POOL
*
* @brief
* This defines whether (1) or not (0) the implementation uses the System::Timer pool.
*/
#ifndef CHIP_SYSTEM_CONFIG_USE_TIMER_POOL
#if CHIP_SYSTEM_CONFIG_NUM_TIMERS > 0
#define CHIP_SYSTEM_CONFIG_USE_TIMER_POOL 1
#else
#define CHIP_SYSTEM_CONFIG_USE_TIMER_POOL 0
#endif
#endif /* CHIP_SYSTEM_CONFIG_USE_TIMER_POOL */
/**
* @def CHIP_SYSTEM_CONFIG_PROVIDE_STATISTICS
*
* @brief
* This defines whether (1) or not (0) the CHIP System Layer provides logic for gathering and reporting statistical
* information for diagnostic purposes.
*/
#ifndef CHIP_SYSTEM_CONFIG_PROVIDE_STATISTICS
#define CHIP_SYSTEM_CONFIG_PROVIDE_STATISTICS 0
#endif // CHIP_SYSTEM_CONFIG_PROVIDE_STATISTICS
/**
* @def CHIP_SYSTEM_CONFIG_TEST
*
* @brief
* Defines whether (1) or not (0) to enable testing aids.
*/
#ifndef CHIP_SYSTEM_CONFIG_TEST
#define CHIP_SYSTEM_CONFIG_TEST 0
#endif
// clang-format on
// Configuration parameters with header inclusion dependencies
/**
* @def CHIP_SYSTEM_CONFIG_HEADER_RESERVE_SIZE
*
* @brief
* The number of bytes to reserve in a network packet buffer to contain all the possible protocol encapsulation headers before the
* application message text. On POSIX sockets, this is CHIP_SYSTEM_HEADER_RESERVE_SIZE. On LwIP, additional space is required for
* the all the headers from layer-2 up to the TCP or UDP header.
*/
#ifndef CHIP_SYSTEM_CONFIG_HEADER_RESERVE_SIZE
#if CHIP_SYSTEM_CONFIG_USE_LWIP
#define CHIP_SYSTEM_CONFIG_HEADER_RESERVE_SIZE \
(PBUF_LINK_HLEN + PBUF_IP_HLEN + PBUF_TRANSPORT_HLEN + CHIP_SYSTEM_HEADER_RESERVE_SIZE)
#else /* !CHIP_SYSTEM_CONFIG_USE_LWIP */
#define CHIP_SYSTEM_CONFIG_HEADER_RESERVE_SIZE (CHIP_SYSTEM_HEADER_RESERVE_SIZE)
#endif /* !CHIP_SYSTEM_CONFIG_USE_LWIP */
#endif /* CHIP_SYSTEM_CONFIG_HEADER_RESERVE_SIZE */
/**
* @def CHIP_SYSTEM_CONFIG_PLATFORM_PROVIDES_TIME
*
* @brief
* Use platform-supplied functions for System Layer clock functions.
*
* Determines whether (1) or not (0) the underlying platform provides implementations for
* the System Layer GetClock/SetClock functions.
*/
#ifndef CHIP_SYSTEM_CONFIG_PLATFORM_PROVIDES_TIME
#define CHIP_SYSTEM_CONFIG_PLATFORM_PROVIDES_TIME 0
#endif // CHIP_SYSTEM_CONFIG_PLATFORM_PROVIDES_TIME
/**
* @def CHIP_SYSTEM_CONFIG_USE_POSIX_TIME_FUNCTS
*
* @brief
* Use the POSIX time functions for System Layer clock functions.
*
* Use the POSIX time functions (clock_gettime, gettimeofday, etc.) to implement the
* System Layer GetClock/SetClock functions.
*
* Defaults to enabled if the system is using sockets.
*
* This configuration is overridden if CHIP_SYSTEM_CONFIG_PLATFORM_PROVIDES_TIME is set.
*/
#ifndef CHIP_SYSTEM_CONFIG_USE_POSIX_TIME_FUNCTS
#if CHIP_SYSTEM_CONFIG_USE_SOCKETS || CHIP_SYSTEM_CONFIG_USE_NETWORK_FRAMEWORK
#define CHIP_SYSTEM_CONFIG_USE_POSIX_TIME_FUNCTS 1
#else // CHIP_SYSTEM_CONFIG_USE_SOCKETS || CHIP_SYSTEM_CONFIG_USE_NETWORK_FRAMEWORK
#define CHIP_SYSTEM_CONFIG_USE_POSIX_TIME_FUNCTS 0
#endif // CHIP_SYSTEM_CONFIG_USE_SOCKETS || CHIP_SYSTEM_CONFIG_USE_NETWORK_FRAMEWORK
#endif // CHIP_SYSTEM_CONFIG_USE_POSIX_TIME_FUNCTS
/**
* @def CHIP_SYSTEM_CONFIG_USE_LWIP_MONOTONIC_TIME
*
* @brief
* Use LwIP time function for System Layer monotonic clock functions.
*
* Use the LwIP sys_now() function to implement the System Clock functions.
*
* Defaults to enabled if the system is using LwIP and not sockets.
*
* This configuration is overridden if CHIP_SYSTEM_CONFIG_PLATFORM_PROVIDES_TIME is set.
*/
#ifndef CHIP_SYSTEM_CONFIG_USE_LWIP_MONOTONIC_TIME
#if CHIP_SYSTEM_CONFIG_USE_LWIP && !CHIP_SYSTEM_CONFIG_USE_SOCKETS
#define CHIP_SYSTEM_CONFIG_USE_LWIP_MONOTONIC_TIME 1
#else
#define CHIP_SYSTEM_CONFIG_USE_LWIP_MONOTONIC_TIME 0
#endif
#endif // CHIP_SYSTEM_CONFIG_USE_LWIP_MONOTONIC_TIME
/**
* @def CHIP_SYSTEM_CONFIG_VALID_REAL_TIME_THRESHOLD
*
* @brief
* The earliest time at which the real time clock is considered to be valid.
*
* The value is given in Unix time scaled to seconds.
*
* The default value corresponds to 2000/01/01 00:00:00
*/
#ifndef CHIP_SYSTEM_CONFIG_VALID_REAL_TIME_THRESHOLD
#define CHIP_SYSTEM_CONFIG_VALID_REAL_TIME_THRESHOLD 946684800
#endif // CHIP_SYSTEM_CONFIG_VALID_REAL_TIME_THRESHOLD
/**
* @def CHIP_SYSTEM_CONFIG_USE_POSIX_PIPE
*
* @brief
* Use the POSIX pipe() function.
*
* Use the POSIX pipe() function to create an anonymous data stream.
*
* Defaults to enabled if the system is using sockets (except for Zephyr RTOS).
*/
#ifndef CHIP_SYSTEM_CONFIG_USE_POSIX_PIPE
#if (CHIP_SYSTEM_CONFIG_USE_SOCKETS || CHIP_SYSTEM_CONFIG_USE_NETWORK_FRAMEWORK) && !__ZEPHYR__ && !__MBED__
#define CHIP_SYSTEM_CONFIG_USE_POSIX_PIPE 1
#else
#define CHIP_SYSTEM_CONFIG_USE_POSIX_PIPE 0
#endif
#endif // CHIP_SYSTEM_CONFIG_USE_POSIX_PIPE
/**
* @def CHIP_SYSTEM_CONFIG_USE_ZEPHYR_SOCKET_EXTENSIONS
*
* @brief
* Include missing functions for Zephyr sockets
*
* Zephyr socket API lacks some of the functions required by CHIP.
* If this value is set CHIP will provide the missing functions.
*
* Defaults to enabled on Zephyr platforms using sockets
*/
#ifndef CHIP_SYSTEM_CONFIG_USE_ZEPHYR_SOCKET_EXTENSIONS
#if CHIP_SYSTEM_CONFIG_USE_SOCKETS && __ZEPHYR__
#define CHIP_SYSTEM_CONFIG_USE_ZEPHYR_SOCKET_EXTENSIONS 1
#else
#define CHIP_SYSTEM_CONFIG_USE_ZEPHYR_SOCKET_EXTENSIONS 0
#endif
#endif // CHIP_SYSTEM_CONFIG_USE_ZEPHYR_SOCKET_EXTENSIONS
/**
* @def CHIP_SYSTEM_CONFIG_USE_PLATFORM_MULTICAST_API
*
* @brief
* Use platform API to join and leave multicast groups.
*
* In case a given platform does not support adding and removing multicast
* addresses to a network interface using the generic network API like LWIP
* or sockets, this setting allows the platform layer to inject handlers
* which achieve the goal by other means.
*
* Defaults to enabled on Zephyr platforms using sockets
*/
#ifndef CHIP_SYSTEM_CONFIG_USE_PLATFORM_MULTICAST_API
#if CHIP_SYSTEM_CONFIG_USE_SOCKETS && __ZEPHYR__
#define CHIP_SYSTEM_CONFIG_USE_PLATFORM_MULTICAST_API 1
#else
#define CHIP_SYSTEM_CONFIG_USE_PLATFORM_MULTICAST_API 0
#endif
#endif // CHIP_SYSTEM_CONFIG_USE_PLATFORM_MULTICAST_API
/**
* @def CHIP_SYSTEM_CONFIG_USE_ZEPHYR_NET_IF
*
* @brief
* Use Zephyr net_if API to enumerate available network interfaces
*
* Defaults to enabled on Zephyr platforms using sockets
*/
#ifndef CHIP_SYSTEM_CONFIG_USE_ZEPHYR_NET_IF
#if CHIP_SYSTEM_CONFIG_USE_SOCKETS && __ZEPHYR__
#define CHIP_SYSTEM_CONFIG_USE_ZEPHYR_NET_IF 1
#else
#define CHIP_SYSTEM_CONFIG_USE_ZEPHYR_NET_IF 0
#endif
#endif // CHIP_SYSTEM_CONFIG_USE_ZEPHYR_NET_IF
/**
* @def CHIP_SYSTEM_CONFIG_USE_BSD_IFADDRS
*
* @brief
* Use BSD ifaddrs.h API to enumerate available network interfaces
*
* Defaults to enabled on Unix/Linux platforms using sockets
*/
#ifndef CHIP_SYSTEM_CONFIG_USE_BSD_IFADDRS
#if (CHIP_SYSTEM_CONFIG_USE_SOCKETS || CHIP_SYSTEM_CONFIG_USE_NETWORK_FRAMEWORK) && !__ZEPHYR__
#define CHIP_SYSTEM_CONFIG_USE_BSD_IFADDRS 1
#else
#define CHIP_SYSTEM_CONFIG_USE_BSD_IFADDRS 0
#endif
#endif // CHIP_SYSTEM_CONFIG_USE_BSD_IFADDRS