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 (at) 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
