/** * @file * * lwIP Options Configuration *//* * Copyright (c) 2001-2004 Swedish Institute of Computer Science. * All rights reserved.  *  * Redistribution and use in source and binary forms, with or without modification,  * are permitted provided that the following conditions are met: * * 1. Redistributions of source code must retain the above copyright notice, *    this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright notice, *    this list of conditions and the following disclaimer in the documentation *    and/or other materials provided with the distribution. * 3. The name of the author may not be used to endorse or promote products *    derived from this software without specific prior written permission.  * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED  * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF  * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT  * SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT  * OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING  * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY  * OF SUCH DAMAGE. * * This file is part of the lwIP TCP/IP stack. *  * Author: Adam Dunkels <adam@sics.se> * */#ifndef __LWIP_OPT_H__#define __LWIP_OPT_H__/* * Include user defined options first. Anything not defined in these files * will be set to standard values. Override anything you dont like! */#include "lwipopts.h"#include "lwip/debug.h"/*   -----------------------------------------------   ---------- Platform specific locking ----------   -----------------------------------------------*//** * SYS_LIGHTWEIGHT_PROT==1: if you want inter-task protection for certain * critical regions during buffer allocation, deallocation and memory * allocation and deallocation. */#ifndef SYS_LIGHTWEIGHT_PROT#define SYS_LIGHTWEIGHT_PROT            0#endif/**  * NO_SYS==1: Provides VERY minimal functionality. Otherwise, * use lwIP facilities. */#ifndef NO_SYS#define NO_SYS                          0#endif/** * MEMCPY: override this if you have a faster implementation at hand than the * one included in your C library */#ifndef MEMCPY#define MEMCPY(dst,src,len)             memcpy(dst,src,len)#endif/** * SMEMCPY: override this with care! Some compilers (e.g. gcc) can inline a * call to memcpy() if the length is known at compile time and is small. */#ifndef SMEMCPY#define SMEMCPY(dst,src,len)            memcpy(dst,src,len)#endif/*   ------------------------------------   ---------- Memory options ----------   ------------------------------------*//** * MEM_LIBC_MALLOC==1: Use malloc/free/realloc provided by your C-library * instead of the lwip internal allocator. Can save code size if you * already use it. */#ifndef MEM_LIBC_MALLOC#define MEM_LIBC_MALLOC                 0#endif/** * MEM_ALIGNMENT: should be set to the alignment of the CPU *    4 byte alignment -> #define MEM_ALIGNMENT 4 *    2 byte alignment -> #define MEM_ALIGNMENT 2 */#ifndef MEM_ALIGNMENT#define MEM_ALIGNMENT                   1#endif/** * MEM_SIZE: the size of the heap memory. If the application will send * a lot of data that needs to be copied, this should be set high. */#ifndef MEM_SIZE#define MEM_SIZE                        1600#endif/** * MEMP_OVERFLOW_CHECK: memp overflow protection reserves a configurable * amount of bytes before and after each memp element in every pool and fills * it with a prominent default value. *    MEMP_OVERFLOW_CHECK == 0 no checking *    MEMP_OVERFLOW_CHECK == 1 checks each element when it is freed *    MEMP_OVERFLOW_CHECK >= 2 checks each element in every pool every time *      memp_malloc() or memp_free() is called (useful but slow!) */#ifndef MEMP_OVERFLOW_CHECK#define MEMP_OVERFLOW_CHECK             0#endif/** * MEMP_SANITY_CHECK==1: run a sanity check after each memp_free() to make * sure that there are no cycles in the linked lists. */#ifndef MEMP_SANITY_CHECK#define MEMP_SANITY_CHECK               0#endif/** * MEM_USE_POOLS==1: Use an alternative to malloc() by allocating from a set * of memory pools of various sizes. When mem_malloc is called, an element of * the smallest pool that can provide the lenght needed is returned. */#ifndef MEM_USE_POOLS#define MEM_USE_POOLS                   0#endif/** * MEMP_USE_CUSTOM_POOLS==1: whether to include a user file lwippools.h * that defines additional pools beyond the "standard" ones required * by lwIP. If you set this to 1, you must have lwippools.h in your  * inlude path somewhere.  */#ifndef MEMP_USE_CUSTOM_POOLS#define MEMP_USE_CUSTOM_POOLS           0#endif/*   ------------------------------------------------   ---------- Internal Memory Pool Sizes ----------   ------------------------------------------------*//** * MEMP_NUM_PBUF: the number of memp struct pbufs (used for PBUF_ROM and PBUF_REF). * If the application sends a lot of data out of ROM (or other static memory), * this should be set high. */#ifndef MEMP_NUM_PBUF#define MEMP_NUM_PBUF                   32#endif/** * MEMP_NUM_RAW_PCB: Number of raw connection PCBs * (requires the LWIP_RAW option) */#ifndef MEMP_NUM_RAW_PCB#define MEMP_NUM_RAW_PCB                4#endif/** * MEMP_NUM_UDP_PCB: the number of UDP protocol control blocks. One * per active UDP "connection". * (requires the LWIP_UDP option) */#ifndef MEMP_NUM_UDP_PCB#define MEMP_NUM_UDP_PCB                4#endif/** * MEMP_NUM_TCP_PCB: the number of simulatenously active TCP connections. * (requires the LWIP_TCP option) */#ifndef MEMP_NUM_TCP_PCB#define MEMP_NUM_TCP_PCB                5#endif/** * MEMP_NUM_TCP_PCB_LISTEN: the number of listening TCP connections. * (requires the LWIP_TCP option) */#ifndef MEMP_NUM_TCP_PCB_LISTEN#define MEMP_NUM_TCP_PCB_LISTEN         8#endif/** * MEMP_NUM_TCP_SEG: the number of simultaneously queued TCP segments. * (requires the LWIP_TCP option) */#ifndef MEMP_NUM_TCP_SEG#define MEMP_NUM_TCP_SEG                16#endif/** * MEMP_NUM_REASSDATA: the number of simultaneously IP packets queued for * reassembly (whole packets, not fragments!) */#ifndef MEMP_NUM_REASSDATA#define MEMP_NUM_REASSDATA              5#endif/** * MEMP_NUM_ARP_QUEUE: the number of simulateously queued outgoing * packets (pbufs) that are waiting for an ARP request (to resolve * their destination address) to finish. * (requires the ARP_QUEUEING option) */#ifndef MEMP_NUM_ARP_QUEUE#define MEMP_NUM_ARP_QUEUE              30#endif/** * MEMP_NUM_IGMP_GROUP: The number of multicast groups whose network interfaces * can be members et the same time (one per netif - allsystems group -, plus one * per netif membership). * (requires the LWIP_IGMP option) */#ifndef MEMP_NUM_IGMP_GROUP#define MEMP_NUM_IGMP_GROUP             8#endif/** * MEMP_NUM_SYS_TIMEOUT: the number of simulateously active timeouts. * (requires NO_SYS==0) */#ifndef MEMP_NUM_SYS_TIMEOUT#define MEMP_NUM_SYS_TIMEOUT            3#endif/** * MEMP_NUM_NETBUF: the number of struct netbufs. * (only needed if you use the sequential API, like api_lib.c) */#ifndef MEMP_NUM_NETBUF#define MEMP_NUM_NETBUF                 2#endif/** * MEMP_NUM_NETCONN: the number of struct netconns. * (only needed if you use the sequential API, like api_lib.c) */#ifndef MEMP_NUM_NETCONN#define MEMP_NUM_NETCONN                4#endif/** * MEMP_NUM_TCPIP_MSG_API: the number of struct tcpip_msg, which are used * for callback/timeout API communication.  * (only needed if you use tcpip.c) */#ifndef MEMP_NUM_TCPIP_MSG_API#define MEMP_NUM_TCPIP_MSG_API          8#endif/** * MEMP_NUM_TCPIP_MSG_INPKT: the number of struct tcpip_msg, which are used * for incoming packets.  * (only needed if you use tcpip.c) */#ifndef MEMP_NUM_TCPIP_MSG_INPKT#define MEMP_NUM_TCPIP_MSG_INPKT        8#endif/** * PBUF_POOL_SIZE: the number of buffers in the pbuf pool.  */#ifndef PBUF_POOL_SIZE#define PBUF_POOL_SIZE                  32#endif/*   ---------------------------------   ---------- ARP options ----------   ---------------------------------*//** * LWIP_ARP==1: Enable ARP functionality. */#ifndef LWIP_ARP#define LWIP_ARP                        1#endif/** * ARP_TABLE_SIZE: Number of active MAC-IP address pairs cached. */#ifndef ARP_TABLE_SIZE#define ARP_TABLE_SIZE                  10#endif/** * ARP_QUEUEING==1: Outgoing packets are queued during hardware address * resolution. */#ifndef ARP_QUEUEING#define ARP_QUEUEING                    1#endif/** * ETHARP_TRUST_IP_MAC==1: Incoming IP packets cause the ARP table to be * updated with the source MAC and IP addresses supplied in the packet. * You may want to disable this if you do not trust LAN peers to have the * correct addresses, or as a limited approach to attempt to handle * spoofing. If disabled, lwIP will need to make a new ARP request if * the peer is not already in the ARP table, adding a little latency. */#ifndef ETHARP_TRUST_IP_MAC#define ETHARP_TRUST_IP_MAC             1#endif/*   --------------------------------   ---------- IP options ----------   --------------------------------*//** * IP_FORWARD==1: Enables the ability to forward IP packets across network * interfaces. If you are going to run lwIP on a device with only one network * interface, define this to 0. */#ifndef IP_FORWARD#define IP_FORWARD                      0#endif/** * IP_OPTIONS_ALLOWED: Defines the behavior for IP options. *      IP_OPTIONS_ALLOWED==0: All packets with IP options are dropped. *      IP_OPTIONS_ALLOWED==1: IP options are allowed (but not parsed). */#ifndef IP_OPTIONS_ALLOWED#define IP_OPTIONS_ALLOWED              1#endif/** * IP_REASSEMBLY==1: Reassemble incoming fragmented IP packets. Note that * this option does not affect outgoing packet sizes, which can be controlled * via IP_FRAG. */#ifndef IP_REASSEMBLY#define IP_REASSEMBLY                   1#endif/** * IP_FRAG==1: Fragment outgoing IP packets if their size exceeds MTU. Note * that this option does not affect incoming packet sizes, which can be * controlled via IP_REASSEMBLY. */#ifndef IP_FRAG#define IP_FRAG                         1#endif/** * IP_REASS_MAXAGE: Maximum time (in multiples of IP_TMR_INTERVAL - so seconds, normally) * a fragmented IP packet waits for all fragments to arrive. If not all fragments arrived * in this time, the whole packet is discarded. */#ifndef IP_REASS_MAXAGE#define IP_REASS_MAXAGE                 3#endif/** * IP_REASS_MAX_PBUFS: Total maximum amount of pbufs waiting to be reassembled. * Since the received pbufs are enqueued, be sure to configure * PBUF_POOL_SIZE > IP_REASS_MAX_PBUFS so that the stack is still able to receive * packets even if the maximum amount of fragments is enqueued for reassembly! */#ifndef IP_REASS_MAX_PBUFS#define IP_REASS_MAX_PBUFS              10#endif/** * IP_FRAG_USES_STATIC_BUF==1: Use a static MTU-sized buffer for IP * fragmentation. Otherwise pbufs are allocated and reference the original * packet data to be fragmented. */#ifndef IP_FRAG_USES_STATIC_BUF#define IP_FRAG_USES_STATIC_BUF         1#endif/** * IP_FRAG_MAX_MTU: Assumed max MTU on any interface for IP frag buffer * (requires IP_FRAG_USES_STATIC_BUF==1) */#if IP_FRAG_USES_STATIC_BUF && !defined(IP_FRAG_MAX_MTU)#define IP_FRAG_MAX_MTU                 1500#endif/** * IP_DEFAULT_TTL: Default value for Time-To-Live used by transport layers. */#ifndef IP_DEFAULT_TTL#define IP_DEFAULT_TTL                  255#endif/*   ----------------------------------   ---------- ICMP options ----------   ----------------------------------*//** * LWIP_ICMP==1: Enable ICMP module inside the IP stack. * Be careful, disable that make your product non-compliant to RFC1122 */#ifndef LWIP_ICMP#define LWIP_ICMP                       1#endif/** * ICMP_TTL: Default value for Time-To-Live used by ICMP packets. */#ifndef ICMP_TTL#define ICMP_TTL                       (IP_DEFAULT_TTL)#endif/*   ---------------------------------   ---------- RAW options ----------   ---------------------------------*//** * LWIP_RAW==1: Enable application layer to hook into the IP layer itself. */#ifndef LWIP_RAW#define LWIP_RAW                        1#endif/** * LWIP_RAW==1: Enable application layer to hook into the IP layer itself. */#ifndef RAW_TTL#define RAW_TTL                        (IP_DEFAULT_TTL)#endif/*   ----------------------------------   ---------- DHCP options ----------   ----------------------------------*//** * LWIP_DHCP==1: Enable DHCP module. */#ifndef LWIP_DHCP#define LWIP_DHCP                       0#endif/** * DHCP_DOES_ARP_CHECK==1: Do an ARP check on the offered address. */#ifndef DHCP_DOES_ARP_CHECK#define DHCP_DOES_ARP_CHECK             ((LWIP_DHCP) && (LWIP_ARP))#endif/*   ------------------------------------   ---------- AUTOIP options ----------   ------------------------------------*//** * LWIP_AUTOIP==1: Enable AUTOIP module. */#ifndef LWIP_AUTOIP#define LWIP_AUTOIP                     0#endif/** * LWIP_DHCP_AUTOIP_COOP==1: Allow DHCP and AUTOIP to be both enabled on * the same interface at the same time. */#ifndef LWIP_DHCP_AUTOIP_COOP#define LWIP_DHCP_AUTOIP_COOP           0#endif/*   ----------------------------------   ---------- SNMP options ----------   ----------------------------------*//** * LWIP_SNMP==1: Turn on SNMP module. UDP must be available for SNMP * transport. */#ifndef LWIP_SNMP#define LWIP_SNMP                       0#endif/** * SNMP_CONCURRENT_REQUESTS: Number of concurrent requests the module will * allow. At least one request buffer is required.  */#ifndef SNMP_CONCURRENT_REQUESTS#define SNMP_CONCURRENT_REQUESTS        1#endif/** * SNMP_TRAP_DESTINATIONS: Number of trap destinations. At least one trap * destination is required */#ifndef SNMP_TRAP_DESTINATIONS#define SNMP_TRAP_DESTINATIONS          1#endif/** * SNMP_PRIVATE_MIB:  */#ifndef SNMP_PRIVATE_MIB#define SNMP_PRIVATE_MIB                0#endif/** * Only allow SNMP write actions that are 'safe' (e.g. disabeling netifs is not * a safe action and disabled when SNMP_SAFE_REQUESTS = 1). * Unsafe requests are disabled by default! */#ifndef SNMP_SAFE_REQUESTS#define SNMP_SAFE_REQUESTS              1#endif/*   ----------------------------------   ---------- IGMP options ----------   ----------------------------------*//** * LWIP_IGMP==1: Turn on IGMP module.  */#ifndef LWIP_IGMP#define LWIP_IGMP                       0#endif/*   ----------------------------------   ---------- DNS options -----------   ----------------------------------*/