libdb/uIP/uipopt.h

   1 /**
   2  * \defgroup uipopt Configuration options for uIP
   3  * @{
   4  *
   5  * uIP is configured using the per-project configuration file
   6  * "uipopt.h". This file contains all compile-time options for uIP and
   7  * should be tweaked to match each specific project. The uIP
   8  * distribution contains a documented example "uipopt.h" that can be
   9  * copied and modified for each project.
  10  */
  11
  12 /**
  13  * \file
  14  * Configuration options for uIP.
  15  * \author Adam Dunkels <adam@dunkels.com>
  16  *
  17  * This file is used for tweaking various configuration options for
  18  * uIP. You should make a copy of this file into one of your project's
  19  * directories instead of editing this example "uipopt.h" file that
  20  * comes with the uIP distribution.
  21  */
  22
  23 /*
  24  * Copyright (c) 2001-2003, Adam Dunkels.
  25  * All rights reserved.
  26  *
  27  * Redistribution and use in source and binary forms, with or without
  28  * modification, are permitted provided that the following conditions
  29  * are met:
  30  * 1. Redistributions of source code must retain the above copyright
  31  *    notice, this list of conditions and the following disclaimer.
  32  * 2. Redistributions in binary form must reproduce the above copyright
  33  *    notice, this list of conditions and the following disclaimer in the
  34  *    documentation and/or other materials provided with the distribution.
  35  * 3. The name of the author may not be used to endorse or promote
  36  *    products derived from this software without specific prior
  37  *    written permission.
  38  *
  39  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS
  40  * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  41  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  42  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
  43  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  44  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
  45  * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  46  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
  47  * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
  48  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  49  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  50  *
  51  * This file is part of the uIP TCP/IP stack.
  52  *
  53  *
  54  */
  55
  56 #ifndef __UIPOPT_H__
  57 #define __UIPOPT_H__
  58
  59 #include <gctypes.h>
  60 #include <stdlib.h>
  61 #include <string.h>
  62
  63 /*------------------------------------------------------------------------------*/
  64 /**
  65  * \defgroup uipopttypedef uIP type definitions
  66  * @{
  67  */
  68
  69 /**
  70  * The 8-bit unsigned data type.
  71  *
  72  * This may have to be tweaked for your particular compiler. "unsigned
  73  * char" works for most compilers.
  74  */
  75 typedef u8 u8_t;
  76
  77 /**
  78  * The 8-bit signed data type.
  79  *
  80  * This may have to be tweaked for your particular compiler. "unsigned
  81  * char" works for most compilers.
  82  */
  83 typedef s8 s8_t;
  84
  85 /**
  86  * The 16-bit unsigned data type.
  87  *
  88  * This may have to be tweaked for your particular compiler. "unsigned
  89  * short" works for most compilers.
  90  */
  91 typedef u16 u16_t;
  92
  93 /**
  94  * The 16-bit signed data type.
  95  *
  96  * This may have to be tweaked for your particular compiler. "unsigned
  97  * short" works for most compilers.
  98  */
  99 typedef s16 s16_t;
 100
 101 /**
 102  * The 32-bit signed data type.
 103  *
 104  * This may have to be tweaked for your particular compiler. "unsigned
 105  * short" works for most compilers.
 106  */
 107 typedef s32 s32_t;
 108
 109 /**
 110  * The 32-bit unsigned data type.
 111  *
 112  * This may have to be tweaked for your particular compiler. "unsigned
 113  * short" works for most compilers.
 114  */
 115 typedef u32 u32_t;
 116
 117 /**
 118  * The statistics data type.
 119  *
 120  * This datatype determines how high the statistics counters are able
 121  * to count.
 122  */
 123 typedef u16 uip_stats_t;
 124
 125 /** @} */
 126 /*------------------------------------------------------------------------------*/
 127 /**
 128  * \defgroup uipoptip IP configuration options
 129  * @{
 130  *
 131  */
 132 /**
 133  * The IP TTL (time to live) of IP packets sent by uIP.
 134  *
 135  * This should normally not be changed.
 136  */
 137 #define UIP_TCP_TTL         255
 138
 139 #define UIP_TCP                         1
 140
 141 /**
 142  * Turn on support for IP packet reassembly.
 143  *
 144  * uIP supports reassembly of fragmented IP packets. This features
 145  * requires an additonal amount of RAM to hold the reassembly buffer
 146  * and the reassembly code size is approximately 700 bytes.  The
 147  * reassembly buffer is of the same size as the uip_buf buffer
 148  * (configured by UIP_BUFSIZE).
 149  *
 150  * \note IP packet reassembly is not heavily tested.
 151  *
 152  * \hideinitializer
 153  */
 154 #define UIP_IP_REASSEMBLY 0
 155
 156 #define UIP_IP_FRAG 0
 157
 158 /**
 159  * The maximum time an IP fragment should wait in the reassembly
 160  * buffer before it is dropped.
 161  *
 162  */
 163 #define UIP_REASS_MAXAGE 30
 164
 165 /** @} */
 166
 167 /*------------------------------------------------------------------------------*/
 168 /**
 169  * \defgroup uipoptudp UDP configuration options
 170  * @{
 171  *
 172  * \note The UDP support in uIP is still not entirely complete; there
 173  * is no support for sending or receiving broadcast or multicast
 174  * packets, but it works well enough to support a number of vital
 175  * applications such as DNS queries, though
 176  */
 177
 178 /**
 179  * Toggles wether UDP support should be compiled in or not.
 180  *
 181  * \hideinitializer
 182  */
 183 #define UIP_UDP           0
 184
 185 /**
 186  * Toggles if UDP checksums should be used or not.
 187  *
 188  * \note Support for UDP checksums is currently not included in uIP,
 189  * so this option has no function.
 190  *
 191  * \hideinitializer
 192  */
 193 #define UIP_UDP_CHECKSUMS 0
 194
 195 /**
 196  * The maximum amount of concurrent UDP connections.
 197  *
 198  * \hideinitializer
 199  */
 200 #define UIP_UDP_CONNS    10
 201
 202 /**
 203  * The name of the function that should be called when UDP datagrams arrive.
 204  *
 205  * \hideinitializer
 206  */
 207 //#define UIP_UDP_APPCALL               ((void*0)
 208
 209 /** @} */
 210 /*------------------------------------------------------------------------------*/
 211 /**
 212  * \defgroup uipopttcp TCP configuration options
 213  * @{
 214  */
 215
 216 /**
 217  * Determines if support for opening connections from uIP should be
 218  * compiled in.
 219  *
 220  * If the applications that are running on top of uIP for this project
 221  * do not need to open outgoing TCP connections, this configration
 222  * option can be turned off to reduce the code size of uIP.
 223  *
 224  * \hideinitializer
 225  */
 226 #define UIP_ACTIVE_OPEN                         1
 227
 228 /**
 229  * The maximum number of simultaneously open TCP connections.
 230  *
 231  * Since the TCP connections are statically allocated, turning this
 232  * configuration knob down results in less RAM used. Each TCP
 233  * connection requires approximatly 30 bytes of memory.
 234  *
 235  * \hideinitializer
 236  */
 237 #define UIP_TCP_PCBS                            4
 238
 239 /**
 240  * The maximum number of simultaneously listening TCP ports.
 241  *
 242  * Each listening TCP port requires 2 bytes of memory.
 243  *
 244  * \hideinitializer
 245  */
 246 #define UIP_LISTEN_TCP_PCBS                     2
 247
 248 /**
 249  * The size of the advertised receiver's window.
 250  *
 251  * Should be set low (i.e., to the size of the uip_buf buffer) is the
 252  * application is slow to process incoming data, or high (32768 bytes)
 253  * if the application processes data quickly.
 254  *
 255  * \hideinitializer
 256  */
 257 #define UIP_TCPIP_SOCKS                         32
 258
 259 #define UIP_TCP_SEGS                            32
 260
 261
 262 /**
 263  * Determines if support for TCP urgent data notification should be
 264  * compiled in.
 265  *
 266  * Urgent data (out-of-band data) is a rarely used TCP feature that
 267  * very seldom would be required.
 268  *
 269  * \hideinitializer
 270  */
 271 #define UIP_URGDATA                             1
 272
 273 /**
 274  * The initial retransmission timeout counted in timer pulses.
 275  *
 276  * This should not be changed.
 277  */
 278 #define UIP_RTO                                 3
 279
 280 /**
 281  * The maximum number of times a segment should be retransmitted
 282  * before the connection should be aborted.
 283  *
 284  * This should not be changed.
 285  */
 286 #define UIP_MAXRTX                              12
 287
 288 /**
 289  * The maximum number of times a SYN segment should be retransmitted
 290  * before a connection request should be deemed to have been
 291  * unsuccessful.
 292  *
 293  * This should not need to be changed.
 294  */
 295 #define UIP_MAXSYNRTX                   4
 296
 297 /**
 298  * The TCP maximum segment size.
 299  *
 300  * This is should not be to set to more than UIP_BUFSIZE - UIP_LLH_LEN - 40.
 301  */
 302 #define UIP_TCP_MSS                             (1460)
 303
 304
 305 #define UIP_TCP_SND_BUF                 (4*UIP_TCP_MSS)
 306
 307 #define UIP_TCP_SND_QUEUELEN    (4*UIP_TCP_SND_BUF/UIP_TCP_MSS)
 308
 309 #define UIP_TCP_WND                             (4*UIP_TCP_MSS)
 310
 311 /**
 312  * How long a connection should stay in the TIME_WAIT state.
 313  *
 314  * This configiration option has no real implication, and it should be
 315  * left untouched.
 316  */
 317 #define UIP_TIME_WAIT_TIMEOUT   120
 318
 319
 320 /** @} */
 321 /*------------------------------------------------------------------------------*/
 322 /**
 323  * \defgroup uipoptarp ARP configuration options
 324  * @{
 325  */
 326
 327 /**
 328  * The size of the ARP table.
 329  *
 330  * This option should be set to a larger value if this uIP node will
 331  * have many connections from the local network.
 332  *
 333  * \hideinitializer
 334  */
 335 #define UIP_ARPTAB_SIZE 8
 336
 337 /**
 338  * The maxium age of ARP table entries measured in 10ths of seconds.
 339  *
 340  * An UIP_ARP_MAXAGE of 120 corresponds to 20 minutes (BSD
 341  * default).
 342  */
 343 #define UIP_ARP_MAXAGE 120
 344
 345 /** @} */
 346
 347 /*------------------------------------------------------------------------------*/
 348
 349 /**
 350  * \defgroup uipoptgeneral General configuration options
 351  * @{
 352  */
 353
 354 /**
 355  * The size of the uIP packet buffer.
 356  *
 357  * The uIP packet buffer should not be smaller than 60 bytes, and does
 358  * not need to be larger than 1500 bytes. Lower size results in lower
 359  * TCP throughput, larger size results in higher TCP throughput.
 360  *
 361  * \hideinitializer
 362  */
 363 #define UIP_MEM_SIZE                            (28*1024)
 364
 365 #define UIP_PBUF_POOL_NUM                       16
 366 #define UIP_PBUF_POOL_BUFSIZE           1600
 367
 368 #define UIP_PBUF_ROM_NUM                        128
 369
 370
 371 /**
 372  * Determines if statistics support should be compiled in.
 373  *
 374  * The statistics is useful for debugging and to show the user.
 375  *
 376  * \hideinitializer
 377  */
 378 #define UIP_STATISTICS  0
 379
 380 /**
 381  * Determines if logging of certain events should be compiled in.
 382  *
 383  * This is useful mostly for debugging. The function uip_log()
 384  * must be implemented to suit the architecture of the project, if
 385  * logging is turned on.
 386  *
 387  * \hideinitializer
 388  */
 389 #define UIP_LOGGING     0
 390 #define UIP_ERRORING    0
 391
 392 /**
 393  * Print out a uIP log message.
 394  *
 395  * This function must be implemented by the module that uses uIP, and
 396  * is called by uIP whenever a log message is generated.
 397  */
 398 void uip_log(const char *filename,int line_nb,char *msg);
 399
 400 /**
 401  * The link level header length.
 402  *
 403  * This is the offset into the uip_buf where the IP header can be
 404  * found. For Ethernet, this should be set to 14. For SLIP, this
 405  * should be set to 0.
 406  *
 407  * \hideinitializer
 408  */
 409 #define UIP_LL_HLEN     16
 410
 411 #define UIP_TCPIP_HLEN  40
 412 /** @} */
 413 /*------------------------------------------------------------------------------*/
 414 /**
 415  * \defgroup uipoptcpu CPU architecture configuration
 416  * @{
 417  *
 418  * The CPU architecture configuration is where the endianess of the
 419  * CPU on which uIP is to be run is specified. Most CPUs today are
 420  * little endian, and the most notable exception are the Motorolas
 421  * which are big endian. The BYTE_ORDER macro should be changed to
 422  * reflect the CPU architecture on which uIP is to be run.
 423  */
 424 #ifndef LITTLE_ENDIAN
 425 #define LITTLE_ENDIAN  3412
 426 #endif /* LITTLE_ENDIAN */
 427 #ifndef BIG_ENDIAN
 428 #define BIG_ENDIAN     1234
 429 #endif /* BIGE_ENDIAN */
 430
 431 /**
 432  * The byte order of the CPU architecture on which uIP is to be run.
 433  *
 434  * This option can be either BIG_ENDIAN (Motorola byte order) or
 435  * LITTLE_ENDIAN (Intel byte order).
 436  *
 437  * \hideinitializer
 438  */
 439 #ifndef BYTE_ORDER
 440 #define BYTE_ORDER     BIG_ENDIAN
 441 #endif /* BYTE_ORDER */
 442
 443 /** @} */
 444 /*------------------------------------------------------------------------------*/
 445
 446 /**
 447  * \defgroup uipoptapp Appication specific configurations
 448  * @{
 449  *
 450  * An uIP application is implemented using a single application
 451  * function that is called by uIP whenever a TCP/IP event occurs. The
 452  * name of this function must be registered with uIP at compile time
 453  * using the UIP_APPCALL definition.
 454  *
 455  * uIP applications can store the application state within the
 456  * uip_conn structure by specifying the size of the application
 457  * structure with the UIP_APPSTATE_SIZE macro.
 458  *
 459  * The file containing the definitions must be included in the
 460  * uipopt.h file.
 461  *
 462  * The following example illustrates how this can look.
 463  \code
 464
 465 void httpd_appcall(void);
 466 #define UIP_APPCALL     httpd_appcall
 467
 468 struct httpd_state {
 469   u8_t state;
 470   u16_t count;
 471   char *dataptr;
 472   char *script;
 473 };
 474 #define UIP_APPSTATE_SIZE (sizeof(struct httpd_state))
 475  \endcode
 476  */
 477
 478 /**
 479  * \var #define UIP_APPCALL
 480  *
 481  * The name of the application function that uIP should call in
 482  * response to TCP/IP events.
 483  *
 484  */
 485
 486 /**
 487  * \var #define UIP_APPSTATE_SIZE
 488  *
 489  * The size of the application state that is to be stored in the
 490  * uip_conn structure.
 491  */
 492 /** @} */
 493
 494 /* Include the header file for the application program that should be
 495    used. If you don't use the example web server, you should change
 496    this. */
 497
 498 #define UIP_LIBC_MEMFUNCREPLACE                         1
 499
 500 #endif /* __UIPOPT_H__ */