Projects/Webserver/Lib/uip/uipopt.h

   1 /**
   2  * \addtogroup uip
   3  * @{
   4  */
   5
   6 /**
   7  * \defgroup uipopt Configuration options for uIP
   8  * @{
   9  *
  10  * uIP is configured using the per-project configuration file
  11  * "uipopt.h". This file contains all compile-time options for uIP and
  12  * should be tweaked to match each specific project. The uIP
  13  * distribution contains a documented example "uipopt.h" that can be
  14  * copied and modified for each project.
  15  */
  16
  17 /**
  18  * \file
  19  * Configuration options for uIP.
  20  * \author Adam Dunkels <adam@dunkels.com>
  21  *
  22  * This file is used for tweaking various configuration options for
  23  * uIP. You should make a copy of this file into one of your project's
  24  * directories instead of editing this example "uipopt.h" file that
  25  * comes with the uIP distribution.
  26  */
  27
  28 /*
  29  * Copyright (c) 2001-2003, Adam Dunkels.
  30  * All rights reserved.
  31  *
  32  * Redistribution and use in source and binary forms, with or without
  33  * modification, are permitted provided that the following conditions
  34  * are met:
  35  * 1. Redistributions of source code must retain the above copyright
  36  *    notice, this list of conditions and the following disclaimer.
  37  * 2. Redistributions in binary form must reproduce the above copyright
  38  *    notice, this list of conditions and the following disclaimer in the
  39  *    documentation and/or other materials provided with the distribution.
  40  * 3. The name of the author may not be used to endorse or promote
  41  *    products derived from this software without specific prior
  42  *    written permission.
  43  *
  44  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS
  45  * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  46  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  47  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
  48  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  49  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
  50  * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  51  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
  52  * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
  53  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  54  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  55  *
  56  * This file is part of the uIP TCP/IP stack.
  57  *
  58  * $Id: uipopt.h,v 1.11 2009/04/10 00:37:48 adamdunkels Exp $
  59  *
  60  */
  61
  62 #ifndef __UIPOPT_H__
  63 #define __UIPOPT_H__
  64
  65 #ifndef UIP_LITTLE_ENDIAN
  66 #define UIP_LITTLE_ENDIAN  3412
  67 #endif /* UIP_LITTLE_ENDIAN */
  68 #ifndef UIP_BIG_ENDIAN
  69 #define UIP_BIG_ENDIAN     1234
  70 #endif /* UIP_BIG_ENDIAN */
  71
  72 /*------------------------------------------------------------------------------*/
  73
  74 /**
  75  * \defgroup uipoptstaticconf Static configuration options
  76  * @{
  77  *
  78  * These configuration options can be used for setting the IP address
  79  * settings statically, but only if UIP_FIXEDADDR is set to 1. The
  80  * configuration options for a specific node includes IP address,
  81  * netmask and default router as well as the Ethernet address. The
  82  * netmask, default router and Ethernet address are applicable only
  83  * if uIP should be run over Ethernet.
  84  *
  85  * This options are meaningful only for the IPv4 code.
  86  *
  87  * All of these should be changed to suit your project.
  88  */
  89
  90 /**
  91  * Determines if uIP should use a fixed IP address or not.
  92  *
  93  * If uIP should use a fixed IP address, the settings are set in the
  94  * uipopt.h file. If not, the macros uip_sethostaddr(),
  95  * uip_setdraddr() and uip_setnetmask() should be used instead.
  96  *
  97  * \hideinitializer
  98  */
  99 #define UIP_FIXEDADDR    0
 100
 101 /**
 102  * Ping IP address assignment.
 103  *
 104  * uIP uses a "ping" packets for setting its own IP address if this
 105  * option is set. If so, uIP will start with an empty IP address and
 106  * the destination IP address of the first incoming "ping" (ICMP echo)
 107  * packet will be used for setting the hosts IP address.
 108  *
 109  * \note This works only if UIP_FIXEDADDR is 0.
 110  *
 111  * \hideinitializer
 112  */
 113 #ifdef UIP_CONF_PINGADDRCONF
 114 #define UIP_PINGADDRCONF UIP_CONF_PINGADDRCONF
 115 #else /* UIP_CONF_PINGADDRCONF */
 116 #define UIP_PINGADDRCONF 0
 117 #endif /* UIP_CONF_PINGADDRCONF */
 118
 119
 120 /**
 121  * Specifies if the uIP ARP module should be compiled with a fixed
 122  * Ethernet MAC address or not.
 123  *
 124  * If this configuration option is 0, the macro uip_setethaddr() can
 125  * be used to specify the Ethernet address at run-time.
 126  *
 127  * \hideinitializer
 128  */
 129 #define UIP_FIXEDETHADDR 0
 130
 131 /** @} */
 132 /*------------------------------------------------------------------------------*/
 133 /**
 134  * \defgroup uipoptip IP configuration options
 135  * @{
 136  *
 137  */
 138 /**
 139  * The IP TTL (time to live) of IP packets sent by uIP.
 140  *
 141  * This should normally not be changed.
 142  */
 143 #define UIP_TTL         64
 144
 145 /**
 146  * The maximum time an IP fragment should wait in the reassembly
 147  * buffer before it is dropped.
 148  *
 149  */
 150 #define UIP_REASS_MAXAGE 60 /*60s*/
 151
 152 /**
 153  * Turn on support for IP packet reassembly.
 154  *
 155  * uIP supports reassembly of fragmented IP packets. This features
 156  * requires an additional amount of RAM to hold the reassembly buffer
 157  * and the reassembly code size is approximately 700 bytes.  The
 158  * reassembly buffer is of the same size as the uip_buf buffer
 159  * (configured by UIP_BUFSIZE).
 160  *
 161  * \note IP packet reassembly is not heavily tested.
 162  *
 163  * \hideinitializer
 164  */
 165 #ifdef UIP_CONF_REASSEMBLY
 166 #define UIP_REASSEMBLY UIP_CONF_REASSEMBLY
 167 #else /* UIP_CONF_REASSEMBLY */
 168 #define UIP_REASSEMBLY 0
 169 #endif /* UIP_CONF_REASSEMBLY */
 170 /** @} */
 171
 172 /*------------------------------------------------------------------------------*/
 173 /**
 174  * \defgroup uipoptipv6 IPv6 configuration options
 175  * @{
 176  *
 177  */
 178
 179 /** The maximum transmission unit at the IP Layer*/
 180 #define UIP_LINK_MTU 1280
 181
 182 #ifndef UIP_CONF_IPV6
 183 /** Do we use IPv6 or not (default: no) */
 184 #define UIP_CONF_IPV6                 0
 185 #endif
 186
 187 #ifndef UIP_CONF_IPV6_QUEUE_PKT
 188 /** Do we do per %neighbor queuing during address resolution (default: no) */
 189 #define UIP_CONF_IPV6_QUEUE_PKT       0
 190 #endif
 191
 192 #ifndef UIP_CONF_IPV6_CHECKS
 193 /** Do we do IPv6 consistency checks (highly recommended, default: yes) */
 194 #define UIP_CONF_IPV6_CHECKS          1
 195 #endif
 196
 197 #ifndef UIP_CONF_IPV6_REASSEMBLY
 198 /** Do we do IPv6 fragmentation (default: no) */
 199 #define UIP_CONF_IPV6_REASSEMBLY      0
 200 #endif
 201
 202 #ifndef UIP_CONF_NETIF_MAX_ADDRESSES
 203 /** Default number of IPv6 addresses associated to the node's interface */
 204 #define UIP_CONF_NETIF_MAX_ADDRESSES  3
 205 #endif
 206
 207 #ifndef UIP_CONF_ND6_MAX_PREFIXES
 208 /** Default number of IPv6 prefixes associated to the node's interface */
 209 #define UIP_CONF_ND6_MAX_PREFIXES     3
 210 #endif
 211
 212 #ifndef UIP_CONF_ND6_MAX_NEIGHBORS
 213 /** Default number of neighbors that can be stored in the %neighbor cache */
 214 #define UIP_CONF_ND6_MAX_NEIGHBORS    4
 215 #endif
 216
 217 #ifndef UIP_CONF_ND6_MAX_DEFROUTERS
 218 /** Minimum number of default routers */
 219 #define UIP_CONF_ND6_MAX_DEFROUTERS   2
 220 #endif
 221 /** @} */
 222
 223 /*------------------------------------------------------------------------------*/
 224 /**
 225  * \defgroup uipoptudp UDP configuration options
 226  * @{
 227  *
 228  * \note The UDP support in uIP is still not entirely complete; there
 229  * is no support for sending or receiving broadcast or multicast
 230  * packets, but it works well enough to support a number of vital
 231  * applications such as DNS queries, though
 232  */
 233
 234 /**
 235  * Toggles whether UDP support should be compiled in or not.
 236  *
 237  * \hideinitializer
 238  */
 239 #ifdef UIP_CONF_UDP
 240 #define UIP_UDP UIP_CONF_UDP
 241 #else /* UIP_CONF_UDP */
 242 #define UIP_UDP           1
 243 #endif /* UIP_CONF_UDP */
 244
 245 /**
 246  * Toggles if UDP checksums should be used or not.
 247  *
 248  * \note Support for UDP checksums is currently not included in uIP,
 249  * so this option has no function.
 250  *
 251  * \hideinitializer
 252  */
 253 #ifdef UIP_CONF_UDP_CHECKSUMS
 254 #define UIP_UDP_CHECKSUMS UIP_CONF_UDP_CHECKSUMS
 255 #else
 256 #define UIP_UDP_CHECKSUMS 0
 257 #endif
 258
 259 /**
 260  * The maximum amount of concurrent UDP connections.
 261  *
 262  * \hideinitializer
 263  */
 264 #ifdef UIP_CONF_UDP_CONNS
 265 #define UIP_UDP_CONNS UIP_CONF_UDP_CONNS
 266 #else /* UIP_CONF_UDP_CONNS */
 267 #define UIP_UDP_CONNS    10
 268 #endif /* UIP_CONF_UDP_CONNS */
 269
 270 /**
 271  * The name of the function that should be called when UDP datagrams arrive.
 272  *
 273  * \hideinitializer
 274  */
 275
 276
 277 /** @} */
 278 /*------------------------------------------------------------------------------*/
 279 /**
 280  * \defgroup uipopttcp TCP configuration options
 281  * @{
 282  */
 283
 284 /**
 285  * Toggles whether UDP support should be compiled in or not.
 286  *
 287  * \hideinitializer
 288  */
 289 #ifdef UIP_CONF_TCP
 290 #define UIP_TCP UIP_CONF_TCP
 291 #else /* UIP_CONF_UDP */
 292 #define UIP_TCP           1
 293 #endif /* UIP_CONF_UDP */
 294
 295 /**
 296  * Determines if support for opening connections from uIP should be
 297  * compiled in.
 298  *
 299  * If the applications that are running on top of uIP for this project
 300  * do not need to open outgoing TCP connections, this configuration
 301  * option can be turned off to reduce the code size of uIP.
 302  *
 303  * \hideinitializer
 304  */
 305 #ifndef UIP_CONF_ACTIVE_OPEN
 306 #define UIP_ACTIVE_OPEN 1
 307 #else /* UIP_CONF_ACTIVE_OPEN */
 308 #define UIP_ACTIVE_OPEN UIP_CONF_ACTIVE_OPEN
 309 #endif /* UIP_CONF_ACTIVE_OPEN */
 310
 311 /**
 312  * The maximum number of simultaneously open TCP connections.
 313  *
 314  * Since the TCP connections are statically allocated, turning this
 315  * configuration knob down results in less RAM used. Each TCP
 316  * connection requires approximately 30 bytes of memory.
 317  *
 318  * \hideinitializer
 319  */
 320 #ifndef UIP_CONF_MAX_CONNECTIONS
 321 #define UIP_CONNS       10
 322 #else /* UIP_CONF_MAX_CONNECTIONS */
 323 #define UIP_CONNS UIP_CONF_MAX_CONNECTIONS
 324 #endif /* UIP_CONF_MAX_CONNECTIONS */
 325
 326
 327 /**
 328  * The maximum number of simultaneously listening TCP ports.
 329  *
 330  * Each listening TCP port requires 2 bytes of memory.
 331  *
 332  * \hideinitializer
 333  */
 334 #ifndef UIP_CONF_MAX_LISTENPORTS
 335 #define UIP_LISTENPORTS 20
 336 #else /* UIP_CONF_MAX_LISTENPORTS */
 337 #define UIP_LISTENPORTS UIP_CONF_MAX_LISTENPORTS
 338 #endif /* UIP_CONF_MAX_LISTENPORTS */
 339
 340 /**
 341  * Determines if support for TCP urgent data notification should be
 342  * compiled in.
 343  *
 344  * Urgent data (out-of-band data) is a rarely used TCP feature that
 345  * very seldom would be required.
 346  *
 347  * \hideinitializer
 348  */
 349 #if !defined(UIP_URGDATA)
 350 #define UIP_URGDATA      0
 351 #endif
 352
 353 /**
 354  * The initial retransmission timeout counted in timer pulses.
 355  *
 356  * This should not be changed.
 357  */
 358 #if !defined(UIP_RTO)
 359 #define UIP_RTO         3
 360 #endif
 361
 362 /**
 363  * The maximum number of times a segment should be retransmitted
 364  * before the connection should be aborted.
 365  *
 366  * This should not be changed.
 367  */
 368 #if !defined(UIP_MAXRTX)
 369 #define UIP_MAXRTX      8
 370 #endif
 371
 372 /**
 373  * The maximum number of times a SYN segment should be retransmitted
 374  * before a connection request should be deemed to have been
 375  * unsuccessful.
 376  *
 377  * This should not need to be changed.
 378  */
 379 #if !defined(UIP_MAXSYNRTX)
 380 #define UIP_MAXSYNRTX      5
 381 #endif
 382
 383 /**
 384  * The TCP maximum segment size.
 385  *
 386  * This is should not be to set to more than
 387  * UIP_BUFSIZE - UIP_LLH_LEN - UIP_TCPIP_HLEN.
 388  */
 389 #ifdef UIP_CONF_TCP_MSS
 390 #define UIP_TCP_MSS UIP_CONF_TCP_MSS
 391 #else
 392 #define UIP_TCP_MSS     (UIP_BUFSIZE - UIP_LLH_LEN - UIP_TCPIP_HLEN)
 393 #endif
 394
 395 /**
 396  * The size of the advertised receiver's window.
 397  *
 398  * Should be set low (i.e., to the size of the uip_buf buffer) if the
 399  * application is slow to process incoming data, or high (32768 bytes)
 400  * if the application processes data quickly.
 401  *
 402  * \hideinitializer
 403  */
 404 #ifndef UIP_CONF_RECEIVE_WINDOW
 405 #define UIP_RECEIVE_WINDOW UIP_TCP_MSS
 406 #else
 407 #define UIP_RECEIVE_WINDOW UIP_CONF_RECEIVE_WINDOW
 408 #endif
 409
 410 /**
 411  * How long a connection should stay in the TIME_WAIT state.
 412  *
 413  * This configuration option has no real implication, and it should be
 414  * left untouched.
 415  */
 416 #define UIP_TIME_WAIT_TIMEOUT 120
 417
 418
 419 /** @} */
 420 /*------------------------------------------------------------------------------*/
 421 /**
 422  * \defgroup uipoptarp ARP configuration options
 423  * @{
 424  */
 425
 426 /**
 427  * The size of the ARP table.
 428  *
 429  * This option should be set to a larger value if this uIP node will
 430  * have many connections from the local network.
 431  *
 432  * \hideinitializer
 433  */
 434 #ifdef UIP_CONF_ARPTAB_SIZE
 435 #define UIP_ARPTAB_SIZE UIP_CONF_ARPTAB_SIZE
 436 #else
 437 #define UIP_ARPTAB_SIZE 8
 438 #endif
 439
 440 /**
 441  * The maximum age of ARP table entries measured in 10ths of seconds.
 442  *
 443  * An UIP_ARP_MAXAGE of 120 corresponds to 20 minutes (BSD
 444  * default).
 445  */
 446 #define UIP_ARP_MAXAGE 120
 447
 448
 449 /** @} */
 450
 451 /*------------------------------------------------------------------------------*/
 452
 453 /**
 454  * \defgroup uipoptmac layer 2 options (for ipv6)
 455  * @{
 456  */
 457
 458 #define UIP_DEFAULT_PREFIX_LEN 64
 459
 460 /** @} */
 461
 462 /*------------------------------------------------------------------------------*/
 463
 464 /**
 465  * \defgroup uipoptsics 6lowpan options (for ipv6)
 466  * @{
 467  */
 468 /**
 469  * Timeout for packet reassembly at the 6lowpan layer
 470  * (should be < 60s)
 471  */
 472 #ifdef SICSLOWPAN_CONF_MAXAGE
 473 #define SICSLOWPAN_REASS_MAXAGE SICSLOWPAN_CONF_MAXAGE
 474 #else
 475 #define SICSLOWPAN_REASS_MAXAGE 20
 476 #endif
 477
 478 /**
 479  * Do we compress the IP header or not (default: no)
 480  */
 481 #ifndef SICSLOWPAN_CONF_COMPRESSION
 482 #define SICSLOWPAN_CONF_COMPRESSION 0
 483 #endif
 484
 485 /**
 486  * If we use IPHC compression, how many address contexts do we support
 487  */
 488 #ifndef SICSLOWPAN_CONF_MAX_ADDR_CONTEXTS
 489 #define SICSLOWPAN_CONF_MAX_ADDR_CONTEXTS 1
 490 #endif
 491
 492 /**
 493  * Do we support 6lowpan fragmentation
 494  */
 495 #ifndef SICSLOWPAN_CONF_FRAG
 496 #define SICSLOWPAN_CONF_FRAG  0
 497 #endif
 498
 499 /** @} */
 500
 501 /*------------------------------------------------------------------------------*/
 502
 503 /**
 504  * \defgroup uipoptgeneral General configuration options
 505  * @{
 506  */
 507
 508 /**
 509  * The size of the uIP packet buffer.
 510  *
 511  * The uIP packet buffer should not be smaller than 60 bytes, and does
 512  * not need to be larger than 1514 bytes. Lower size results in lower
 513  * TCP throughput, larger size results in higher TCP throughput.
 514  *
 515  * \hideinitializer
 516  */
 517 #ifndef UIP_CONF_BUFFER_SIZE
 518 #define UIP_BUFSIZE UIP_LINK_MTU + UIP_LLH_LEN
 519 #else /* UIP_CONF_BUFFER_SIZE */
 520 #define UIP_BUFSIZE UIP_CONF_BUFFER_SIZE
 521 #endif /* UIP_CONF_BUFFER_SIZE */
 522
 523
 524 /**
 525  * Determines if statistics support should be compiled in.
 526  *
 527  * The statistics is useful for debugging and to show the user.
 528  *
 529  * \hideinitializer
 530  */
 531 #ifndef UIP_CONF_STATISTICS
 532 #define UIP_STATISTICS  0
 533 #else /* UIP_CONF_STATISTICS */
 534 #define UIP_STATISTICS UIP_CONF_STATISTICS
 535 #endif /* UIP_CONF_STATISTICS */
 536
 537 /**
 538  * Determines if logging of certain events should be compiled in.
 539  *
 540  * This is useful mostly for debugging. The function uip_log()
 541  * must be implemented to suit the architecture of the project, if
 542  * logging is turned on.
 543  *
 544  * \hideinitializer
 545  */
 546 #ifndef UIP_CONF_LOGGING
 547 #define UIP_LOGGING     0
 548 #else /* UIP_CONF_LOGGING */
 549 #define UIP_LOGGING     UIP_CONF_LOGGING
 550 #endif /* UIP_CONF_LOGGING */
 551
 552 /**
 553  * Broadcast support.
 554  *
 555  * This flag configures IP broadcast support. This is useful only
 556  * together with UDP.
 557  *
 558  * \hideinitializer
 559  *
 560  */
 561 #ifndef UIP_CONF_BROADCAST
 562 #define UIP_BROADCAST 0
 563 #else /* UIP_CONF_BROADCAST */
 564 #define UIP_BROADCAST UIP_CONF_BROADCAST
 565 #endif /* UIP_CONF_BROADCAST */
 566
 567 /**
 568  * Print out a uIP log message.
 569  *
 570  * This function must be implemented by the module that uses uIP, and
 571  * is called by uIP whenever a log message is generated.
 572  */
 573 void uip_log(char *msg);
 574
 575 /**
 576  * The link level header length.
 577  *
 578  * This is the offset into the uip_buf where the IP header can be
 579  * found. For Ethernet, this should be set to 14. For SLIP, this
 580  * should be set to 0.
 581  *
 582  * \note we probably won't use this constant for other link layers than
 583  * ethernet as they have variable header length (this is due to variable
 584  * number and type of address fields and to optional security features)
 585  * E.g.: 802.15.4 -> 2 + (1/2*4/8) + 0/5/6/10/14
 586  *       802.11 -> 4 + (6*3/4) + 2
 587  * \hideinitializer
 588  */
 589 #ifdef UIP_CONF_LLH_LEN
 590 #define UIP_LLH_LEN UIP_CONF_LLH_LEN
 591 #else /* UIP_LLH_LEN */
 592 #define UIP_LLH_LEN     14
 593 #endif /* UIP_CONF_LLH_LEN */
 594
 595 /** @} */
 596 /*------------------------------------------------------------------------------*/
 597 /**
 598  * \defgroup uipoptcpu CPU architecture configuration
 599  * @{
 600  *
 601  * The CPU architecture configuration is where the endianess of the
 602  * CPU on which uIP is to be run is specified. Most CPUs today are
 603  * little endian, and the most notable exception are the Motorolas
 604  * which are big endian. The BYTE_ORDER macro should be changed to
 605  * reflect the CPU architecture on which uIP is to be run.
 606  */
 607
 608 /**
 609  * The byte order of the CPU architecture on which uIP is to be run.
 610  *
 611  * This option can be either UIP_BIG_ENDIAN (Motorola byte order) or
 612  * UIP_LITTLE_ENDIAN (Intel byte order).
 613  *
 614  * \hideinitializer
 615  */
 616 #ifdef UIP_CONF_BYTE_ORDER
 617 #define UIP_BYTE_ORDER     UIP_CONF_BYTE_ORDER
 618 #else /* UIP_CONF_BYTE_ORDER */
 619 #define UIP_BYTE_ORDER     UIP_LITTLE_ENDIAN
 620 #endif /* UIP_CONF_BYTE_ORDER */
 621
 622 /** @} */
 623 /*------------------------------------------------------------------------------*/
 624
 625 #include <ff.h>
 626 #include <stdbool.h>
 627 #include <stdint.h>
 628
 629 typedef uint8_t u8_t;
 630 typedef uint16_t u16_t;
 631 typedef uint32_t u32_t;
 632 typedef uint32_t uip_stats_t;
 633
 634 /**
 635  * \defgroup uipoptapp Application specific configurations
 636  * @{
 637  *
 638  * An uIP application is implemented using a single application
 639  * function that is called by uIP whenever a TCP/IP event occurs. The
 640  * name of this function must be registered with uIP at compile time
 641  * using the UIP_APPCALL definition.
 642  *
 643  * uIP applications can store the application state within the
 644  * uip_conn structure by specifying the type of the application
 645  * structure by typedef:ing the type uip_tcp_appstate_t and uip_udp_appstate_t.
 646  *
 647  * The file containing the definitions must be included in the
 648  * uipopt.h file.
 649  *
 650  * The following example illustrates how this can look.
 651  \code
 652
 653  void httpd_appcall(void);
 654  #define UIP_APPCALL     httpd_appcall
 655
 656  struct httpd_state {
 657  u8_t state;
 658  u16_t count;
 659  char *dataptr;
 660  char *script;
 661  };
 662  typedef struct httpd_state uip_tcp_appstate_t
 663  \endcode
 664 */
 665 #define UIP_UDP_APPCALL uIPManagement_UDPCallback
 666 void UIP_UDP_APPCALL(void);
 667
 668 /**
 669  * \var #define UIP_APPCALL
 670  *
 671  * The name of the application function that uIP should call in
 672  * response to TCP/IP events.
 673  *
 674  */
 675 #define UIP_APPCALL     uIPManagement_TCPCallback
 676 void UIP_APPCALL(void);
 677
 678 /**
 679  * \var typedef uip_tcp_appstate_t
 680  *
 681  * The type of the application state that is to be stored in the
 682  * uip_conn structure. This usually is typedef:ed to a struct holding
 683  * application state information.
 684  */
 685 typedef union
 686 {
 687         struct
 688         {
 689                 uint8_t  CurrentState;
 690                 uint8_t  NextState;
 691
 692                 char     FileName[50];
 693                 FIL      FileHandle;
 694                 bool     FileOpen;
 695                 uint32_t ACKedFilePos;
 696                 uint16_t SentChunkSize;
 697         } HTTPServer;
 698
 699         struct
 700         {
 701                 uint8_t  CurrentState;
 702                 uint8_t  NextState;
 703
 704                 uint8_t  IssuedCommand;
 705         } TELNETServer;
 706 } uip_tcp_appstate_t;
 707
 708 /**
 709  * \var typedef uip_udp_appstate_t
 710  *
 711  * The type of the application state that is to be stored in the
 712  * uip_conn structure. This usually is typedef:ed to a struct holding
 713  * application state information.
 714  */
 715 typedef union
 716 {
 717         struct
 718         {
 719                 uint8_t CurrentState;
 720
 721                 struct
 722                 {
 723                         uint8_t AllocatedIP[4];
 724                         uint8_t Netmask[4];
 725                         uint8_t GatewayIP[4];
 726                         uint8_t ServerIP[4];
 727                 } DHCPOffer_Data;
 728         } DHCPClient;
 729 } uip_udp_appstate_t;
 730 /** @} */
 731
 732 #endif /* __UIPOPT_H__ */
 733 /** @} */
 734 /** @} */