1/** 2 * @file 3 * 4 * lwIP Options Configuration 5 */ 6 7/* 8 * Copyright (c) 2001-2004 Swedish Institute of Computer Science. 9 * All rights reserved. 10 * 11 * Redistribution and use in source and binary forms, with or without modification, 12 * are permitted provided that the following conditions are met: 13 * 14 * 1. Redistributions of source code must retain the above copyright notice, 15 * this list of conditions and the following disclaimer. 16 * 2. Redistributions in binary form must reproduce the above copyright notice, 17 * this list of conditions and the following disclaimer in the documentation 18 * and/or other materials provided with the distribution. 19 * 3. The name of the author may not be used to endorse or promote products 20 * derived from this software without specific prior written permission. 21 * 22 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED 23 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF 24 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT 25 * SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, 26 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT 27 * OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 28 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 29 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING 30 * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY 31 * OF SUCH DAMAGE. 32 * 33 * This file is part of the lwIP TCP/IP stack. 34 * 35 * Author: Adam Dunkels <adam@sics.se> 36 * 37 */ 38#ifndef __LWIP_OPT_H__ 39#define __LWIP_OPT_H__ 40 41/* 42 * Include user defined options first. Anything not defined in these files 43 * will be set to standard values. Override anything you dont like! 44 */ 45#include "lwipopts.h" 46#include "lwip/debug.h" 47 48/* 49 ----------------------------------------------- 50 ---------- Platform specific locking ---------- 51 ----------------------------------------------- 52*/ 53 54/** 55 * SYS_LIGHTWEIGHT_PROT==1: if you want inter-task protection for certain 56 * critical regions during buffer allocation, deallocation and memory 57 * allocation and deallocation. 58 */ 59#ifndef SYS_LIGHTWEIGHT_PROT 60#define SYS_LIGHTWEIGHT_PROT 0 61#endif 62 63/** 64 * NO_SYS==1: Provides VERY minimal functionality. Otherwise, 65 * use lwIP facilities. 66 */ 67#ifndef NO_SYS 68#define NO_SYS 0 69#endif 70 71/** 72 * NO_SYS_NO_TIMERS==1: Drop support for sys_timeout when NO_SYS==1 73 * Mainly for compatibility to old versions. 74 */ 75#ifndef NO_SYS_NO_TIMERS 76#define NO_SYS_NO_TIMERS 0 77#endif 78 79/** 80 * MEMCPY: override this if you have a faster implementation at hand than the 81 * one included in your C library 82 */ 83#ifndef MEMCPY 84#define MEMCPY(dst,src,len) memcpy(dst,src,len) 85#endif 86 87/** 88 * SMEMCPY: override this with care! Some compilers (e.g. gcc) can inline a 89 * call to memcpy() if the length is known at compile time and is small. 90 */ 91#ifndef SMEMCPY 92#define SMEMCPY(dst,src,len) memcpy(dst,src,len) 93#endif 94 95/* 96 ------------------------------------ 97 ---------- Memory options ---------- 98 ------------------------------------ 99*/ 100/** 101 * MEM_LIBC_MALLOC==1: Use malloc/free/realloc provided by your C-library 102 * instead of the lwip internal allocator. Can save code size if you 103 * already use it. 104 */ 105#ifndef MEM_LIBC_MALLOC 106#define MEM_LIBC_MALLOC 0 107#endif 108 109/** 110* MEMP_MEM_MALLOC==1: Use mem_malloc/mem_free instead of the lwip pool allocator. 111* Especially useful with MEM_LIBC_MALLOC but handle with care regarding execution 112* speed and usage from interrupts! 113*/ 114#ifndef MEMP_MEM_MALLOC 115#define MEMP_MEM_MALLOC 0 116#endif 117 118/** 119 * MEM_ALIGNMENT: should be set to the alignment of the CPU 120 * 4 byte alignment -> #define MEM_ALIGNMENT 4 121 * 2 byte alignment -> #define MEM_ALIGNMENT 2 122 */ 123#ifndef MEM_ALIGNMENT 124#define MEM_ALIGNMENT 1 125#endif 126 127/** 128 * MEM_SIZE: the size of the heap memory. If the application will send 129 * a lot of data that needs to be copied, this should be set high. 130 */ 131#ifndef MEM_SIZE 132#define MEM_SIZE 1600 133#endif 134 135/** 136 * MEMP_SEPARATE_POOLS: if defined to 1, each pool is placed in its own array. 137 * This can be used to individually change the location of each pool. 138 * Default is one big array for all pools 139 */ 140#ifndef MEMP_SEPARATE_POOLS 141#define MEMP_SEPARATE_POOLS 0 142#endif 143 144/** 145 * MEMP_OVERFLOW_CHECK: memp overflow protection reserves a configurable 146 * amount of bytes before and after each memp element in every pool and fills 147 * it with a prominent default value. 148 * MEMP_OVERFLOW_CHECK == 0 no checking 149 * MEMP_OVERFLOW_CHECK == 1 checks each element when it is freed 150 * MEMP_OVERFLOW_CHECK >= 2 checks each element in every pool every time 151 * memp_malloc() or memp_free() is called (useful but slow!) 152 */ 153#ifndef MEMP_OVERFLOW_CHECK 154#define MEMP_OVERFLOW_CHECK 0 155#endif 156 157/** 158 * MEMP_SANITY_CHECK==1: run a sanity check after each memp_free() to make 159 * sure that there are no cycles in the linked lists. 160 */ 161#ifndef MEMP_SANITY_CHECK 162#define MEMP_SANITY_CHECK 0 163#endif 164 165/** 166 * MEM_USE_POOLS==1: Use an alternative to malloc() by allocating from a set 167 * of memory pools of various sizes. When mem_malloc is called, an element of 168 * the smallest pool that can provide the length needed is returned. 169 * To use this, MEMP_USE_CUSTOM_POOLS also has to be enabled. 170 */ 171#ifndef MEM_USE_POOLS 172#define MEM_USE_POOLS 0 173#endif 174 175/** 176 * MEM_USE_POOLS_TRY_BIGGER_POOL==1: if one malloc-pool is empty, try the next 177 * bigger pool - WARNING: THIS MIGHT WASTE MEMORY but it can make a system more 178 * reliable. */ 179#ifndef MEM_USE_POOLS_TRY_BIGGER_POOL 180#define MEM_USE_POOLS_TRY_BIGGER_POOL 0 181#endif 182 183/** 184 * MEMP_USE_CUSTOM_POOLS==1: whether to include a user file lwippools.h 185 * that defines additional pools beyond the "standard" ones required 186 * by lwIP. If you set this to 1, you must have lwippools.h in your 187 * inlude path somewhere. 188 */ 189#ifndef MEMP_USE_CUSTOM_POOLS 190#define MEMP_USE_CUSTOM_POOLS 0 191#endif 192 193/** 194 * Set this to 1 if you want to free PBUF_RAM pbufs (or call mem_free()) from 195 * interrupt context (or another context that doesn't allow waiting for a 196 * semaphore). 197 * If set to 1, mem_malloc will be protected by a semaphore and SYS_ARCH_PROTECT, 198 * while mem_free will only use SYS_ARCH_PROTECT. mem_malloc SYS_ARCH_UNPROTECTs 199 * with each loop so that mem_free can run. 200 * 201 * ATTENTION: As you can see from the above description, this leads to dis-/ 202 * enabling interrupts often, which can be slow! Also, on low memory, mem_malloc 203 * can need longer. 204 * 205 * If you don't want that, at least for NO_SYS=0, you can still use the following 206 * functions to enqueue a deallocation call which then runs in the tcpip_thread 207 * context: 208 * - pbuf_free_callback(p); 209 * - mem_free_callback(m); 210 */ 211#ifndef LWIP_ALLOW_MEM_FREE_FROM_OTHER_CONTEXT 212#define LWIP_ALLOW_MEM_FREE_FROM_OTHER_CONTEXT 0 213#endif 214 215/* 216 ------------------------------------------------ 217 ---------- Internal Memory Pool Sizes ---------- 218 ------------------------------------------------ 219*/ 220/** 221 * MEMP_NUM_PBUF: the number of memp struct pbufs (used for PBUF_ROM and PBUF_REF). 222 * If the application sends a lot of data out of ROM (or other static memory), 223 * this should be set high. 224 */ 225#ifndef MEMP_NUM_PBUF 226#define MEMP_NUM_PBUF 16 227#endif 228 229/** 230 * MEMP_NUM_RAW_PCB: Number of raw connection PCBs 231 * (requires the LWIP_RAW option) 232 */ 233#ifndef MEMP_NUM_RAW_PCB 234#define MEMP_NUM_RAW_PCB 4 235#endif 236 237/** 238 * MEMP_NUM_UDP_PCB: the number of UDP protocol control blocks. One 239 * per active UDP "connection". 240 * (requires the LWIP_UDP option) 241 */ 242#ifndef MEMP_NUM_UDP_PCB 243#define MEMP_NUM_UDP_PCB 4 244#endif 245 246/** 247 * MEMP_NUM_TCP_PCB: the number of simulatenously active TCP connections. 248 * (requires the LWIP_TCP option) 249 */ 250#ifndef MEMP_NUM_TCP_PCB 251#define MEMP_NUM_TCP_PCB 5 252#endif 253 254/** 255 * MEMP_NUM_TCP_PCB_LISTEN: the number of listening TCP connections. 256 * (requires the LWIP_TCP option) 257 */ 258#ifndef MEMP_NUM_TCP_PCB_LISTEN 259#define MEMP_NUM_TCP_PCB_LISTEN 8 260#endif 261 262/** 263 * MEMP_NUM_TCP_SEG: the number of simultaneously queued TCP segments. 264 * (requires the LWIP_TCP option) 265 */ 266#ifndef MEMP_NUM_TCP_SEG 267#define MEMP_NUM_TCP_SEG 16 268#endif 269 270/** 271 * MEMP_NUM_REASSDATA: the number of IP packets simultaneously queued for 272 * reassembly (whole packets, not fragments!) 273 */ 274#ifndef MEMP_NUM_REASSDATA 275#define MEMP_NUM_REASSDATA 5 276#endif 277 278/** 279 * MEMP_NUM_FRAG_PBUF: the number of IP fragments simultaneously sent 280 * (fragments, not whole packets!). 281 * This is only used with IP_FRAG_USES_STATIC_BUF==0 and 282 * LWIP_NETIF_TX_SINGLE_PBUF==0 and only has to be > 1 with DMA-enabled MACs 283 * where the packet is not yet sent when netif->output returns. 284 */ 285#ifndef MEMP_NUM_FRAG_PBUF 286#define MEMP_NUM_FRAG_PBUF 15 287#endif 288 289/** 290 * MEMP_NUM_ARP_QUEUE: the number of simulateously queued outgoing 291 * packets (pbufs) that are waiting for an ARP request (to resolve 292 * their destination address) to finish. 293 * (requires the ARP_QUEUEING option) 294 */ 295#ifndef MEMP_NUM_ARP_QUEUE 296#define MEMP_NUM_ARP_QUEUE 30 297#endif 298 299/** 300 * MEMP_NUM_IGMP_GROUP: The number of multicast groups whose network interfaces 301 * can be members et the same time (one per netif - allsystems group -, plus one 302 * per netif membership). 303 * (requires the LWIP_IGMP option) 304 */ 305#ifndef MEMP_NUM_IGMP_GROUP 306#define MEMP_NUM_IGMP_GROUP 8 307#endif 308 309/** 310 * MEMP_NUM_SYS_TIMEOUT: the number of simulateously active timeouts. 311 * (requires NO_SYS==0) 312 */ 313#ifndef MEMP_NUM_SYS_TIMEOUT 314#define MEMP_NUM_SYS_TIMEOUT 3 315#endif 316 317/** 318 * MEMP_NUM_NETBUF: the number of struct netbufs. 319 * (only needed if you use the sequential API, like api_lib.c) 320 */ 321#ifndef MEMP_NUM_NETBUF 322#define MEMP_NUM_NETBUF 2 323#endif 324 325/** 326 * MEMP_NUM_NETCONN: the number of struct netconns. 327 * (only needed if you use the sequential API, like api_lib.c) 328 */ 329#ifndef MEMP_NUM_NETCONN 330#define MEMP_NUM_NETCONN 4 331#endif 332 333/** 334 * MEMP_NUM_TCPIP_MSG_API: the number of struct tcpip_msg, which are used 335 * for callback/timeout API communication. 336 * (only needed if you use tcpip.c) 337 */ 338#ifndef MEMP_NUM_TCPIP_MSG_API 339#define MEMP_NUM_TCPIP_MSG_API 8 340#endif 341 342/** 343 * MEMP_NUM_TCPIP_MSG_INPKT: the number of struct tcpip_msg, which are used 344 * for incoming packets. 345 * (only needed if you use tcpip.c) 346 */ 347#ifndef MEMP_NUM_TCPIP_MSG_INPKT 348#define MEMP_NUM_TCPIP_MSG_INPKT 8 349#endif 350 351/** 352 * MEMP_NUM_SNMP_NODE: the number of leafs in the SNMP tree. 353 */ 354#ifndef MEMP_NUM_SNMP_NODE 355#define MEMP_NUM_SNMP_NODE 50 356#endif 357 358/** 359 * MEMP_NUM_SNMP_ROOTNODE: the number of branches in the SNMP tree. 360 * Every branch has one leaf (MEMP_NUM_SNMP_NODE) at least! 361 */ 362#ifndef MEMP_NUM_SNMP_ROOTNODE 363#define MEMP_NUM_SNMP_ROOTNODE 30 364#endif 365 366/** 367 * MEMP_NUM_SNMP_VARBIND: the number of concurrent requests (does not have to 368 * be changed normally) - 2 of these are used per request (1 for input, 369 * 1 for output) 370 */ 371#ifndef MEMP_NUM_SNMP_VARBIND 372#define MEMP_NUM_SNMP_VARBIND 2 373#endif 374 375/** 376 * MEMP_NUM_SNMP_VALUE: the number of OID or values concurrently used 377 * (does not have to be changed normally) - 3 of these are used per request 378 * (1 for the value read and 2 for OIDs - input and output) 379 */ 380#ifndef MEMP_NUM_SNMP_VALUE 381#define MEMP_NUM_SNMP_VALUE 3 382#endif 383 384/** 385 * MEMP_NUM_NETDB: the number of concurrently running lwip_addrinfo() calls 386 * (before freeing the corresponding memory using lwip_freeaddrinfo()). 387 */ 388#ifndef MEMP_NUM_NETDB 389#define MEMP_NUM_NETDB 1 390#endif 391 392/** 393 * MEMP_NUM_LOCALHOSTLIST: the number of host entries in the local host list 394 * if DNS_LOCAL_HOSTLIST_IS_DYNAMIC==1. 395 */ 396#ifndef MEMP_NUM_LOCALHOSTLIST 397#define MEMP_NUM_LOCALHOSTLIST 1 398#endif 399 400/** 401 * MEMP_NUM_PPPOE_INTERFACES: the number of concurrently active PPPoE 402 * interfaces (only used with PPPOE_SUPPORT==1) 403 */ 404#ifndef MEMP_NUM_PPPOE_INTERFACES 405#define MEMP_NUM_PPPOE_INTERFACES 1 406#endif 407 408/** 409 * PBUF_POOL_SIZE: the number of buffers in the pbuf pool. 410 */ 411#ifndef PBUF_POOL_SIZE 412#define PBUF_POOL_SIZE 16 413#endif 414 415/* 416 --------------------------------- 417 ---------- ARP options ---------- 418 --------------------------------- 419*/ 420/** 421 * LWIP_ARP==1: Enable ARP functionality. 422 */ 423#ifndef LWIP_ARP 424#define LWIP_ARP 1 425#endif 426 427/** 428 * ARP_TABLE_SIZE: Number of active MAC-IP address pairs cached. 429 */ 430#ifndef ARP_TABLE_SIZE 431#define ARP_TABLE_SIZE 10 432#endif 433 434/** 435 * ARP_QUEUEING==1: Multiple outgoing packets are queued during hardware address 436 * resolution. By default, only the most recent packet is queued per IP address. 437 * This is sufficient for most protocols and mainly reduces TCP connection 438 * startup time. Set this to 1 if you know your application sends more than one 439 * packet in a row to an IP address that is not in the ARP cache. 440 */ 441#ifndef ARP_QUEUEING 442#define ARP_QUEUEING 0 443#endif 444 445/** 446 * ETHARP_TRUST_IP_MAC==1: Incoming IP packets cause the ARP table to be 447 * updated with the source MAC and IP addresses supplied in the packet. 448 * You may want to disable this if you do not trust LAN peers to have the 449 * correct addresses, or as a limited approach to attempt to handle 450 * spoofing. If disabled, lwIP will need to make a new ARP request if 451 * the peer is not already in the ARP table, adding a little latency. 452 * The peer *is* in the ARP table if it requested our address before. 453 * Also notice that this slows down input processing of every IP packet! 454 */ 455#ifndef ETHARP_TRUST_IP_MAC 456#define ETHARP_TRUST_IP_MAC 0 457#endif 458 459/** 460 * ETHARP_SUPPORT_VLAN==1: support receiving ethernet packets with VLAN header. 461 * Additionally, you can define ETHARP_VLAN_CHECK to an u16_t VLAN ID to check. 462 * If ETHARP_VLAN_CHECK is defined, only VLAN-traffic for this VLAN is accepted. 463 * If ETHARP_VLAN_CHECK is not defined, all traffic is accepted. 464 */ 465#ifndef ETHARP_SUPPORT_VLAN 466#define ETHARP_SUPPORT_VLAN 0 467#endif 468 469/** LWIP_ETHERNET==1: enable ethernet support for PPPoE even though ARP 470 * might be disabled 471 */ 472#ifndef LWIP_ETHERNET 473#define LWIP_ETHERNET (LWIP_ARP || PPPOE_SUPPORT) 474#endif 475 476/** ETH_PAD_SIZE: number of bytes added before the ethernet header to ensure 477 * alignment of payload after that header. Since the header is 14 bytes long, 478 * without this padding e.g. addresses in the IP header will not be aligned 479 * on a 32-bit boundary, so setting this to 2 can speed up 32-bit-platforms. 480 */ 481#ifndef ETH_PAD_SIZE 482#define ETH_PAD_SIZE 0 483#endif 484 485/** ETHARP_SUPPORT_STATIC_ENTRIES==1: enable code to support static ARP table 486 * entries (using etharp_add_static_entry/etharp_remove_static_entry). 487 */ 488#ifndef ETHARP_SUPPORT_STATIC_ENTRIES 489#define ETHARP_SUPPORT_STATIC_ENTRIES 0 490#endif 491 492 493/* 494 -------------------------------- 495 ---------- IP options ---------- 496 -------------------------------- 497*/ 498/** 499 * IP_FORWARD==1: Enables the ability to forward IP packets across network 500 * interfaces. If you are going to run lwIP on a device with only one network 501 * interface, define this to 0. 502 */ 503#ifndef IP_FORWARD 504#define IP_FORWARD 0 505#endif 506 507/** 508 * IP_OPTIONS_ALLOWED: Defines the behavior for IP options. 509 * IP_OPTIONS_ALLOWED==0: All packets with IP options are dropped. 510 * IP_OPTIONS_ALLOWED==1: IP options are allowed (but not parsed). 511 */ 512#ifndef IP_OPTIONS_ALLOWED 513#define IP_OPTIONS_ALLOWED 1 514#endif 515 516/** 517 * IP_REASSEMBLY==1: Reassemble incoming fragmented IP packets. Note that 518 * this option does not affect outgoing packet sizes, which can be controlled 519 * via IP_FRAG. 520 */ 521#ifndef IP_REASSEMBLY 522#define IP_REASSEMBLY 1 523#endif 524 525/** 526 * IP_FRAG==1: Fragment outgoing IP packets if their size exceeds MTU. Note 527 * that this option does not affect incoming packet sizes, which can be 528 * controlled via IP_REASSEMBLY. 529 */ 530#ifndef IP_FRAG 531#define IP_FRAG 1 532#endif 533 534/** 535 * IP_REASS_MAXAGE: Maximum time (in multiples of IP_TMR_INTERVAL - so seconds, normally) 536 * a fragmented IP packet waits for all fragments to arrive. If not all fragments arrived 537 * in this time, the whole packet is discarded. 538 */ 539#ifndef IP_REASS_MAXAGE 540#define IP_REASS_MAXAGE 3 541#endif 542 543/** 544 * IP_REASS_MAX_PBUFS: Total maximum amount of pbufs waiting to be reassembled. 545 * Since the received pbufs are enqueued, be sure to configure 546 * PBUF_POOL_SIZE > IP_REASS_MAX_PBUFS so that the stack is still able to receive 547 * packets even if the maximum amount of fragments is enqueued for reassembly! 548 */ 549#ifndef IP_REASS_MAX_PBUFS 550#define IP_REASS_MAX_PBUFS 10 551#endif 552 553/** 554 * IP_FRAG_USES_STATIC_BUF==1: Use a static MTU-sized buffer for IP 555 * fragmentation. Otherwise pbufs are allocated and reference the original 556 * packet data to be fragmented (or with LWIP_NETIF_TX_SINGLE_PBUF==1, 557 * new PBUF_RAM pbufs are used for fragments). 558 * ATTENTION: IP_FRAG_USES_STATIC_BUF==1 may not be used for DMA-enabled MACs! 559 */ 560#ifndef IP_FRAG_USES_STATIC_BUF 561#define IP_FRAG_USES_STATIC_BUF 0 562#endif 563 564/** 565 * IP_FRAG_MAX_MTU: Assumed max MTU on any interface for IP frag buffer 566 * (requires IP_FRAG_USES_STATIC_BUF==1) 567 */ 568#if IP_FRAG_USES_STATIC_BUF && !defined(IP_FRAG_MAX_MTU) 569#define IP_FRAG_MAX_MTU 1500 570#endif 571 572/** 573 * IP_DEFAULT_TTL: Default value for Time-To-Live used by transport layers. 574 */ 575#ifndef IP_DEFAULT_TTL 576#define IP_DEFAULT_TTL 255 577#endif 578 579/** 580 * IP_SOF_BROADCAST=1: Use the SOF_BROADCAST field to enable broadcast 581 * filter per pcb on udp and raw send operations. To enable broadcast filter 582 * on recv operations, you also have to set IP_SOF_BROADCAST_RECV=1. 583 */ 584#ifndef IP_SOF_BROADCAST 585#define IP_SOF_BROADCAST 0 586#endif 587 588/** 589 * IP_SOF_BROADCAST_RECV (requires IP_SOF_BROADCAST=1) enable the broadcast 590 * filter on recv operations. 591 */ 592#ifndef IP_SOF_BROADCAST_RECV 593#define IP_SOF_BROADCAST_RECV 0 594#endif 595 596/* 597 ---------------------------------- 598 ---------- ICMP options ---------- 599 ---------------------------------- 600*/ 601/** 602 * LWIP_ICMP==1: Enable ICMP module inside the IP stack. 603 * Be careful, disable that make your product non-compliant to RFC1122 604 */ 605#ifndef LWIP_ICMP 606#define LWIP_ICMP 1 607#endif 608 609/** 610 * ICMP_TTL: Default value for Time-To-Live used by ICMP packets. 611 */ 612#ifndef ICMP_TTL 613#define ICMP_TTL (IP_DEFAULT_TTL) 614#endif 615 616/** 617 * LWIP_BROADCAST_PING==1: respond to broadcast pings (default is unicast only) 618 */ 619#ifndef LWIP_BROADCAST_PING 620#define LWIP_BROADCAST_PING 0 621#endif 622 623/** 624 * LWIP_MULTICAST_PING==1: respond to multicast pings (default is unicast only) 625 */ 626#ifndef LWIP_MULTICAST_PING 627#define LWIP_MULTICAST_PING 0 628#endif 629 630/* 631 --------------------------------- 632 ---------- RAW options ---------- 633 --------------------------------- 634*/ 635/** 636 * LWIP_RAW==1: Enable application layer to hook into the IP layer itself. 637 */ 638#ifndef LWIP_RAW 639#define LWIP_RAW 1 640#endif 641 642/** 643 * LWIP_RAW==1: Enable application layer to hook into the IP layer itself. 644 */ 645#ifndef RAW_TTL 646#define RAW_TTL (IP_DEFAULT_TTL) 647#endif 648 649/* 650 ---------------------------------- 651 ---------- DHCP options ---------- 652 ---------------------------------- 653*/ 654/** 655 * LWIP_DHCP==1: Enable DHCP module. 656 */ 657#ifndef LWIP_DHCP 658#define LWIP_DHCP 0 659#endif 660 661/** 662 * DHCP_DOES_ARP_CHECK==1: Do an ARP check on the offered address. 663 */ 664#ifndef DHCP_DOES_ARP_CHECK 665#define DHCP_DOES_ARP_CHECK ((LWIP_DHCP) && (LWIP_ARP)) 666#endif 667 668/* 669 ------------------------------------ 670 ---------- AUTOIP options ---------- 671 ------------------------------------ 672*/ 673/** 674 * LWIP_AUTOIP==1: Enable AUTOIP module. 675 */ 676#ifndef LWIP_AUTOIP 677#define LWIP_AUTOIP 0 678#endif 679 680/** 681 * LWIP_DHCP_AUTOIP_COOP==1: Allow DHCP and AUTOIP to be both enabled on 682 * the same interface at the same time. 683 */ 684#ifndef LWIP_DHCP_AUTOIP_COOP 685#define LWIP_DHCP_AUTOIP_COOP 0 686#endif 687 688/** 689 * LWIP_DHCP_AUTOIP_COOP_TRIES: Set to the number of DHCP DISCOVER probes 690 * that should be sent before falling back on AUTOIP. This can be set 691 * as low as 1 to get an AutoIP address very quickly, but you should 692 * be prepared to handle a changing IP address when DHCP overrides 693 * AutoIP. 694 */ 695#ifndef LWIP_DHCP_AUTOIP_COOP_TRIES 696#define LWIP_DHCP_AUTOIP_COOP_TRIES 9 697#endif 698 699/* 700 ---------------------------------- 701 ---------- SNMP options ---------- 702 ---------------------------------- 703*/ 704/** 705 * LWIP_SNMP==1: Turn on SNMP module. UDP must be available for SNMP 706 * transport. 707 */ 708#ifndef LWIP_SNMP 709#define LWIP_SNMP 0 710#endif 711 712/** 713 * SNMP_CONCURRENT_REQUESTS: Number of concurrent requests the module will 714 * allow. At least one request buffer is required. 715 * Does not have to be changed unless external MIBs answer request asynchronously 716 */ 717#ifndef SNMP_CONCURRENT_REQUESTS 718#define SNMP_CONCURRENT_REQUESTS 1 719#endif 720 721/** 722 * SNMP_TRAP_DESTINATIONS: Number of trap destinations. At least one trap 723 * destination is required 724 */ 725#ifndef SNMP_TRAP_DESTINATIONS 726#define SNMP_TRAP_DESTINATIONS 1 727#endif 728 729/** 730 * SNMP_PRIVATE_MIB: 731 * When using a private MIB, you have to create a file 'private_mib.h' that contains 732 * a 'struct mib_array_node mib_private' which contains your MIB. 733 */ 734#ifndef SNMP_PRIVATE_MIB 735#define SNMP_PRIVATE_MIB 0 736#endif 737 738/** 739 * Only allow SNMP write actions that are 'safe' (e.g. disabeling netifs is not 740 * a safe action and disabled when SNMP_SAFE_REQUESTS = 1). 741 * Unsafe requests are disabled by default! 742 */ 743#ifndef SNMP_SAFE_REQUESTS 744#define SNMP_SAFE_REQUESTS 1 745#endif 746 747/** 748 * The maximum length of strings used. This affects the size of 749 * MEMP_SNMP_VALUE elements. 750 */ 751#ifndef SNMP_MAX_OCTET_STRING_LEN 752#define SNMP_MAX_OCTET_STRING_LEN 127 753#endif 754 755/** 756 * The maximum depth of the SNMP tree. 757 * With private MIBs enabled, this depends on your MIB! 758 * This affects the size of MEMP_SNMP_VALUE elements. 759 */ 760#ifndef SNMP_MAX_TREE_DEPTH 761#define SNMP_MAX_TREE_DEPTH 15 762#endif 763 764/** 765 * The size of the MEMP_SNMP_VALUE elements, normally calculated from 766 * SNMP_MAX_OCTET_STRING_LEN and SNMP_MAX_TREE_DEPTH. 767 */ 768#ifndef SNMP_MAX_VALUE_SIZE 769#define SNMP_MAX_VALUE_SIZE LWIP_MAX((SNMP_MAX_OCTET_STRING_LEN)+1, sizeof(s32_t)*(SNMP_MAX_TREE_DEPTH)) 770#endif 771 772/* 773 ---------------------------------- 774 ---------- IGMP options ---------- 775 ---------------------------------- 776*/ 777/** 778 * LWIP_IGMP==1: Turn on IGMP module. 779 */ 780#ifndef LWIP_IGMP 781#define LWIP_IGMP 0 782#endif 783 784/* 785 ---------------------------------- 786 ---------- DNS options ----------- 787 ---------------------------------- 788*/ 789/** 790 * LWIP_DNS==1: Turn on DNS module. UDP must be available for DNS 791 * transport. 792 */ 793#ifndef LWIP_DNS 794#define LWIP_DNS 0 795#endif 796 797/** DNS maximum number of entries to maintain locally. */ 798#ifndef DNS_TABLE_SIZE 799#define DNS_TABLE_SIZE 4 800#endif 801 802/** DNS maximum host name length supported in the name table. */ 803#ifndef DNS_MAX_NAME_LENGTH 804#define DNS_MAX_NAME_LENGTH 256 805#endif 806 807/** The maximum of DNS servers */ 808#ifndef DNS_MAX_SERVERS 809#define DNS_MAX_SERVERS 2 810#endif 811 812/** DNS do a name checking between the query and the response. */ 813#ifndef DNS_DOES_NAME_CHECK 814#define DNS_DOES_NAME_CHECK 1 815#endif 816 817/** DNS message max. size. Default value is RFC compliant. */ 818#ifndef DNS_MSG_SIZE 819#define DNS_MSG_SIZE 512 820#endif 821 822/** DNS_LOCAL_HOSTLIST: Implements a local host-to-address list. If enabled, 823 * you have to define 824 * #define DNS_LOCAL_HOSTLIST_INIT {{"host1", 0x123}, {"host2", 0x234}} 825 * (an array of structs name/address, where address is an u32_t in network 826 * byte order). 827 * 828 * Instead, you can also use an external function: 829 * #define DNS_LOOKUP_LOCAL_EXTERN(x) extern u32_t my_lookup_function(const char *name) 830 * that returns the IP address or INADDR_NONE if not found. 831 */ 832#ifndef DNS_LOCAL_HOSTLIST 833#define DNS_LOCAL_HOSTLIST 0 834#endif /* DNS_LOCAL_HOSTLIST */ 835 836/** If this is turned on, the local host-list can be dynamically changed 837 * at runtime. */ 838#ifndef DNS_LOCAL_HOSTLIST_IS_DYNAMIC 839#define DNS_LOCAL_HOSTLIST_IS_DYNAMIC 0 840#endif /* DNS_LOCAL_HOSTLIST_IS_DYNAMIC */ 841 842/* 843 --------------------------------- 844 ---------- UDP options ---------- 845 --------------------------------- 846*/ 847/** 848 * LWIP_UDP==1: Turn on UDP. 849 */ 850#ifndef LWIP_UDP 851#define LWIP_UDP 1 852#endif 853 854/** 855 * LWIP_UDPLITE==1: Turn on UDP-Lite. (Requires LWIP_UDP) 856 */ 857#ifndef LWIP_UDPLITE 858#define LWIP_UDPLITE 0 859#endif 860 861/** 862 * UDP_TTL: Default Time-To-Live value. 863 */ 864#ifndef UDP_TTL 865#define UDP_TTL (IP_DEFAULT_TTL) 866#endif 867 868/** 869 * LWIP_NETBUF_RECVINFO==1: append destination addr and port to every netbuf. 870 */ 871#ifndef LWIP_NETBUF_RECVINFO 872#define LWIP_NETBUF_RECVINFO 0 873#endif 874 875/* 876 --------------------------------- 877 ---------- TCP options ---------- 878 --------------------------------- 879*/ 880/** 881 * LWIP_TCP==1: Turn on TCP. 882 */ 883#ifndef LWIP_TCP 884#define LWIP_TCP 1 885#endif 886 887/** 888 * TCP_TTL: Default Time-To-Live value. 889 */ 890#ifndef TCP_TTL 891#define TCP_TTL (IP_DEFAULT_TTL) 892#endif 893 894/** 895 * TCP_WND: The size of a TCP window. This must be at least 896 * (2 * TCP_MSS) for things to work well 897 */ 898#ifndef TCP_WND 899#define TCP_WND (4 * TCP_MSS) 900#endif 901 902/** 903 * TCP_MAXRTX: Maximum number of retransmissions of data segments. 904 */ 905#ifndef TCP_MAXRTX 906#define TCP_MAXRTX 12 907#endif 908 909/** 910 * TCP_SYNMAXRTX: Maximum number of retransmissions of SYN segments. 911 */ 912#ifndef TCP_SYNMAXRTX 913#define TCP_SYNMAXRTX 6 914#endif 915 916/** 917 * TCP_QUEUE_OOSEQ==1: TCP will queue segments that arrive out of order. 918 * Define to 0 if your device is low on memory. 919 */ 920#ifndef TCP_QUEUE_OOSEQ 921#define TCP_QUEUE_OOSEQ (LWIP_TCP) 922#endif 923 924/** 925 * TCP_MSS: TCP Maximum segment size. (default is 536, a conservative default, 926 * you might want to increase this.) 927 * For the receive side, this MSS is advertised to the remote side 928 * when opening a connection. For the transmit size, this MSS sets 929 * an upper limit on the MSS advertised by the remote host. 930 */ 931#ifndef TCP_MSS 932#define TCP_MSS 536 933#endif 934 935/** 936 * TCP_CALCULATE_EFF_SEND_MSS: "The maximum size of a segment that TCP really 937 * sends, the 'effective send MSS,' MUST be the smaller of the send MSS (which 938 * reflects the available reassembly buffer size at the remote host) and the 939 * largest size permitted by the IP layer" (RFC 1122) 940 * Setting this to 1 enables code that checks TCP_MSS against the MTU of the 941 * netif used for a connection and limits the MSS if it would be too big otherwise. 942 */ 943#ifndef TCP_CALCULATE_EFF_SEND_MSS 944#define TCP_CALCULATE_EFF_SEND_MSS 1 945#endif 946 947 948/** 949 * TCP_SND_BUF: TCP sender buffer space (bytes). 950 */ 951#ifndef TCP_SND_BUF 952#define TCP_SND_BUF 256 953#endif 954 955/** 956 * TCP_SND_QUEUELEN: TCP sender buffer space (pbufs). This must be at least 957 * as much as (2 * TCP_SND_BUF/TCP_MSS) for things to work. 958 */ 959#ifndef TCP_SND_QUEUELEN 960#define TCP_SND_QUEUELEN ((4 * (TCP_SND_BUF) + (TCP_MSS - 1))/(TCP_MSS)) 961#endif 962 963/** 964 * TCP_SNDLOWAT: TCP writable space (bytes). This must be less than 965 * TCP_SND_BUF. It is the amount of space which must be available in the 966 * TCP snd_buf for select to return writable (combined with TCP_SNDQUEUELOWAT). 967 */ 968#ifndef TCP_SNDLOWAT 969#define TCP_SNDLOWAT ((TCP_SND_BUF)/2) 970#endif 971 972/** 973 * TCP_SNDQUEUELOWAT: TCP writable bufs (pbuf count). This must be grater 974 * than TCP_SND_QUEUELEN. If the number of pbufs queued on a pcb drops below 975 * this number, select returns writable (combined with TCP_SNDLOWAT). 976 */ 977#ifndef TCP_SNDQUEUELOWAT 978#define TCP_SNDQUEUELOWAT ((TCP_SND_QUEUELEN)/2) 979#endif 980 981/** 982 * TCP_LISTEN_BACKLOG: Enable the backlog option for tcp listen pcb. 983 */ 984#ifndef TCP_LISTEN_BACKLOG 985#define TCP_LISTEN_BACKLOG 0 986#endif 987 988/** 989 * The maximum allowed backlog for TCP listen netconns. 990 * This backlog is used unless another is explicitly specified. 991 * 0xff is the maximum (u8_t). 992 */ 993#ifndef TCP_DEFAULT_LISTEN_BACKLOG 994#define TCP_DEFAULT_LISTEN_BACKLOG 0xff 995#endif 996 997/** 998 * TCP_OVERSIZE: The maximum number of bytes that tcp_write may 999 * allocate ahead of time in an attempt to create shorter pbuf chains 1000 * for transmission. The meaningful range is 0 to TCP_MSS. Some 1001 * suggested values are: 1002 * 1003 * 0: Disable oversized allocation. Each tcp_write() allocates a new 1004 pbuf (old behaviour). 1005 * 1: Allocate size-aligned pbufs with minimal excess. Use this if your 1006 * scatter-gather DMA requires aligned fragments. 1007 * 128: Limit the pbuf/memory overhead to 20%. 1008 * TCP_MSS: Try to create unfragmented TCP packets. 1009 * TCP_MSS/4: Try to create 4 fragments or less per TCP packet. 1010 */ 1011#ifndef TCP_OVERSIZE 1012#define TCP_OVERSIZE TCP_MSS 1013#endif 1014 1015/** 1016 * LWIP_TCP_TIMESTAMPS==1: support the TCP timestamp option. 1017 */ 1018#ifndef LWIP_TCP_TIMESTAMPS 1019#define LWIP_TCP_TIMESTAMPS 0 1020#endif 1021 1022/** 1023 * TCP_WND_UPDATE_THRESHOLD: difference in window to trigger an 1024 * explicit window update 1025 */ 1026#ifndef TCP_WND_UPDATE_THRESHOLD 1027#define TCP_WND_UPDATE_THRESHOLD (TCP_WND / 4) 1028#endif 1029 1030/** 1031 * LWIP_EVENT_API and LWIP_CALLBACK_API: Only one of these should be set to 1. 1032 * LWIP_EVENT_API==1: The user defines lwip_tcp_event() to receive all 1033 * events (accept, sent, etc) that happen in the system. 1034 * LWIP_CALLBACK_API==1: The PCB callback function is called directly 1035 * for the event. 1036 */ 1037#ifndef LWIP_EVENT_API 1038#define LWIP_EVENT_API 0 1039#define LWIP_CALLBACK_API 1 1040#else 1041#define LWIP_EVENT_API 1 1042#define LWIP_CALLBACK_API 0 1043#endif 1044 1045 1046/* 1047 ---------------------------------- 1048 ---------- Pbuf options ---------- 1049 ---------------------------------- 1050*/ 1051/** 1052 * PBUF_LINK_HLEN: the number of bytes that should be allocated for a 1053 * link level header. The default is 14, the standard value for 1054 * Ethernet. 1055 */ 1056#ifndef PBUF_LINK_HLEN 1057#define PBUF_LINK_HLEN (14 + ETH_PAD_SIZE) 1058#endif 1059 1060/** 1061 * PBUF_POOL_BUFSIZE: the size of each pbuf in the pbuf pool. The default is 1062 * designed to accomodate single full size TCP frame in one pbuf, including 1063 * TCP_MSS, IP header, and link header. 1064 */ 1065#ifndef PBUF_POOL_BUFSIZE 1066#define PBUF_POOL_BUFSIZE LWIP_MEM_ALIGN_SIZE(TCP_MSS+40+PBUF_LINK_HLEN) 1067#endif 1068 1069/* 1070 ------------------------------------------------ 1071 ---------- Network Interfaces options ---------- 1072 ------------------------------------------------ 1073*/ 1074/** 1075 * LWIP_NETIF_HOSTNAME==1: use DHCP_OPTION_HOSTNAME with netif's hostname 1076 * field. 1077 */ 1078#ifndef LWIP_NETIF_HOSTNAME 1079#define LWIP_NETIF_HOSTNAME 0 1080#endif 1081 1082/** 1083 * LWIP_NETIF_API==1: Support netif api (in netifapi.c) 1084 */ 1085#ifndef LWIP_NETIF_API 1086#define LWIP_NETIF_API 0 1087#endif 1088 1089/** 1090 * LWIP_NETIF_STATUS_CALLBACK==1: Support a callback function whenever an interface 1091 * changes its up/down status (i.e., due to DHCP IP acquistion) 1092 */ 1093#ifndef LWIP_NETIF_STATUS_CALLBACK 1094#define LWIP_NETIF_STATUS_CALLBACK 0 1095#endif 1096 1097/** 1098 * LWIP_NETIF_LINK_CALLBACK==1: Support a callback function from an interface 1099 * whenever the link changes (i.e., link down) 1100 */ 1101#ifndef LWIP_NETIF_LINK_CALLBACK 1102#define LWIP_NETIF_LINK_CALLBACK 0 1103#endif 1104 1105/** 1106 * LWIP_NETIF_HWADDRHINT==1: Cache link-layer-address hints (e.g. table 1107 * indices) in struct netif. TCP and UDP can make use of this to prevent 1108 * scanning the ARP table for every sent packet. While this is faster for big 1109 * ARP tables or many concurrent connections, it might be counterproductive 1110 * if you have a tiny ARP table or if there never are concurrent connections. 1111 */ 1112#ifndef LWIP_NETIF_HWADDRHINT 1113#define LWIP_NETIF_HWADDRHINT 0 1114#endif 1115 1116/** 1117 * LWIP_NETIF_LOOPBACK==1: Support sending packets with a destination IP 1118 * address equal to the netif IP address, looping them back up the stack. 1119 */ 1120#ifndef LWIP_NETIF_LOOPBACK 1121#define LWIP_NETIF_LOOPBACK 0 1122#endif 1123 1124/** 1125 * LWIP_LOOPBACK_MAX_PBUFS: Maximum number of pbufs on queue for loopback 1126 * sending for each netif (0 = disabled) 1127 */ 1128#ifndef LWIP_LOOPBACK_MAX_PBUFS 1129#define LWIP_LOOPBACK_MAX_PBUFS 0 1130#endif 1131 1132/** 1133 * LWIP_NETIF_LOOPBACK_MULTITHREADING: Indicates whether threading is enabled in 1134 * the system, as netifs must change how they behave depending on this setting 1135 * for the LWIP_NETIF_LOOPBACK option to work. 1136 * Setting this is needed to avoid reentering non-reentrant functions like 1137 * tcp_input(). 1138 * LWIP_NETIF_LOOPBACK_MULTITHREADING==1: Indicates that the user is using a 1139 * multithreaded environment like tcpip.c. In this case, netif->input() 1140 * is called directly. 1141 * LWIP_NETIF_LOOPBACK_MULTITHREADING==0: Indicates a polling (or NO_SYS) setup. 1142 * The packets are put on a list and netif_poll() must be called in 1143 * the main application loop. 1144 */ 1145#ifndef LWIP_NETIF_LOOPBACK_MULTITHREADING 1146#define LWIP_NETIF_LOOPBACK_MULTITHREADING (!NO_SYS) 1147#endif 1148 1149/** 1150 * LWIP_NETIF_TX_SINGLE_PBUF: if this is set to 1, lwIP tries to put all data 1151 * to be sent into one single pbuf. This is for compatibility with DMA-enabled 1152 * MACs that do not support scatter-gather. 1153 * Beware that this might involve CPU-memcpy before transmitting that would not 1154 * be needed without this flag! Use this only if you need to! 1155 * 1156 * @todo: TCP and IP-frag do not work with this, yet: 1157 */ 1158#ifndef LWIP_NETIF_TX_SINGLE_PBUF 1159#define LWIP_NETIF_TX_SINGLE_PBUF 0 1160#endif /* LWIP_NETIF_TX_SINGLE_PBUF */ 1161 1162/* 1163 ------------------------------------ 1164 ---------- LOOPIF options ---------- 1165 ------------------------------------ 1166*/ 1167/** 1168 * LWIP_HAVE_LOOPIF==1: Support loop interface (127.0.0.1) and loopif.c 1169 */ 1170#ifndef LWIP_HAVE_LOOPIF 1171#define LWIP_HAVE_LOOPIF 0 1172#endif 1173 1174/* 1175 ------------------------------------ 1176 ---------- SLIPIF options ---------- 1177 ------------------------------------ 1178*/ 1179/** 1180 * LWIP_HAVE_SLIPIF==1: Support slip interface and slipif.c 1181 */ 1182#ifndef LWIP_HAVE_SLIPIF 1183#define LWIP_HAVE_SLIPIF 0 1184#endif 1185 1186/* 1187 ------------------------------------ 1188 ---------- Thread options ---------- 1189 ------------------------------------ 1190*/ 1191/** 1192 * TCPIP_THREAD_NAME: The name assigned to the main tcpip thread. 1193 */ 1194#ifndef TCPIP_THREAD_NAME 1195#define TCPIP_THREAD_NAME "tcpip_thread" 1196#endif 1197 1198/** 1199 * TCPIP_THREAD_STACKSIZE: The stack size used by the main tcpip thread. 1200 * The stack size value itself is platform-dependent, but is passed to 1201 * sys_thread_new() when the thread is created. 1202 */ 1203#ifndef TCPIP_THREAD_STACKSIZE 1204#define TCPIP_THREAD_STACKSIZE 0 1205#endif 1206 1207/** 1208 * TCPIP_THREAD_PRIO: The priority assigned to the main tcpip thread. 1209 * The priority value itself is platform-dependent, but is passed to 1210 * sys_thread_new() when the thread is created. 1211 */ 1212#ifndef TCPIP_THREAD_PRIO 1213#define TCPIP_THREAD_PRIO 1 1214#endif 1215 1216/** 1217 * TCPIP_MBOX_SIZE: The mailbox size for the tcpip thread messages 1218 * The queue size value itself is platform-dependent, but is passed to 1219 * sys_mbox_new() when tcpip_init is called. 1220 */ 1221#ifndef TCPIP_MBOX_SIZE 1222#define TCPIP_MBOX_SIZE 0 1223#endif 1224 1225/** 1226 * SLIPIF_THREAD_NAME: The name assigned to the slipif_loop thread. 1227 */ 1228#ifndef SLIPIF_THREAD_NAME 1229#define SLIPIF_THREAD_NAME "slipif_loop" 1230#endif 1231 1232/** 1233 * SLIP_THREAD_STACKSIZE: The stack size used by the slipif_loop thread. 1234 * The stack size value itself is platform-dependent, but is passed to 1235 * sys_thread_new() when the thread is created. 1236 */ 1237#ifndef SLIPIF_THREAD_STACKSIZE 1238#define SLIPIF_THREAD_STACKSIZE 0 1239#endif 1240 1241/** 1242 * SLIPIF_THREAD_PRIO: The priority assigned to the slipif_loop thread. 1243 * The priority value itself is platform-dependent, but is passed to 1244 * sys_thread_new() when the thread is created. 1245 */ 1246#ifndef SLIPIF_THREAD_PRIO 1247#define SLIPIF_THREAD_PRIO 1 1248#endif 1249 1250/** 1251 * PPP_THREAD_NAME: The name assigned to the pppInputThread. 1252 */ 1253#ifndef PPP_THREAD_NAME 1254#define PPP_THREAD_NAME "pppInputThread" 1255#endif 1256 1257/** 1258 * PPP_THREAD_STACKSIZE: The stack size used by the pppInputThread. 1259 * The stack size value itself is platform-dependent, but is passed to 1260 * sys_thread_new() when the thread is created. 1261 */ 1262#ifndef PPP_THREAD_STACKSIZE 1263#define PPP_THREAD_STACKSIZE 0 1264#endif 1265 1266/** 1267 * PPP_THREAD_PRIO: The priority assigned to the pppInputThread. 1268 * The priority value itself is platform-dependent, but is passed to 1269 * sys_thread_new() when the thread is created. 1270 */ 1271#ifndef PPP_THREAD_PRIO 1272#define PPP_THREAD_PRIO 1 1273#endif 1274 1275/** 1276 * DEFAULT_THREAD_NAME: The name assigned to any other lwIP thread. 1277 */ 1278#ifndef DEFAULT_THREAD_NAME 1279#define DEFAULT_THREAD_NAME "lwIP" 1280#endif 1281 1282/** 1283 * DEFAULT_THREAD_STACKSIZE: The stack size used by any other lwIP thread. 1284 * The stack size value itself is platform-dependent, but is passed to 1285 * sys_thread_new() when the thread is created. 1286 */ 1287#ifndef DEFAULT_THREAD_STACKSIZE 1288#define DEFAULT_THREAD_STACKSIZE 0 1289#endif 1290 1291/** 1292 * DEFAULT_THREAD_PRIO: The priority assigned to any other lwIP thread. 1293 * The priority value itself is platform-dependent, but is passed to 1294 * sys_thread_new() when the thread is created. 1295 */ 1296#ifndef DEFAULT_THREAD_PRIO 1297#define DEFAULT_THREAD_PRIO 1 1298#endif 1299 1300/** 1301 * DEFAULT_RAW_RECVMBOX_SIZE: The mailbox size for the incoming packets on a 1302 * NETCONN_RAW. The queue size value itself is platform-dependent, but is passed 1303 * to sys_mbox_new() when the recvmbox is created. 1304 */ 1305#ifndef DEFAULT_RAW_RECVMBOX_SIZE 1306#define DEFAULT_RAW_RECVMBOX_SIZE 0 1307#endif 1308 1309/** 1310 * DEFAULT_UDP_RECVMBOX_SIZE: The mailbox size for the incoming packets on a 1311 * NETCONN_UDP. The queue size value itself is platform-dependent, but is passed 1312 * to sys_mbox_new() when the recvmbox is created. 1313 */ 1314#ifndef DEFAULT_UDP_RECVMBOX_SIZE 1315#define DEFAULT_UDP_RECVMBOX_SIZE 0 1316#endif 1317 1318/** 1319 * DEFAULT_TCP_RECVMBOX_SIZE: The mailbox size for the incoming packets on a 1320 * NETCONN_TCP. The queue size value itself is platform-dependent, but is passed 1321 * to sys_mbox_new() when the recvmbox is created. 1322 */ 1323#ifndef DEFAULT_TCP_RECVMBOX_SIZE 1324#define DEFAULT_TCP_RECVMBOX_SIZE 0 1325#endif 1326 1327/** 1328 * DEFAULT_ACCEPTMBOX_SIZE: The mailbox size for the incoming connections. 1329 * The queue size value itself is platform-dependent, but is passed to 1330 * sys_mbox_new() when the acceptmbox is created. 1331 */ 1332#ifndef DEFAULT_ACCEPTMBOX_SIZE 1333#define DEFAULT_ACCEPTMBOX_SIZE 0 1334#endif 1335 1336/* 1337 ---------------------------------------------- 1338 ---------- Sequential layer options ---------- 1339 ---------------------------------------------- 1340*/ 1341/** 1342 * LWIP_TCPIP_CORE_LOCKING: (EXPERIMENTAL!) 1343 * Don't use it if you're not an active lwIP project member 1344 */ 1345#ifndef LWIP_TCPIP_CORE_LOCKING 1346#define LWIP_TCPIP_CORE_LOCKING 0 1347#endif 1348 1349/** 1350 * LWIP_TCPIP_CORE_LOCKING_INPUT: (EXPERIMENTAL!) 1351 * Don't use it if you're not an active lwIP project member 1352 */ 1353#ifndef LWIP_TCPIP_CORE_LOCKING_INPUT 1354#define LWIP_TCPIP_CORE_LOCKING_INPUT 0 1355#endif 1356 1357/** 1358 * LWIP_NETCONN==1: Enable Netconn API (require to use api_lib.c) 1359 */ 1360#ifndef LWIP_NETCONN 1361#define LWIP_NETCONN 1 1362#endif 1363 1364/** LWIP_TCPIP_TIMEOUT==1: Enable tcpip_timeout/tcpip_untimeout tod create 1365 * timers running in tcpip_thread from another thread. 1366 */ 1367#ifndef LWIP_TCPIP_TIMEOUT 1368#define LWIP_TCPIP_TIMEOUT 1 1369#endif 1370 1371/* 1372 ------------------------------------ 1373 ---------- Socket options ---------- 1374 ------------------------------------ 1375*/ 1376/** 1377 * LWIP_SOCKET==1: Enable Socket API (require to use sockets.c) 1378 */ 1379#ifndef LWIP_SOCKET 1380#define LWIP_SOCKET 1 1381#endif 1382 1383/** 1384 * LWIP_COMPAT_SOCKETS==1: Enable BSD-style sockets functions names. 1385 * (only used if you use sockets.c) 1386 */ 1387#ifndef LWIP_COMPAT_SOCKETS 1388#define LWIP_COMPAT_SOCKETS 1 1389#endif 1390 1391/** 1392 * LWIP_POSIX_SOCKETS_IO_NAMES==1: Enable POSIX-style sockets functions names. 1393 * Disable this option if you use a POSIX operating system that uses the same 1394 * names (read, write & close). (only used if you use sockets.c) 1395 */ 1396#ifndef LWIP_POSIX_SOCKETS_IO_NAMES 1397#define LWIP_POSIX_SOCKETS_IO_NAMES 1 1398#endif 1399 1400/** 1401 * LWIP_TCP_KEEPALIVE==1: Enable TCP_KEEPIDLE, TCP_KEEPINTVL and TCP_KEEPCNT 1402 * options processing. Note that TCP_KEEPIDLE and TCP_KEEPINTVL have to be set 1403 * in seconds. (does not require sockets.c, and will affect tcp.c) 1404 */ 1405#ifndef LWIP_TCP_KEEPALIVE 1406#define LWIP_TCP_KEEPALIVE 0 1407#endif 1408 1409/** 1410 * LWIP_SO_RCVTIMEO==1: Enable SO_RCVTIMEO processing. 1411 */ 1412#ifndef LWIP_SO_RCVTIMEO 1413#define LWIP_SO_RCVTIMEO 0 1414#endif 1415 1416/** 1417 * LWIP_SO_RCVBUF==1: Enable SO_RCVBUF processing. 1418 */ 1419#ifndef LWIP_SO_RCVBUF 1420#define LWIP_SO_RCVBUF 0 1421#endif 1422 1423/** 1424 * If LWIP_SO_RCVBUF is used, this is the default value for recv_bufsize. 1425 */ 1426#ifndef RECV_BUFSIZE_DEFAULT 1427#define RECV_BUFSIZE_DEFAULT INT_MAX 1428#endif 1429 1430/** 1431 * SO_REUSE==1: Enable SO_REUSEADDR option. 1432 */ 1433#ifndef SO_REUSE 1434#define SO_REUSE 0 1435#endif 1436 1437/** 1438 * SO_REUSE_RXTOALL==1: Pass a copy of incoming broadcast/multicast packets 1439 * to all local matches if SO_REUSEADDR is turned on. 1440 * WARNING: Adds a memcpy for every packet if passing to more than one pcb! 1441 */ 1442#ifndef SO_REUSE_RXTOALL 1443#define SO_REUSE_RXTOALL 0 1444#endif 1445 1446/* 1447 ---------------------------------------- 1448 ---------- Statistics options ---------- 1449 ---------------------------------------- 1450*/ 1451/** 1452 * LWIP_STATS==1: Enable statistics collection in lwip_stats. 1453 */ 1454#ifndef LWIP_STATS 1455#define LWIP_STATS 1 1456#endif 1457 1458#if LWIP_STATS 1459 1460/** 1461 * LWIP_STATS_DISPLAY==1: Compile in the statistics output functions. 1462 */ 1463#ifndef LWIP_STATS_DISPLAY 1464#define LWIP_STATS_DISPLAY 0 1465#endif 1466 1467/** 1468 * LINK_STATS==1: Enable link stats. 1469 */ 1470#ifndef LINK_STATS 1471#define LINK_STATS 1 1472#endif 1473 1474/** 1475 * ETHARP_STATS==1: Enable etharp stats. 1476 */ 1477#ifndef ETHARP_STATS 1478#define ETHARP_STATS (LWIP_ARP) 1479#endif 1480 1481/** 1482 * IP_STATS==1: Enable IP stats. 1483 */ 1484#ifndef IP_STATS 1485#define IP_STATS 1 1486#endif 1487 1488/** 1489 * IPFRAG_STATS==1: Enable IP fragmentation stats. Default is 1490 * on if using either frag or reass. 1491 */ 1492#ifndef IPFRAG_STATS 1493#define IPFRAG_STATS (IP_REASSEMBLY || IP_FRAG) 1494#endif 1495 1496/** 1497 * ICMP_STATS==1: Enable ICMP stats. 1498 */ 1499#ifndef ICMP_STATS 1500#define ICMP_STATS 1 1501#endif 1502 1503/** 1504 * IGMP_STATS==1: Enable IGMP stats. 1505 */ 1506#ifndef IGMP_STATS 1507#define IGMP_STATS (LWIP_IGMP) 1508#endif 1509 1510/** 1511 * UDP_STATS==1: Enable UDP stats. Default is on if 1512 * UDP enabled, otherwise off. 1513 */ 1514#ifndef UDP_STATS 1515#define UDP_STATS (LWIP_UDP) 1516#endif 1517 1518/** 1519 * TCP_STATS==1: Enable TCP stats. Default is on if TCP 1520 * enabled, otherwise off. 1521 */ 1522#ifndef TCP_STATS 1523#define TCP_STATS (LWIP_TCP) 1524#endif 1525 1526/** 1527 * MEM_STATS==1: Enable mem.c stats. 1528 */ 1529#ifndef MEM_STATS 1530#define MEM_STATS ((MEM_LIBC_MALLOC == 0) && (MEM_USE_POOLS == 0)) 1531#endif 1532 1533/** 1534 * MEMP_STATS==1: Enable memp.c pool stats. 1535 */ 1536#ifndef MEMP_STATS 1537#define MEMP_STATS (MEMP_MEM_MALLOC == 0) 1538#endif 1539 1540/** 1541 * SYS_STATS==1: Enable system stats (sem and mbox counts, etc). 1542 */ 1543#ifndef SYS_STATS 1544#define SYS_STATS (NO_SYS == 0) 1545#endif 1546 1547#else 1548 1549#define LINK_STATS 0 1550#define IP_STATS 0 1551#define IPFRAG_STATS 0 1552#define ICMP_STATS 0 1553#define IGMP_STATS 0 1554#define UDP_STATS 0 1555#define TCP_STATS 0 1556#define MEM_STATS 0 1557#define MEMP_STATS 0 1558#define SYS_STATS 0 1559#define LWIP_STATS_DISPLAY 0 1560 1561#endif /* LWIP_STATS */ 1562 1563/* 1564 --------------------------------- 1565 ---------- PPP options ---------- 1566 --------------------------------- 1567*/ 1568/** 1569 * PPP_SUPPORT==1: Enable PPP. 1570 */ 1571#ifndef PPP_SUPPORT 1572#define PPP_SUPPORT 0 1573#endif 1574 1575/** 1576 * PPPOE_SUPPORT==1: Enable PPP Over Ethernet 1577 */ 1578#ifndef PPPOE_SUPPORT 1579#define PPPOE_SUPPORT 0 1580#endif 1581 1582/** 1583 * PPPOS_SUPPORT==1: Enable PPP Over Serial 1584 */ 1585#ifndef PPPOS_SUPPORT 1586#define PPPOS_SUPPORT PPP_SUPPORT 1587#endif 1588 1589#if PPP_SUPPORT 1590 1591/** 1592 * NUM_PPP: Max PPP sessions. 1593 */ 1594#ifndef NUM_PPP 1595#define NUM_PPP 1 1596#endif 1597 1598/** 1599 * PAP_SUPPORT==1: Support PAP. 1600 */ 1601#ifndef PAP_SUPPORT 1602#define PAP_SUPPORT 0 1603#endif 1604 1605/** 1606 * CHAP_SUPPORT==1: Support CHAP. 1607 */ 1608#ifndef CHAP_SUPPORT 1609#define CHAP_SUPPORT 0 1610#endif 1611 1612/** 1613 * MSCHAP_SUPPORT==1: Support MSCHAP. CURRENTLY NOT SUPPORTED! DO NOT SET! 1614 */ 1615#ifndef MSCHAP_SUPPORT 1616#define MSCHAP_SUPPORT 0 1617#endif 1618 1619/** 1620 * CBCP_SUPPORT==1: Support CBCP. CURRENTLY NOT SUPPORTED! DO NOT SET! 1621 */ 1622#ifndef CBCP_SUPPORT 1623#define CBCP_SUPPORT 0 1624#endif 1625 1626/** 1627 * CCP_SUPPORT==1: Support CCP. CURRENTLY NOT SUPPORTED! DO NOT SET! 1628 */ 1629#ifndef CCP_SUPPORT 1630#define CCP_SUPPORT 0 1631#endif 1632 1633/** 1634 * VJ_SUPPORT==1: Support VJ header compression. 1635 */ 1636#ifndef VJ_SUPPORT 1637#define VJ_SUPPORT 0 1638#endif 1639 1640/** 1641 * MD5_SUPPORT==1: Support MD5 (see also CHAP). 1642 */ 1643#ifndef MD5_SUPPORT 1644#define MD5_SUPPORT 0 1645#endif 1646 1647/* 1648 * Timeouts 1649 */ 1650#ifndef FSM_DEFTIMEOUT 1651#define FSM_DEFTIMEOUT 6 /* Timeout time in seconds */ 1652#endif 1653 1654#ifndef FSM_DEFMAXTERMREQS 1655#define FSM_DEFMAXTERMREQS 2 /* Maximum Terminate-Request transmissions */ 1656#endif 1657 1658#ifndef FSM_DEFMAXCONFREQS 1659#define FSM_DEFMAXCONFREQS 10 /* Maximum Configure-Request transmissions */ 1660#endif 1661 1662#ifndef FSM_DEFMAXNAKLOOPS 1663#define FSM_DEFMAXNAKLOOPS 5 /* Maximum number of nak loops */ 1664#endif 1665 1666#ifndef UPAP_DEFTIMEOUT 1667#define UPAP_DEFTIMEOUT 6 /* Timeout (seconds) for retransmitting req */ 1668#endif 1669 1670#ifndef UPAP_DEFREQTIME 1671#define UPAP_DEFREQTIME 30 /* Time to wait for auth-req from peer */ 1672#endif 1673 1674#ifndef CHAP_DEFTIMEOUT 1675#define CHAP_DEFTIMEOUT 6 /* Timeout time in seconds */ 1676#endif 1677 1678#ifndef CHAP_DEFTRANSMITS 1679#define CHAP_DEFTRANSMITS 10 /* max # times to send challenge */ 1680#endif 1681 1682/* Interval in seconds between keepalive echo requests, 0 to disable. */ 1683#ifndef LCP_ECHOINTERVAL 1684#define LCP_ECHOINTERVAL 0 1685#endif 1686 1687/* Number of unanswered echo requests before failure. */ 1688#ifndef LCP_MAXECHOFAILS 1689#define LCP_MAXECHOFAILS 3 1690#endif 1691 1692/* Max Xmit idle time (in jiffies) before resend flag char. */ 1693#ifndef PPP_MAXIDLEFLAG 1694#define PPP_MAXIDLEFLAG 100 1695#endif 1696 1697/* 1698 * Packet sizes 1699 * 1700 * Note - lcp shouldn't be allowed to negotiate stuff outside these 1701 * limits. See lcp.h in the pppd directory. 1702 * (XXX - these constants should simply be shared by lcp.c instead 1703 * of living in lcp.h) 1704 */ 1705#define PPP_MTU 1500 /* Default MTU (size of Info field) */ 1706#ifndef PPP_MAXMTU 1707/* #define PPP_MAXMTU 65535 - (PPP_HDRLEN + PPP_FCSLEN) */ 1708#define PPP_MAXMTU 1500 /* Largest MTU we allow */ 1709#endif 1710#define PPP_MINMTU 64 1711#define PPP_MRU 1500 /* default MRU = max length of info field */ 1712#define PPP_MAXMRU 1500 /* Largest MRU we allow */ 1713#ifndef PPP_DEFMRU 1714#define PPP_DEFMRU 296 /* Try for this */ 1715#endif 1716#define PPP_MINMRU 128 /* No MRUs below this */ 1717 1718#ifndef MAXNAMELEN 1719#define MAXNAMELEN 256 /* max length of hostname or name for auth */ 1720#endif 1721#ifndef MAXSECRETLEN 1722#define MAXSECRETLEN 256 /* max length of password or secret */ 1723#endif 1724 1725#endif /* PPP_SUPPORT */ 1726 1727/* 1728 -------------------------------------- 1729 ---------- Checksum options ---------- 1730 -------------------------------------- 1731*/ 1732/** 1733 * CHECKSUM_GEN_IP==1: Generate checksums in software for outgoing IP packets. 1734 */ 1735#ifndef CHECKSUM_GEN_IP 1736#define CHECKSUM_GEN_IP 1 1737#endif 1738 1739/** 1740 * CHECKSUM_GEN_UDP==1: Generate checksums in software for outgoing UDP packets. 1741 */ 1742#ifndef CHECKSUM_GEN_UDP 1743#define CHECKSUM_GEN_UDP 1 1744#endif 1745 1746/** 1747 * CHECKSUM_GEN_TCP==1: Generate checksums in software for outgoing TCP packets. 1748 */ 1749#ifndef CHECKSUM_GEN_TCP 1750#define CHECKSUM_GEN_TCP 1 1751#endif 1752 1753/** 1754 * CHECKSUM_CHECK_IP==1: Check checksums in software for incoming IP packets. 1755 */ 1756#ifndef CHECKSUM_CHECK_IP 1757#define CHECKSUM_CHECK_IP 1 1758#endif 1759 1760/** 1761 * CHECKSUM_CHECK_UDP==1: Check checksums in software for incoming UDP packets. 1762 */ 1763#ifndef CHECKSUM_CHECK_UDP 1764#define CHECKSUM_CHECK_UDP 1 1765#endif 1766 1767/** 1768 * CHECKSUM_CHECK_TCP==1: Check checksums in software for incoming TCP packets. 1769 */ 1770#ifndef CHECKSUM_CHECK_TCP 1771#define CHECKSUM_CHECK_TCP 1 1772#endif 1773 1774/** 1775 * LWIP_CHECKSUM_ON_COPY==1: Calculate checksum when copying data from 1776 * application buffers to pbufs. 1777 */ 1778#ifndef LWIP_CHECKSUM_ON_COPY 1779#define LWIP_CHECKSUM_ON_COPY 0 1780#endif 1781 1782/* 1783 --------------------------------------- 1784 ---------- Debugging options ---------- 1785 --------------------------------------- 1786*/ 1787/** 1788 * LWIP_DBG_MIN_LEVEL: After masking, the value of the debug is 1789 * compared against this value. If it is smaller, then debugging 1790 * messages are written. 1791 */ 1792#ifndef LWIP_DBG_MIN_LEVEL 1793#define LWIP_DBG_MIN_LEVEL LWIP_DBG_LEVEL_ALL 1794#endif 1795 1796/** 1797 * LWIP_DBG_TYPES_ON: A mask that can be used to globally enable/disable 1798 * debug messages of certain types. 1799 */ 1800#ifndef LWIP_DBG_TYPES_ON 1801#define LWIP_DBG_TYPES_ON LWIP_DBG_ON 1802#endif 1803 1804/** 1805 * ETHARP_DEBUG: Enable debugging in etharp.c. 1806 */ 1807#ifndef ETHARP_DEBUG 1808#define ETHARP_DEBUG LWIP_DBG_OFF 1809#endif 1810 1811/** 1812 * NETIF_DEBUG: Enable debugging in netif.c. 1813 */ 1814#ifndef NETIF_DEBUG 1815#define NETIF_DEBUG LWIP_DBG_OFF 1816#endif 1817 1818/** 1819 * UNDIIF_DEBUG: Enable debugging in undiif.c. 1820 */ 1821#ifndef UNDIIF_DEBUG 1822#define UNDIIF_DEBUG LWIP_DBG_OFF 1823#endif 1824 1825/** 1826 * UNDIIF_ARP_DEBUG: Enable ETHARP debugging in undiif.c. 1827 */ 1828#ifndef UNDIIF_ARP_DEBUG 1829#define UNDIIF_ARP_DEBUG LWIP_DBG_OFF 1830#endif 1831 1832/** 1833 * UNDIIF_NET_DEBUG: Enable NETIF debugging in undiif.c. 1834 */ 1835#ifndef UNDIIF_NET_DEBUG 1836#define UNDIIF_NET_DEBUG LWIP_DBG_OFF 1837#endif 1838 1839/** 1840 * UNDIIF_ID_DEBUG: Enable debugging to identify packets in undiif.c. 1841 */ 1842#ifndef UNDIIF_ID_DEBUG 1843#define UNDIIF_ID_DEBUG LWIP_DBG_OFF 1844#endif 1845 1846/** 1847 * PBUF_DEBUG: Enable debugging in pbuf.c. 1848 */ 1849#ifndef PBUF_DEBUG 1850#define PBUF_DEBUG LWIP_DBG_OFF 1851#endif 1852 1853/** 1854 * API_LIB_DEBUG: Enable debugging in api_lib.c. 1855 */ 1856#ifndef API_LIB_DEBUG 1857#define API_LIB_DEBUG LWIP_DBG_OFF 1858#endif 1859 1860/** 1861 * API_MSG_DEBUG: Enable debugging in api_msg.c. 1862 */ 1863#ifndef API_MSG_DEBUG 1864#define API_MSG_DEBUG LWIP_DBG_OFF 1865#endif 1866 1867/** 1868 * SOCKETS_DEBUG: Enable debugging in sockets.c. 1869 */ 1870#ifndef SOCKETS_DEBUG 1871#define SOCKETS_DEBUG LWIP_DBG_OFF 1872#endif 1873 1874/** 1875 * ICMP_DEBUG: Enable debugging in icmp.c. 1876 */ 1877#ifndef ICMP_DEBUG 1878#define ICMP_DEBUG LWIP_DBG_OFF 1879#endif 1880 1881/** 1882 * IGMP_DEBUG: Enable debugging in igmp.c. 1883 */ 1884#ifndef IGMP_DEBUG 1885#define IGMP_DEBUG LWIP_DBG_OFF 1886#endif 1887 1888/** 1889 * INET_DEBUG: Enable debugging in inet.c. 1890 */ 1891#ifndef INET_DEBUG 1892#define INET_DEBUG LWIP_DBG_OFF 1893#endif 1894 1895/** 1896 * IP_DEBUG: Enable debugging for IP. 1897 */ 1898#ifndef IP_DEBUG 1899#define IP_DEBUG LWIP_DBG_OFF 1900#endif 1901 1902/** 1903 * IP_REASS_DEBUG: Enable debugging in ip_frag.c for both frag & reass. 1904 */ 1905#ifndef IP_REASS_DEBUG 1906#define IP_REASS_DEBUG LWIP_DBG_OFF 1907#endif 1908 1909/** 1910 * RAW_DEBUG: Enable debugging in raw.c. 1911 */ 1912#ifndef RAW_DEBUG 1913#define RAW_DEBUG LWIP_DBG_OFF 1914#endif 1915 1916/** 1917 * MEM_DEBUG: Enable debugging in mem.c. 1918 */ 1919#ifndef MEM_DEBUG 1920#define MEM_DEBUG LWIP_DBG_OFF 1921#endif 1922 1923/** 1924 * MEMP_DEBUG: Enable debugging in memp.c. 1925 */ 1926#ifndef MEMP_DEBUG 1927#define MEMP_DEBUG LWIP_DBG_OFF 1928#endif 1929 1930/** 1931 * SYS_DEBUG: Enable debugging in sys.c. 1932 */ 1933#ifndef SYS_DEBUG 1934#define SYS_DEBUG LWIP_DBG_OFF 1935#endif 1936 1937/** 1938 * TIMERS_DEBUG: Enable debugging in timers.c. 1939 */ 1940#ifndef TIMERS_DEBUG 1941#define TIMERS_DEBUG LWIP_DBG_OFF 1942#endif 1943 1944/** 1945 * TCP_DEBUG: Enable debugging for TCP. 1946 */ 1947#ifndef TCP_DEBUG 1948#define TCP_DEBUG LWIP_DBG_OFF 1949#endif 1950 1951/** 1952 * TCP_INPUT_DEBUG: Enable debugging in tcp_in.c for incoming debug. 1953 */ 1954#ifndef TCP_INPUT_DEBUG 1955#define TCP_INPUT_DEBUG LWIP_DBG_OFF 1956#endif 1957 1958/** 1959 * TCP_FR_DEBUG: Enable debugging in tcp_in.c for fast retransmit. 1960 */ 1961#ifndef TCP_FR_DEBUG 1962#define TCP_FR_DEBUG LWIP_DBG_OFF 1963#endif 1964 1965/** 1966 * TCP_RTO_DEBUG: Enable debugging in TCP for retransmit 1967 * timeout. 1968 */ 1969#ifndef TCP_RTO_DEBUG 1970#define TCP_RTO_DEBUG LWIP_DBG_OFF 1971#endif 1972 1973/** 1974 * TCP_CWND_DEBUG: Enable debugging for TCP congestion window. 1975 */ 1976#ifndef TCP_CWND_DEBUG 1977#define TCP_CWND_DEBUG LWIP_DBG_OFF 1978#endif 1979 1980/** 1981 * TCP_WND_DEBUG: Enable debugging in tcp_in.c for window updating. 1982 */ 1983#ifndef TCP_WND_DEBUG 1984#define TCP_WND_DEBUG LWIP_DBG_OFF 1985#endif 1986 1987/** 1988 * TCP_OUTPUT_DEBUG: Enable debugging in tcp_out.c output functions. 1989 */ 1990#ifndef TCP_OUTPUT_DEBUG 1991#define TCP_OUTPUT_DEBUG LWIP_DBG_OFF 1992#endif 1993 1994/** 1995 * TCP_RST_DEBUG: Enable debugging for TCP with the RST message. 1996 */ 1997#ifndef TCP_RST_DEBUG 1998#define TCP_RST_DEBUG LWIP_DBG_OFF 1999#endif 2000 2001/** 2002 * TCP_QLEN_DEBUG: Enable debugging for TCP queue lengths. 2003 */ 2004#ifndef TCP_QLEN_DEBUG 2005#define TCP_QLEN_DEBUG LWIP_DBG_OFF 2006#endif 2007 2008/** 2009 * UDP_DEBUG: Enable debugging in UDP. 2010 */ 2011#ifndef UDP_DEBUG 2012#define UDP_DEBUG LWIP_DBG_OFF 2013#endif 2014 2015/** 2016 * TCPIP_DEBUG: Enable debugging in tcpip.c. 2017 */ 2018#ifndef TCPIP_DEBUG 2019#define TCPIP_DEBUG LWIP_DBG_OFF 2020#endif 2021 2022/** 2023 * PPP_DEBUG: Enable debugging for PPP. 2024 */ 2025#ifndef PPP_DEBUG 2026#define PPP_DEBUG LWIP_DBG_OFF 2027#endif 2028 2029/** 2030 * SLIP_DEBUG: Enable debugging in slipif.c. 2031 */ 2032#ifndef SLIP_DEBUG 2033#define SLIP_DEBUG LWIP_DBG_OFF 2034#endif 2035 2036/** 2037 * DHCP_DEBUG: Enable debugging in dhcp.c. 2038 */ 2039#ifndef DHCP_DEBUG 2040#define DHCP_DEBUG LWIP_DBG_OFF 2041#endif 2042 2043/** 2044 * AUTOIP_DEBUG: Enable debugging in autoip.c. 2045 */ 2046#ifndef AUTOIP_DEBUG 2047#define AUTOIP_DEBUG LWIP_DBG_OFF 2048#endif 2049 2050/** 2051 * SNMP_MSG_DEBUG: Enable debugging for SNMP messages. 2052 */ 2053#ifndef SNMP_MSG_DEBUG 2054#define SNMP_MSG_DEBUG LWIP_DBG_OFF 2055#endif 2056 2057/** 2058 * SNMP_MIB_DEBUG: Enable debugging for SNMP MIBs. 2059 */ 2060#ifndef SNMP_MIB_DEBUG 2061#define SNMP_MIB_DEBUG LWIP_DBG_OFF 2062#endif 2063 2064/** 2065 * DNS_DEBUG: Enable debugging for DNS. 2066 */ 2067#ifndef DNS_DEBUG 2068#define DNS_DEBUG LWIP_DBG_OFF 2069#endif 2070 2071#endif /* __LWIP_OPT_H__ */ 2072