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