uIP 1.0: uip/uip.c Source File

00001 #define DEBUG_PRINTF(...) /*printf(__VA_ARGS__)*/
+00002 
+00003 /**
+00004  * \defgroup uip The uIP TCP/IP stack
+00005  * @{
+00006  *
+00007  * uIP is an implementation of the TCP/IP protocol stack intended for
+00008  * small 8-bit and 16-bit microcontrollers.
+00009  *
+00010  * uIP provides the necessary protocols for Internet communication,
+00011  * with a very small code footprint and RAM requirements - the uIP
+00012  * code size is on the order of a few kilobytes and RAM usage is on
+00013  * the order of a few hundred bytes.
+00014  */
+00015 
+00016 /**
+00017  * \file
+00018  * The uIP TCP/IP stack code.
+00019  * \author Adam Dunkels <adam@dunkels.com>
+00020  */
+00021 
+00022 /*
+00023  * Copyright (c) 2001-2003, Adam Dunkels.
+00024  * All rights reserved.
+00025  *
+00026  * Redistribution and use in source and binary forms, with or without
+00027  * modification, are permitted provided that the following conditions
+00028  * are met:
+00029  * 1. Redistributions of source code must retain the above copyright
+00030  *    notice, this list of conditions and the following disclaimer.
+00031  * 2. Redistributions in binary form must reproduce the above copyright
+00032  *    notice, this list of conditions and the following disclaimer in the
+00033  *    documentation and/or other materials provided with the distribution.
+00034  * 3. The name of the author may not be used to endorse or promote
+00035  *    products derived from this software without specific prior
+00036  *    written permission.
+00037  *
+00038  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS
+00039  * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+00040  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+00041  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
+00042  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+00043  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
+00044  * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+00045  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+00046  * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+00047  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+00048  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+00049  *
+00050  * This file is part of the uIP TCP/IP stack.
+00051  *
+00052  * $Id: uip.c,v 1.65 2006/06/11 21:46:39 adam Exp $
+00053  *
+00054  */
+00055 
+00056 /*
+00057  * uIP is a small implementation of the IP, UDP and TCP protocols (as
+00058  * well as some basic ICMP stuff). The implementation couples the IP,
+00059  * UDP, TCP and the application layers very tightly. To keep the size
+00060  * of the compiled code down, this code frequently uses the goto
+00061  * statement. While it would be possible to break the uip_process()
+00062  * function into many smaller functions, this would increase the code
+00063  * size because of the overhead of parameter passing and the fact that
+00064  * the optimier would not be as efficient.
+00065  *
+00066  * The principle is that we have a small buffer, called the uip_buf,
+00067  * in which the device driver puts an incoming packet. The TCP/IP
+00068  * stack parses the headers in the packet, and calls the
+00069  * application. If the remote host has sent data to the application,
+00070  * this data is present in the uip_buf and the application read the
+00071  * data from there. It is up to the application to put this data into
+00072  * a byte stream if needed. The application will not be fed with data
+00073  * that is out of sequence.
+00074  *
+00075  * If the application whishes to send data to the peer, it should put
+00076  * its data into the uip_buf. The uip_appdata pointer points to the
+00077  * first available byte. The TCP/IP stack will calculate the
+00078  * checksums, and fill in the necessary header fields and finally send
+00079  * the packet back to the peer.
+00080 */
+00081 
+00082 #include "uip.h"
+00083 #include "uipopt.h"
+00084 #include "uip_arch.h"
+00085 
+00086 #if UIP_CONF_IPV6
+00087 #include "uip-neighbor.h"
+00088 #endif /* UIP_CONF_IPV6 */
+00089 
+00090 #include <string.h>
+00091 
+00092 /*---------------------------------------------------------------------------*/
+00093 /* Variable definitions. */
+00094 
+00095 
+00096 /* The IP address of this host. If it is defined to be fixed (by
+00097    setting UIP_FIXEDADDR to 1 in uipopt.h), the address is set
+00098    here. Otherwise, the address */
+00099 #if UIP_FIXEDADDR > 0
+00100 const uip_ipaddr_t uip_hostaddr =
+00101   {HTONS((UIP_IPADDR0 << 8) | UIP_IPADDR1),
+00102    HTONS((UIP_IPADDR2 << 8) | UIP_IPADDR3)};
+00103 const uip_ipaddr_t uip_draddr =
+00104   {HTONS((UIP_DRIPADDR0 << 8) | UIP_DRIPADDR1),
+00105    HTONS((UIP_DRIPADDR2 << 8) | UIP_DRIPADDR3)};
+00106 const uip_ipaddr_t uip_netmask =
+00107   {HTONS((UIP_NETMASK0 << 8) | UIP_NETMASK1),
+00108    HTONS((UIP_NETMASK2 << 8) | UIP_NETMASK3)};
+00109 #else
+00110 uip_ipaddr_t uip_hostaddr, uip_draddr, uip_netmask;
+00111 #endif /* UIP_FIXEDADDR */
+00112 
+00113 static const uip_ipaddr_t all_ones_addr =
+00114 #if UIP_CONF_IPV6
+00115   {0xffff,0xffff,0xffff,0xffff,0xffff,0xffff,0xffff,0xffff};
+00116 #else /* UIP_CONF_IPV6 */
+00117   {0xffff,0xffff};
+00118 #endif /* UIP_CONF_IPV6 */
+00119 static const uip_ipaddr_t all_zeroes_addr =
+00120 #if UIP_CONF_IPV6
+00121   {0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000};
+00122 #else /* UIP_CONF_IPV6 */
+00123   {0x0000,0x0000};
+00124 #endif /* UIP_CONF_IPV6 */
+00125 
+00126 
+00127 #if UIP_FIXEDETHADDR
+00128 const struct uip_eth_addr uip_ethaddr = {{UIP_ETHADDR0,
+00129                                           UIP_ETHADDR1,
+00130                                           UIP_ETHADDR2,
+00131                                           UIP_ETHADDR3,
+00132                                           UIP_ETHADDR4,
+00133                                           UIP_ETHADDR5}};
+00134 #else
+00135 struct uip_eth_addr uip_ethaddr = {{0,0,0,0,0,0}};
+00136 #endif
+00137 
+00138 #ifndef UIP_CONF_EXTERNAL_BUFFER
+00139 u8_t uip_buf[UIP_BUFSIZE + 2];   /* The packet buffer that contains
+00140                                     incoming packets. */
+00141 #endif /* UIP_CONF_EXTERNAL_BUFFER */
+00142 
+00143 void *uip_appdata;               /* The uip_appdata pointer points to
+00144                                     application data. */
+00145 void *uip_sappdata;              /* The uip_appdata pointer points to
+00146                                     the application data which is to
+00147                                     be sent. */
+00148 #if UIP_URGDATA > 0
+00149 void *uip_urgdata;               /* The uip_urgdata pointer points to
+00150                                     urgent data (out-of-band data), if
+00151                                     present. */
+00152 u16_t uip_urglen, uip_surglen;
+00153 #endif /* UIP_URGDATA > 0 */
+00154 
+00155 u16_t uip_len, uip_slen;
+00156                              /* The uip_len is either 8 or 16 bits,
+00157                                 depending on the maximum packet
+00158                                 size. */
+00159 
+00160 u8_t uip_flags;     /* The uip_flags variable is used for
+00161                                 communication between the TCP/IP stack
+00162                                 and the application program. */
+00163 struct uip_conn *uip_conn;   /* uip_conn always points to the current
+00164                                 connection. */
+00165 
+00166 struct uip_conn uip_conns[UIP_CONNS];
+00167                              /* The uip_conns array holds all TCP
+00168                                 connections. */
+00169 u16_t uip_listenports[UIP_LISTENPORTS];
+00170                              /* The uip_listenports list all currently
+00171                                 listning ports. */
+00172 #if UIP_UDP
+00173 struct uip_udp_conn *uip_udp_conn;
+00174 struct uip_udp_conn uip_udp_conns[UIP_UDP_CONNS];
+00175 #endif /* UIP_UDP */
+00176 
+00177 static u16_t ipid;           /* Ths ipid variable is an increasing
+00178                                 number that is used for the IP ID
+00179                                 field. */
+00180 
+00181 void uip_setipid(u16_t id) { ipid = id; }
+00182 
+00183 static u8_t iss[4];          /* The iss variable is used for the TCP
+00184                                 initial sequence number. */
+00185 
+00186 #if UIP_ACTIVE_OPEN
+00187 static u16_t lastport;       /* Keeps track of the last port used for
+00188                                 a new connection. */
+00189 #endif /* UIP_ACTIVE_OPEN */
+00190 
+00191 /* Temporary variables. */
+00192 u8_t uip_acc32[4];
+00193 static u8_t c, opt;
+00194 static u16_t tmp16;
+00195 
+00196 /* Structures and definitions. */
+00197 #define TCP_FIN 0x01
+00198 #define TCP_SYN 0x02
+00199 #define TCP_RST 0x04
+00200 #define TCP_PSH 0x08
+00201 #define TCP_ACK 0x10
+00202 #define TCP_URG 0x20
+00203 #define TCP_CTL 0x3f
+00204 
+00205 #define TCP_OPT_END     0   /* End of TCP options list */
+00206 #define TCP_OPT_NOOP    1   /* "No-operation" TCP option */
+00207 #define TCP_OPT_MSS     2   /* Maximum segment size TCP option */
+00208 
+00209 #define TCP_OPT_MSS_LEN 4   /* Length of TCP MSS option. */
+00210 
+00211 #define ICMP_ECHO_REPLY 0
+00212 #define ICMP_ECHO       8
+00213 
+00214 #define ICMP6_ECHO_REPLY             129
+00215 #define ICMP6_ECHO                   128
+00216 #define ICMP6_NEIGHBOR_SOLICITATION  135
+00217 #define ICMP6_NEIGHBOR_ADVERTISEMENT 136
+00218 
+00219 #define ICMP6_FLAG_S (1 << 6)
+00220 
+00221 #define ICMP6_OPTION_SOURCE_LINK_ADDRESS 1
+00222 #define ICMP6_OPTION_TARGET_LINK_ADDRESS 2
+00223 
+00224 
+00225 /* Macros. */
+00226 #define BUF ((struct uip_tcpip_hdr *)&uip_buf[UIP_LLH_LEN])
+00227 #define FBUF ((struct uip_tcpip_hdr *)&uip_reassbuf[0])
+00228 #define ICMPBUF ((struct uip_icmpip_hdr *)&uip_buf[UIP_LLH_LEN])
+00229 #define UDPBUF ((struct uip_udpip_hdr *)&uip_buf[UIP_LLH_LEN])
+00230 
+00231 
+00232 #if UIP_STATISTICS == 1
+00233 struct uip_stats uip_stat;
+00234 #define UIP_STAT(s) s
+00235 #else
+00236 #define UIP_STAT(s)
+00237 #endif /* UIP_STATISTICS == 1 */
+00238 
+00239 #if UIP_LOGGING == 1
+00240 #include <stdio.h>
+00241 void uip_log(char *msg);
+00242 #define UIP_LOG(m) uip_log(m)
+00243 #else
+00244 #define UIP_LOG(m)
+00245 #endif /* UIP_LOGGING == 1 */
+00246 
+00247 #if ! UIP_ARCH_ADD32
+00248 void
+00249 uip_add32(u8_t *op32, u16_t op16)
+00250 {
+00251   uip_acc32[3] = op32[3] + (op16 & 0xff);
+00252   uip_acc32[2] = op32[2] + (op16 >> 8);
+00253   uip_acc32[1] = op32[1];
+00254   uip_acc32[0] = op32[0];
+00255   
+00256   if(uip_acc32[2] < (op16 >> 8)) {
+00257     ++uip_acc32[1];
+00258     if(uip_acc32[1] == 0) {
+00259       ++uip_acc32[0];
+00260     }
+00261   }
+00262   
+00263   
+00264   if(uip_acc32[3] < (op16 & 0xff)) {
+00265     ++uip_acc32[2];
+00266     if(uip_acc32[2] == 0) {
+00267       ++uip_acc32[1];
+00268       if(uip_acc32[1] == 0) {
+00269         ++uip_acc32[0];
+00270       }
+00271     }
+00272   }
+00273 }
+00274 
+00275 #endif /* UIP_ARCH_ADD32 */
+00276 
+00277 #if ! UIP_ARCH_CHKSUM
+00278 /*---------------------------------------------------------------------------*/
+00279 static u16_t
+00280 chksum(u16_t sum, const u8_t *data, u16_t len)
+00281 {
+00282   u16_t t;
+00283   const u8_t *dataptr;
+00284   const u8_t *last_byte;
+00285 
+00286   dataptr = data;
+00287   last_byte = data + len - 1;
+00288   
+00289   while(dataptr < last_byte) {  /* At least two more bytes */
+00290     t = (dataptr[0] << 8) + dataptr[1];
+00291     sum += t;
+00292     if(sum < t) {
+00293       sum++;            /* carry */
+00294     }
+00295     dataptr += 2;
+00296   }
+00297   
+00298   if(dataptr == last_byte) {
+00299     t = (dataptr[0] << 8) + 0;
+00300     sum += t;
+00301     if(sum < t) {
+00302       sum++;            /* carry */
+00303     }
+00304   }
+00305 
+00306   /* Return sum in host byte order. */
+00307   return sum;
+00308 }
+00309 /*---------------------------------------------------------------------------*/
+00310 u16_t
+00311 uip_chksum(u16_t *data, u16_t len)
+00312 {
+00313   return htons(chksum(0, (u8_t *)data, len));
+00314 }
+00315 /*---------------------------------------------------------------------------*/
+00316 #ifndef UIP_ARCH_IPCHKSUM
+00317 u16_t
+00318 uip_ipchksum(void)
+00319 {
+00320   u16_t sum;
+00321 
+00322   sum = chksum(0, &uip_buf[UIP_LLH_LEN], UIP_IPH_LEN);
+00323   DEBUG_PRINTF("uip_ipchksum: sum 0x%04x\n", sum);
+00324   return (sum == 0) ? 0xffff : htons(sum);
+00325 }
+00326 #endif
+00327 /*---------------------------------------------------------------------------*/
+00328 static u16_t
+00329 upper_layer_chksum(u8_t proto)
+00330 {
+00331   u16_t upper_layer_len;
+00332   u16_t sum;
+00333   
+00334 #if UIP_CONF_IPV6
+00335   upper_layer_len = (((u16_t)(BUF->len[0]) << 8) + BUF->len[1]);
+00336 #else /* UIP_CONF_IPV6 */
+00337   upper_layer_len = (((u16_t)(BUF->len[0]) << 8) + BUF->len[1]) - UIP_IPH_LEN;
+00338 #endif /* UIP_CONF_IPV6 */
+00339   
+00340   /* First sum pseudoheader. */
+00341   
+00342   /* IP protocol and length fields. This addition cannot carry. */
+00343   sum = upper_layer_len + proto;
+00344   /* Sum IP source and destination addresses. */
+00345   sum = chksum(sum, (u8_t *)&BUF->srcipaddr[0], 2 * sizeof(uip_ipaddr_t));
+00346 
+00347   /* Sum TCP header and data. */
+00348   sum = chksum(sum, &uip_buf[UIP_IPH_LEN + UIP_LLH_LEN],
+00349                upper_layer_len);
+00350     
+00351   return (sum == 0) ? 0xffff : htons(sum);
+00352 }
+00353 /*---------------------------------------------------------------------------*/
+00354 #if UIP_CONF_IPV6
+00355 u16_t
+00356 uip_icmp6chksum(void)
+00357 {
+00358   return upper_layer_chksum(UIP_PROTO_ICMP6);
+00359   
+00360 }
+00361 #endif /* UIP_CONF_IPV6 */
+00362 /*---------------------------------------------------------------------------*/
+00363 u16_t
+00364 uip_tcpchksum(void)
+00365 {
+00366   return upper_layer_chksum(UIP_PROTO_TCP);
+00367 }
+00368 /*---------------------------------------------------------------------------*/
+00369 #if UIP_UDP_CHECKSUMS
+00370 u16_t
+00371 uip_udpchksum(void)
+00372 {
+00373   return upper_layer_chksum(UIP_PROTO_UDP);
+00374 }
+00375 #endif /* UIP_UDP_CHECKSUMS */
+00376 #endif /* UIP_ARCH_CHKSUM */
+00377 /*---------------------------------------------------------------------------*/
+00378 void
+00379 uip_init(void)
+00380 {
+00381   for(c = 0; c < UIP_LISTENPORTS; ++c) {
+00382     uip_listenports[c] = 0;
+00383   }
+00384   for(c = 0; c < UIP_CONNS; ++c) {
+00385     uip_conns[c].tcpstateflags = UIP_CLOSED;
+00386   }
+00387 #if UIP_ACTIVE_OPEN
+00388   lastport = 1024;
+00389 #endif /* UIP_ACTIVE_OPEN */
+00390 
+00391 #if UIP_UDP
+00392   for(c = 0; c < UIP_UDP_CONNS; ++c) {
+00393     uip_udp_conns[c].lport = 0;
+00394   }
+00395 #endif /* UIP_UDP */
+00396   
+00397 
+00398   /* IPv4 initialization. */
+00399 #if UIP_FIXEDADDR == 0
+00400   /*  uip_hostaddr[0] = uip_hostaddr[1] = 0;*/
+00401 #endif /* UIP_FIXEDADDR */
+00402 
+00403 }
+00404 /*---------------------------------------------------------------------------*/
+00405 #if UIP_ACTIVE_OPEN
+00406 struct uip_conn *
+00407 uip_connect(uip_ipaddr_t *ripaddr, u16_t rport)
+00408 {
+00409   register struct uip_conn *conn, *cconn;
+00410   
+00411   /* Find an unused local port. */
+00412  again:
+00413   ++lastport;
+00414 
+00415   if(lastport >= 32000) {
+00416     lastport = 4096;
+00417   }
+00418 
+00419   /* Check if this port is already in use, and if so try to find
+00420      another one. */
+00421   for(c = 0; c < UIP_CONNS; ++c) {
+00422     conn = &uip_conns[c];
+00423     if(conn->tcpstateflags != UIP_CLOSED &&
+00424        conn->lport == htons(lastport)) {
+00425       goto again;
+00426     }
+00427   }
+00428 
+00429   conn = 0;
+00430   for(c = 0; c < UIP_CONNS; ++c) {
+00431     cconn = &uip_conns[c];
+00432     if(cconn->tcpstateflags == UIP_CLOSED) {
+00433       conn = cconn;
+00434       break;
+00435     }
+00436     if(cconn->tcpstateflags == UIP_TIME_WAIT) {
+00437       if(conn == 0 ||
+00438          cconn->timer > conn->timer) {
+00439         conn = cconn;
+00440       }
+00441     }
+00442   }
+00443 
+00444   if(conn == 0) {
+00445     return 0;
+00446   }
+00447   
+00448   conn->tcpstateflags = UIP_SYN_SENT;
+00449 
+00450   conn->snd_nxt[0] = iss[0];
+00451   conn->snd_nxt[1] = iss[1];
+00452   conn->snd_nxt[2] = iss[2];
+00453   conn->snd_nxt[3] = iss[3];
+00454 
+00455   conn->initialmss = conn->mss = UIP_TCP_MSS;
+00456   
+00457   conn->len = 1;   /* TCP length of the SYN is one. */
+00458   conn->nrtx = 0;
+00459   conn->timer = 1; /* Send the SYN next time around. */
+00460   conn->rto = UIP_RTO;
+00461   conn->sa = 0;
+00462   conn->sv = 16;   /* Initial value of the RTT variance. */
+00463   conn->lport = htons(lastport);
+00464   conn->rport = rport;
+00465   uip_ipaddr_copy(&conn->ripaddr, ripaddr);
+00466   
+00467   return conn;
+00468 }
+00469 #endif /* UIP_ACTIVE_OPEN */
+00470 /*---------------------------------------------------------------------------*/
+00471 #if UIP_UDP
+00472 struct uip_udp_conn *
+00473 uip_udp_new(uip_ipaddr_t *ripaddr, u16_t rport)
+00474 {
+00475   register struct uip_udp_conn *conn;
+00476   
+00477   /* Find an unused local port. */
+00478  again:
+00479   ++lastport;
+00480 
+00481   if(lastport >= 32000) {
+00482     lastport = 4096;
+00483   }
+00484   
+00485   for(c = 0; c < UIP_UDP_CONNS; ++c) {
+00486     if(uip_udp_conns[c].lport == htons(lastport)) {
+00487       goto again;
+00488     }
+00489   }
+00490 
+00491 
+00492   conn = 0;
+00493   for(c = 0; c < UIP_UDP_CONNS; ++c) {
+00494     if(uip_udp_conns[c].lport == 0) {
+00495       conn = &uip_udp_conns[c];
+00496       break;
+00497     }
+00498   }
+00499 
+00500   if(conn == 0) {
+00501     return 0;
+00502   }
+00503   
+00504   conn->lport = HTONS(lastport);
+00505   conn->rport = rport;
+00506   if(ripaddr == NULL) {
+00507     memset(conn->ripaddr, 0, sizeof(uip_ipaddr_t));
+00508   } else {
+00509     uip_ipaddr_copy(&conn->ripaddr, ripaddr);
+00510   }
+00511   conn->ttl = UIP_TTL;
+00512   
+00513   return conn;
+00514 }
+00515 #endif /* UIP_UDP */
+00516 /*---------------------------------------------------------------------------*/
+00517 void
+00518 uip_unlisten(u16_t port)
+00519 {
+00520   for(c = 0; c < UIP_LISTENPORTS; ++c) {
+00521     if(uip_listenports[c] == port) {
+00522       uip_listenports[c] = 0;
+00523       return;
+00524     }
+00525   }
+00526 }
+00527 /*---------------------------------------------------------------------------*/
+00528 void
+00529 uip_listen(u16_t port)
+00530 {
+00531   for(c = 0; c < UIP_LISTENPORTS; ++c) {
+00532     if(uip_listenports[c] == 0) {
+00533       uip_listenports[c] = port;
+00534       return;
+00535     }
+00536   }
+00537 }
+00538 /*---------------------------------------------------------------------------*/
+00539 /* XXX: IP fragment reassembly: not well-tested. */
+00540 
+00541 #if UIP_REASSEMBLY && !UIP_CONF_IPV6
+00542 #define UIP_REASS_BUFSIZE (UIP_BUFSIZE - UIP_LLH_LEN)
+00543 static u8_t uip_reassbuf[UIP_REASS_BUFSIZE];
+00544 static u8_t uip_reassbitmap[UIP_REASS_BUFSIZE / (8 * 8)];
+00545 static const u8_t bitmap_bits[8] = {0xff, 0x7f, 0x3f, 0x1f,
+00546                                     0x0f, 0x07, 0x03, 0x01};
+00547 static u16_t uip_reasslen;
+00548 static u8_t uip_reassflags;
+00549 #define UIP_REASS_FLAG_LASTFRAG 0x01
+00550 static u8_t uip_reasstmr;
+00551 
+00552 #define IP_MF   0x20
+00553 
+00554 static u8_t
+00555 uip_reass(void)
+00556 {
+00557   u16_t offset, len;
+00558   u16_t i;
+00559 
+00560   /* If ip_reasstmr is zero, no packet is present in the buffer, so we
+00561      write the IP header of the fragment into the reassembly
+00562      buffer. The timer is updated with the maximum age. */
+00563   if(uip_reasstmr == 0) {
+00564     memcpy(uip_reassbuf, &BUF->vhl, UIP_IPH_LEN);
+00565     uip_reasstmr = UIP_REASS_MAXAGE;
+00566     uip_reassflags = 0;
+00567     /* Clear the bitmap. */
+00568     memset(uip_reassbitmap, 0, sizeof(uip_reassbitmap));
+00569   }
+00570 
+00571   /* Check if the incoming fragment matches the one currently present
+00572      in the reasembly buffer. If so, we proceed with copying the
+00573      fragment into the buffer. */
+00574   if(BUF->srcipaddr[0] == FBUF->srcipaddr[0] &&
+00575      BUF->srcipaddr[1] == FBUF->srcipaddr[1] &&
+00576      BUF->destipaddr[0] == FBUF->destipaddr[0] &&
+00577      BUF->destipaddr[1] == FBUF->destipaddr[1] &&
+00578      BUF->ipid[0] == FBUF->ipid[0] &&
+00579      BUF->ipid[1] == FBUF->ipid[1]) {
+00580 
+00581     len = (BUF->len[0] << 8) + BUF->len[1] - (BUF->vhl & 0x0f) * 4;
+00582     offset = (((BUF->ipoffset[0] & 0x3f) << 8) + BUF->ipoffset[1]) * 8;
+00583 
+00584     /* If the offset or the offset + fragment length overflows the
+00585        reassembly buffer, we discard the entire packet. */
+00586     if(offset > UIP_REASS_BUFSIZE ||
+00587        offset + len > UIP_REASS_BUFSIZE) {
+00588       uip_reasstmr = 0;
+00589       goto nullreturn;
+00590     }
+00591 
+00592     /* Copy the fragment into the reassembly buffer, at the right
+00593        offset. */
+00594     memcpy(&uip_reassbuf[UIP_IPH_LEN + offset],
+00595            (char *)BUF + (int)((BUF->vhl & 0x0f) * 4),
+00596            len);
+00597       
+00598     /* Update the bitmap. */
+00599     if(offset / (8 * 8) == (offset + len) / (8 * 8)) {
+00600       /* If the two endpoints are in the same byte, we only update
+00601          that byte. */
+00602              
+00603       uip_reassbitmap[offset / (8 * 8)] |=
+00604              bitmap_bits[(offset / 8 ) & 7] &
+00605              ~bitmap_bits[((offset + len) / 8 ) & 7];
+00606     } else {
+00607       /* If the two endpoints are in different bytes, we update the
+00608          bytes in the endpoints and fill the stuff inbetween with
+00609          0xff. */
+00610       uip_reassbitmap[offset / (8 * 8)] |=
+00611         bitmap_bits[(offset / 8 ) & 7];
+00612       for(i = 1 + offset / (8 * 8); i < (offset + len) / (8 * 8); ++i) {
+00613         uip_reassbitmap[i] = 0xff;
+00614       }
+00615       uip_reassbitmap[(offset + len) / (8 * 8)] |=
+00616         ~bitmap_bits[((offset + len) / 8 ) & 7];
+00617     }
+00618     
+00619     /* If this fragment has the More Fragments flag set to zero, we
+00620        know that this is the last fragment, so we can calculate the
+00621        size of the entire packet. We also set the
+00622        IP_REASS_FLAG_LASTFRAG flag to indicate that we have received
+00623        the final fragment. */
+00624 
+00625     if((BUF->ipoffset[0] & IP_MF) == 0) {
+00626       uip_reassflags |= UIP_REASS_FLAG_LASTFRAG;
+00627       uip_reasslen = offset + len;
+00628     }
+00629     
+00630     /* Finally, we check if we have a full packet in the buffer. We do
+00631        this by checking if we have the last fragment and if all bits
+00632        in the bitmap are set. */
+00633     if(uip_reassflags & UIP_REASS_FLAG_LASTFRAG) {
+00634       /* Check all bytes up to and including all but the last byte in
+00635          the bitmap. */
+00636       for(i = 0; i < uip_reasslen / (8 * 8) - 1; ++i) {
+00637         if(uip_reassbitmap[i] != 0xff) {
+00638           goto nullreturn;
+00639         }
+00640       }
+00641       /* Check the last byte in the bitmap. It should contain just the
+00642          right amount of bits. */
+00643       if(uip_reassbitmap[uip_reasslen / (8 * 8)] !=
+00644          (u8_t)~bitmap_bits[uip_reasslen / 8 & 7]) {
+00645         goto nullreturn;
+00646       }
+00647 
+00648       /* If we have come this far, we have a full packet in the
+00649          buffer, so we allocate a pbuf and copy the packet into it. We
+00650          also reset the timer. */
+00651       uip_reasstmr = 0;
+00652       memcpy(BUF, FBUF, uip_reasslen);
+00653 
+00654       /* Pretend to be a "normal" (i.e., not fragmented) IP packet
+00655          from now on. */
+00656       BUF->ipoffset[0] = BUF->ipoffset[1] = 0;
+00657       BUF->len[0] = uip_reasslen >> 8;
+00658       BUF->len[1] = uip_reasslen & 0xff;
+00659       BUF->ipchksum = 0;
+00660       BUF->ipchksum = ~(uip_ipchksum());
+00661 
+00662       return uip_reasslen;
+00663     }
+00664   }
+00665 
+00666  nullreturn:
+00667   return 0;
+00668 }
+00669 #endif /* UIP_REASSEMBLY */
+00670 /*---------------------------------------------------------------------------*/
+00671 static void
+00672 uip_add_rcv_nxt(u16_t n)
+00673 {
+00674   uip_add32(uip_conn->rcv_nxt, n);
+00675   uip_conn->rcv_nxt[0] = uip_acc32[0];
+00676   uip_conn->rcv_nxt[1] = uip_acc32[1];
+00677   uip_conn->rcv_nxt[2] = uip_acc32[2];
+00678   uip_conn->rcv_nxt[3] = uip_acc32[3];
+00679 }
+00680 /*---------------------------------------------------------------------------*/
+00681 void
+00682 uip_process(u8_t flag)
+00683 {
+00684   register struct uip_conn *uip_connr = uip_conn;
+00685 
+00686 #if UIP_UDP
+00687   if(flag == UIP_UDP_SEND_CONN) {
+00688     goto udp_send;
+00689   }
+00690 #endif /* UIP_UDP */
+00691   
+00692   uip_sappdata = uip_appdata = &uip_buf[UIP_IPTCPH_LEN + UIP_LLH_LEN];
+00693 
+00694   /* Check if we were invoked because of a poll request for a
+00695      particular connection. */
+00696   if(flag == UIP_POLL_REQUEST) {
+00697     if((uip_connr->tcpstateflags & UIP_TS_MASK) == UIP_ESTABLISHED &&
+00698        !uip_outstanding(uip_connr)) {
+00699         uip_flags = UIP_POLL;
+00700         UIP_APPCALL();
+00701         goto appsend;
+00702     }
+00703     goto drop;
+00704     
+00705     /* Check if we were invoked because of the perodic timer fireing. */
+00706   } else if(flag == UIP_TIMER) {
+00707 #if UIP_REASSEMBLY
+00708     if(uip_reasstmr != 0) {
+00709       --uip_reasstmr;
+00710     }
+00711 #endif /* UIP_REASSEMBLY */
+00712     /* Increase the initial sequence number. */
+00713     if(++iss[3] == 0) {
+00714       if(++iss[2] == 0) {
+00715         if(++iss[1] == 0) {
+00716           ++iss[0];
+00717         }
+00718       }
+00719     }
+00720 
+00721     /* Reset the length variables. */
+00722     uip_len = 0;
+00723     uip_slen = 0;
+00724 
+00725     /* Check if the connection is in a state in which we simply wait
+00726        for the connection to time out. If so, we increase the
+00727        connection's timer and remove the connection if it times
+00728        out. */
+00729     if(uip_connr->tcpstateflags == UIP_TIME_WAIT ||
+00730        uip_connr->tcpstateflags == UIP_FIN_WAIT_2) {
+00731       ++(uip_connr->timer);
+00732       if(uip_connr->timer == UIP_TIME_WAIT_TIMEOUT) {
+00733         uip_connr->tcpstateflags = UIP_CLOSED;
+00734       }
+00735     } else if(uip_connr->tcpstateflags != UIP_CLOSED) {
+00736       /* If the connection has outstanding data, we increase the
+00737          connection's timer and see if it has reached the RTO value
+00738          in which case we retransmit. */
+00739       if(uip_outstanding(uip_connr)) {
+00740         if(uip_connr->timer-- == 0) {
+00741           if(uip_connr->nrtx == UIP_MAXRTX ||
+00742              ((uip_connr->tcpstateflags == UIP_SYN_SENT ||
+00743                uip_connr->tcpstateflags == UIP_SYN_RCVD) &&
+00744               uip_connr->nrtx == UIP_MAXSYNRTX)) {
+00745             uip_connr->tcpstateflags = UIP_CLOSED;
+00746 
+00747             /* We call UIP_APPCALL() with uip_flags set to
+00748                UIP_TIMEDOUT to inform the application that the
+00749                connection has timed out. */
+00750             uip_flags = UIP_TIMEDOUT;
+00751             UIP_APPCALL();
+00752 
+00753             /* We also send a reset packet to the remote host. */
+00754             BUF->flags = TCP_RST | TCP_ACK;
+00755             goto tcp_send_nodata;
+00756           }
+00757 
+00758           /* Exponential backoff. */
+00759           uip_connr->timer = UIP_RTO << (uip_connr->nrtx > 4?
+00760                                          4:
+00761                                          uip_connr->nrtx);
+00762           ++(uip_connr->nrtx);
+00763           
+00764           /* Ok, so we need to retransmit. We do this differently
+00765              depending on which state we are in. In ESTABLISHED, we
+00766              call upon the application so that it may prepare the
+00767              data for the retransmit. In SYN_RCVD, we resend the
+00768              SYNACK that we sent earlier and in LAST_ACK we have to
+00769              retransmit our FINACK. */
+00770           UIP_STAT(++uip_stat.tcp.rexmit);
+00771           switch(uip_connr->tcpstateflags & UIP_TS_MASK) {
+00772           case UIP_SYN_RCVD:
+00773             /* In the SYN_RCVD state, we should retransmit our
+00774                SYNACK. */
+00775             goto tcp_send_synack;
+00776             
+00777 #if UIP_ACTIVE_OPEN
+00778           case UIP_SYN_SENT:
+00779             /* In the SYN_SENT state, we retransmit out SYN. */
+00780             BUF->flags = 0;
+00781             goto tcp_send_syn;
+00782 #endif /* UIP_ACTIVE_OPEN */
+00783             
+00784           case UIP_ESTABLISHED:
+00785             /* In the ESTABLISHED state, we call upon the application
+00786                to do the actual retransmit after which we jump into
+00787                the code for sending out the packet (the apprexmit
+00788                label). */
+00789             uip_flags = UIP_REXMIT;
+00790             UIP_APPCALL();
+00791             goto apprexmit;
+00792             
+00793           case UIP_FIN_WAIT_1:
+00794           case UIP_CLOSING:
+00795           case UIP_LAST_ACK:
+00796             /* In all these states we should retransmit a FINACK. */
+00797             goto tcp_send_finack;
+00798             
+00799           }
+00800         }
+00801       } else if((uip_connr->tcpstateflags & UIP_TS_MASK) == UIP_ESTABLISHED) {
+00802         /* If there was no need for a retransmission, we poll the
+00803            application for new data. */
+00804         uip_flags = UIP_POLL;
+00805         UIP_APPCALL();
+00806         goto appsend;
+00807       }
+00808     }
+00809     goto drop;
+00810   }
+00811 #if UIP_UDP
+00812   if(flag == UIP_UDP_TIMER) {
+00813     if(uip_udp_conn->lport != 0) {
+00814       uip_conn = NULL;
+00815       uip_sappdata = uip_appdata = &uip_buf[UIP_LLH_LEN + UIP_IPUDPH_LEN];
+00816       uip_len = uip_slen = 0;
+00817       uip_flags = UIP_POLL;
+00818       UIP_UDP_APPCALL();
+00819       goto udp_send;
+00820     } else {
+00821       goto drop;
+00822     }
+00823   }
+00824 #endif
+00825 
+00826   /* This is where the input processing starts. */
+00827   UIP_STAT(++uip_stat.ip.recv);
+00828 
+00829   /* Start of IP input header processing code. */
+00830   
+00831 #if UIP_CONF_IPV6
+00832   /* Check validity of the IP header. */
+00833   if((BUF->vtc & 0xf0) != 0x60)  { /* IP version and header length. */
+00834     UIP_STAT(++uip_stat.ip.drop);
+00835     UIP_STAT(++uip_stat.ip.vhlerr);
+00836     UIP_LOG("ipv6: invalid version.");
+00837     goto drop;
+00838   }
+00839 #else /* UIP_CONF_IPV6 */
+00840   /* Check validity of the IP header. */
+00841   if(BUF->vhl != 0x45)  { /* IP version and header length. */
+00842     UIP_STAT(++uip_stat.ip.drop);
+00843     UIP_STAT(++uip_stat.ip.vhlerr);
+00844     UIP_LOG("ip: invalid version or header length.");
+00845     goto drop;
+00846   }
+00847 #endif /* UIP_CONF_IPV6 */
+00848   
+00849   /* Check the size of the packet. If the size reported to us in
+00850      uip_len is smaller the size reported in the IP header, we assume
+00851      that the packet has been corrupted in transit. If the size of
+00852      uip_len is larger than the size reported in the IP packet header,
+00853      the packet has been padded and we set uip_len to the correct
+00854      value.. */
+00855 
+00856   if((BUF->len[0] << 8) + BUF->len[1] <= uip_len) {
+00857     uip_len = (BUF->len[0] << 8) + BUF->len[1];
+00858 #if UIP_CONF_IPV6
+00859     uip_len += 40; /* The length reported in the IPv6 header is the
+00860                       length of the payload that follows the
+00861                       header. However, uIP uses the uip_len variable
+00862                       for holding the size of the entire packet,
+00863                       including the IP header. For IPv4 this is not a
+00864                       problem as the length field in the IPv4 header
+00865                       contains the length of the entire packet. But
+00866                       for IPv6 we need to add the size of the IPv6
+00867                       header (40 bytes). */
+00868 #endif /* UIP_CONF_IPV6 */
+00869   } else {
+00870     UIP_LOG("ip: packet shorter than reported in IP header.");
+00871     goto drop;
+00872   }
+00873 
+00874 #if !UIP_CONF_IPV6
+00875   /* Check the fragment flag. */
+00876   if((BUF->ipoffset[0] & 0x3f) != 0 ||
+00877      BUF->ipoffset[1] != 0) {
+00878 #if UIP_REASSEMBLY
+00879     uip_len = uip_reass();
+00880     if(uip_len == 0) {
+00881       goto drop;
+00882     }
+00883 #else /* UIP_REASSEMBLY */
+00884     UIP_STAT(++uip_stat.ip.drop);
+00885     UIP_STAT(++uip_stat.ip.fragerr);
+00886     UIP_LOG("ip: fragment dropped.");
+00887     goto drop;
+00888 #endif /* UIP_REASSEMBLY */
+00889   }
+00890 #endif /* UIP_CONF_IPV6 */
+00891 
+00892   if(uip_ipaddr_cmp(uip_hostaddr, all_zeroes_addr)) {
+00893     /* If we are configured to use ping IP address configuration and
+00894        hasn't been assigned an IP address yet, we accept all ICMP
+00895        packets. */
+00896 #if UIP_PINGADDRCONF && !UIP_CONF_IPV6
+00897     if(BUF->proto == UIP_PROTO_ICMP) {
+00898       UIP_LOG("ip: possible ping config packet received.");
+00899       goto icmp_input;
+00900     } else {
+00901       UIP_LOG("ip: packet dropped since no address assigned.");
+00902       goto drop;
+00903     }
+00904 #endif /* UIP_PINGADDRCONF */
+00905 
+00906   } else {
+00907     /* If IP broadcast support is configured, we check for a broadcast
+00908        UDP packet, which may be destined to us. */
+00909 #if UIP_BROADCAST
+00910     DEBUG_PRINTF("UDP IP checksum 0x%04x\n", uip_ipchksum());
+00911     if(BUF->proto == UIP_PROTO_UDP &&
+00912        uip_ipaddr_cmp(BUF->destipaddr, all_ones_addr)
+00913        /*&&
+00914          uip_ipchksum() == 0xffff*/) {
+00915       goto udp_input;
+00916     }
+00917 #endif /* UIP_BROADCAST */
+00918     
+00919     /* Check if the packet is destined for our IP address. */
+00920 #if !UIP_CONF_IPV6
+00921     if(!uip_ipaddr_cmp(BUF->destipaddr, uip_hostaddr)) {
+00922       UIP_STAT(++uip_stat.ip.drop);
+00923       goto drop;
+00924     }
+00925 #else /* UIP_CONF_IPV6 */
+00926     /* For IPv6, packet reception is a little trickier as we need to
+00927        make sure that we listen to certain multicast addresses (all
+00928        hosts multicast address, and the solicited-node multicast
+00929        address) as well. However, we will cheat here and accept all
+00930        multicast packets that are sent to the ff02::/16 addresses. */
+00931     if(!uip_ipaddr_cmp(BUF->destipaddr, uip_hostaddr) &&
+00932        BUF->destipaddr[0] != HTONS(0xff02)) {
+00933       UIP_STAT(++uip_stat.ip.drop);
+00934       goto drop;
+00935     }
+00936 #endif /* UIP_CONF_IPV6 */
+00937   }
+00938 
+00939 #if !UIP_CONF_IPV6
+00940   if(uip_ipchksum() != 0xffff) { /* Compute and check the IP header
+00941                                     checksum. */
+00942     UIP_STAT(++uip_stat.ip.drop);
+00943     UIP_STAT(++uip_stat.ip.chkerr);
+00944     UIP_LOG("ip: bad checksum.");
+00945     goto drop;
+00946   }
+00947 #endif /* UIP_CONF_IPV6 */
+00948 
+00949   if(BUF->proto == UIP_PROTO_TCP) { /* Check for TCP packet. If so,
+00950                                        proceed with TCP input
+00951                                        processing. */
+00952     goto tcp_input;
+00953   }
+00954 
+00955 #if UIP_UDP
+00956   if(BUF->proto == UIP_PROTO_UDP) {
+00957     goto udp_input;
+00958   }
+00959 #endif /* UIP_UDP */
+00960 
+00961 #if !UIP_CONF_IPV6
+00962   /* ICMPv4 processing code follows. */
+00963   if(BUF->proto != UIP_PROTO_ICMP) { /* We only allow ICMP packets from
+00964                                         here. */
+00965     UIP_STAT(++uip_stat.ip.drop);
+00966     UIP_STAT(++uip_stat.ip.protoerr);
+00967     UIP_LOG("ip: neither tcp nor icmp.");
+00968     goto drop;
+00969   }
+00970 
+00971 #if UIP_PINGADDRCONF
+00972  icmp_input:
+00973 #endif /* UIP_PINGADDRCONF */
+00974   UIP_STAT(++uip_stat.icmp.recv);
+00975 
+00976   /* ICMP echo (i.e., ping) processing. This is simple, we only change
+00977      the ICMP type from ECHO to ECHO_REPLY and adjust the ICMP
+00978      checksum before we return the packet. */
+00979   if(ICMPBUF->type != ICMP_ECHO) {
+00980     UIP_STAT(++uip_stat.icmp.drop);
+00981     UIP_STAT(++uip_stat.icmp.typeerr);
+00982     UIP_LOG("icmp: not icmp echo.");
+00983     goto drop;
+00984   }
+00985 
+00986   /* If we are configured to use ping IP address assignment, we use
+00987      the destination IP address of this ping packet and assign it to
+00988      ourself. */
+00989 #if UIP_PINGADDRCONF
+00990   if((uip_hostaddr[0] | uip_hostaddr[1]) == 0) {
+00991     uip_hostaddr[0] = BUF->destipaddr[0];
+00992     uip_hostaddr[1] = BUF->destipaddr[1];
+00993   }
+00994 #endif /* UIP_PINGADDRCONF */
+00995 
+00996   ICMPBUF->type = ICMP_ECHO_REPLY;
+00997 
+00998   if(ICMPBUF->icmpchksum >= HTONS(0xffff - (ICMP_ECHO << 8))) {
+00999     ICMPBUF->icmpchksum += HTONS(ICMP_ECHO << 8) + 1;
+01000   } else {
+01001     ICMPBUF->icmpchksum += HTONS(ICMP_ECHO << 8);
+01002   }
+01003 
+01004   /* Swap IP addresses. */
+01005   uip_ipaddr_copy(BUF->destipaddr, BUF->srcipaddr);
+01006   uip_ipaddr_copy(BUF->srcipaddr, uip_hostaddr);
+01007 
+01008   UIP_STAT(++uip_stat.icmp.sent);
+01009   goto send;
+01010 
+01011   /* End of IPv4 input header processing code. */
+01012 #else /* !UIP_CONF_IPV6 */
+01013 
+01014   /* This is IPv6 ICMPv6 processing code. */
+01015   DEBUG_PRINTF("icmp6_input: length %d\n", uip_len);
+01016 
+01017   if(BUF->proto != UIP_PROTO_ICMP6) { /* We only allow ICMPv6 packets from
+01018                                          here. */
+01019     UIP_STAT(++uip_stat.ip.drop);
+01020     UIP_STAT(++uip_stat.ip.protoerr);
+01021     UIP_LOG("ip: neither tcp nor icmp6.");
+01022     goto drop;
+01023   }
+01024 
+01025   UIP_STAT(++uip_stat.icmp.recv);
+01026 
+01027   /* If we get a neighbor solicitation for our address we should send
+01028      a neighbor advertisement message back. */
+01029   if(ICMPBUF->type == ICMP6_NEIGHBOR_SOLICITATION) {
+01030     if(uip_ipaddr_cmp(ICMPBUF->icmp6data, uip_hostaddr)) {
+01031 
+01032       if(ICMPBUF->options[0] == ICMP6_OPTION_SOURCE_LINK_ADDRESS) {
+01033         /* Save the sender's address in our neighbor list. */
+01034         uip_neighbor_add(ICMPBUF->srcipaddr, &(ICMPBUF->options[2]));
+01035       }
+01036       
+01037       /* We should now send a neighbor advertisement back to where the
+01038          neighbor solicication came from. */
+01039       ICMPBUF->type = ICMP6_NEIGHBOR_ADVERTISEMENT;
+01040       ICMPBUF->flags = ICMP6_FLAG_S; /* Solicited flag. */
+01041       
+01042       ICMPBUF->reserved1 = ICMPBUF->reserved2 = ICMPBUF->reserved3 = 0;
+01043       
+01044       uip_ipaddr_copy(ICMPBUF->destipaddr, ICMPBUF->srcipaddr);
+01045       uip_ipaddr_copy(ICMPBUF->srcipaddr, uip_hostaddr);
+01046       ICMPBUF->options[0] = ICMP6_OPTION_TARGET_LINK_ADDRESS;
+01047       ICMPBUF->options[1] = 1;  /* Options length, 1 = 8 bytes. */
+01048       memcpy(&(ICMPBUF->options[2]), &uip_ethaddr, sizeof(uip_ethaddr));
+01049       ICMPBUF->icmpchksum = 0;
+01050       ICMPBUF->icmpchksum = ~uip_icmp6chksum();
+01051       goto send;
+01052       
+01053     }
+01054     goto drop;
+01055   } else if(ICMPBUF->type == ICMP6_ECHO) {
+01056     /* ICMP echo (i.e., ping) processing. This is simple, we only
+01057        change the ICMP type from ECHO to ECHO_REPLY and update the
+01058        ICMP checksum before we return the packet. */
+01059 
+01060     ICMPBUF->type = ICMP6_ECHO_REPLY;
+01061     
+01062     uip_ipaddr_copy(BUF->destipaddr, BUF->srcipaddr);
+01063     uip_ipaddr_copy(BUF->srcipaddr, uip_hostaddr);
+01064     ICMPBUF->icmpchksum = 0;
+01065     ICMPBUF->icmpchksum = ~uip_icmp6chksum();
+01066     
+01067     UIP_STAT(++uip_stat.icmp.sent);
+01068     goto send;
+01069   } else {
+01070     DEBUG_PRINTF("Unknown icmp6 message type %d\n", ICMPBUF->type);
+01071     UIP_STAT(++uip_stat.icmp.drop);
+01072     UIP_STAT(++uip_stat.icmp.typeerr);
+01073     UIP_LOG("icmp: unknown ICMP message.");
+01074     goto drop;
+01075   }
+01076 
+01077   /* End of IPv6 ICMP processing. */
+01078   
+01079 #endif /* !UIP_CONF_IPV6 */
+01080 
+01081 #if UIP_UDP
+01082   /* UDP input processing. */
+01083  udp_input:
+01084   /* UDP processing is really just a hack. We don't do anything to the
+01085      UDP/IP headers, but let the UDP application do all the hard
+01086      work. If the application sets uip_slen, it has a packet to
+01087      send. */
+01088 #if UIP_UDP_CHECKSUMS
+01089   uip_len = uip_len - UIP_IPUDPH_LEN;
+01090   uip_appdata = &uip_buf[UIP_LLH_LEN + UIP_IPUDPH_LEN];
+01091   if(UDPBUF->udpchksum != 0 && uip_udpchksum() != 0xffff) {
+01092     UIP_STAT(++uip_stat.udp.drop);
+01093     UIP_STAT(++uip_stat.udp.chkerr);
+01094     UIP_LOG("udp: bad checksum.");
+01095     goto drop;
+01096   }
+01097 #else /* UIP_UDP_CHECKSUMS */
+01098   uip_len = uip_len - UIP_IPUDPH_LEN;
+01099 #endif /* UIP_UDP_CHECKSUMS */
+01100 
+01101   /* Demultiplex this UDP packet between the UDP "connections". */
+01102   for(uip_udp_conn = &uip_udp_conns[0];
+01103       uip_udp_conn < &uip_udp_conns[UIP_UDP_CONNS];
+01104       ++uip_udp_conn) {
+01105     /* If the local UDP port is non-zero, the connection is considered
+01106        to be used. If so, the local port number is checked against the
+01107        destination port number in the received packet. If the two port
+01108        numbers match, the remote port number is checked if the
+01109        connection is bound to a remote port. Finally, if the
+01110        connection is bound to a remote IP address, the source IP
+01111        address of the packet is checked. */
+01112     if(uip_udp_conn->lport != 0 &&
+01113        UDPBUF->destport == uip_udp_conn->lport &&
+01114        (uip_udp_conn->rport == 0 ||
+01115         UDPBUF->srcport == uip_udp_conn->rport) &&
+01116        (uip_ipaddr_cmp(uip_udp_conn->ripaddr, all_zeroes_addr) ||
+01117         uip_ipaddr_cmp(uip_udp_conn->ripaddr, all_ones_addr) ||
+01118         uip_ipaddr_cmp(BUF->srcipaddr, uip_udp_conn->ripaddr))) {
+01119       goto udp_found;
+01120     }
+01121   }
+01122   UIP_LOG("udp: no matching connection found");
+01123   goto drop;
+01124   
+01125  udp_found:
+01126   uip_conn = NULL;
+01127   uip_flags = UIP_NEWDATA;
+01128   uip_sappdata = uip_appdata = &uip_buf[UIP_LLH_LEN + UIP_IPUDPH_LEN];
+01129   uip_slen = 0;
+01130   UIP_UDP_APPCALL();
+01131  udp_send:
+01132   if(uip_slen == 0) {
+01133     goto drop;
+01134   }
+01135   uip_len = uip_slen + UIP_IPUDPH_LEN;
+01136 
+01137 #if UIP_CONF_IPV6
+01138   /* For IPv6, the IP length field does not include the IPv6 IP header
+01139      length. */
+01140   BUF->len[0] = ((uip_len - UIP_IPH_LEN) >> 8);
+01141   BUF->len[1] = ((uip_len - UIP_IPH_LEN) & 0xff);
+01142 #else /* UIP_CONF_IPV6 */
+01143   BUF->len[0] = (uip_len >> 8);
+01144   BUF->len[1] = (uip_len & 0xff);
+01145 #endif /* UIP_CONF_IPV6 */
+01146 
+01147   BUF->ttl = uip_udp_conn->ttl;
+01148   BUF->proto = UIP_PROTO_UDP;
+01149 
+01150   UDPBUF->udplen = HTONS(uip_slen + UIP_UDPH_LEN);
+01151   UDPBUF->udpchksum = 0;
+01152 
+01153   BUF->srcport  = uip_udp_conn->lport;
+01154   BUF->destport = uip_udp_conn->rport;
+01155 
+01156   uip_ipaddr_copy(BUF->srcipaddr, uip_hostaddr);
+01157   uip_ipaddr_copy(BUF->destipaddr, uip_udp_conn->ripaddr);
+01158    
+01159   uip_appdata = &uip_buf[UIP_LLH_LEN + UIP_IPTCPH_LEN];
+01160 
+01161 #if UIP_UDP_CHECKSUMS
+01162   /* Calculate UDP checksum. */
+01163   UDPBUF->udpchksum = ~(uip_udpchksum());
+01164   if(UDPBUF->udpchksum == 0) {
+01165     UDPBUF->udpchksum = 0xffff;
+01166   }
+01167 #endif /* UIP_UDP_CHECKSUMS */
+01168   
+01169   goto ip_send_nolen;
+01170 #endif /* UIP_UDP */
+01171   
+01172   /* TCP input processing. */
+01173  tcp_input:
+01174   UIP_STAT(++uip_stat.tcp.recv);
+01175 
+01176   /* Start of TCP input header processing code. */
+01177   
+01178   if(uip_tcpchksum() != 0xffff) {   /* Compute and check the TCP
+01179                                        checksum. */
+01180     UIP_STAT(++uip_stat.tcp.drop);
+01181     UIP_STAT(++uip_stat.tcp.chkerr);
+01182     UIP_LOG("tcp: bad checksum.");
+01183     goto drop;
+01184   }
+01185   
+01186   
+01187   /* Demultiplex this segment. */
+01188   /* First check any active connections. */
+01189   for(uip_connr = &uip_conns[0]; uip_connr <= &uip_conns[UIP_CONNS - 1];
+01190       ++uip_connr) {
+01191     if(uip_connr->tcpstateflags != UIP_CLOSED &&
+01192        BUF->destport == uip_connr->lport &&
+01193        BUF->srcport == uip_connr->rport &&
+01194        uip_ipaddr_cmp(BUF->srcipaddr, uip_connr->ripaddr)) {
+01195       goto found;
+01196     }
+01197   }
+01198 
+01199   /* If we didn't find and active connection that expected the packet,
+01200      either this packet is an old duplicate, or this is a SYN packet
+01201      destined for a connection in LISTEN. If the SYN flag isn't set,
+01202      it is an old packet and we send a RST. */
+01203   if((BUF->flags & TCP_CTL) != TCP_SYN) {
+01204     goto reset;
+01205   }
+01206   
+01207   tmp16 = BUF->destport;
+01208   /* Next, check listening connections. */
+01209   for(c = 0; c < UIP_LISTENPORTS; ++c) {
+01210     if(tmp16 == uip_listenports[c])
+01211       goto found_listen;
+01212   }
+01213   
+01214   /* No matching connection found, so we send a RST packet. */
+01215   UIP_STAT(++uip_stat.tcp.synrst);
+01216  reset:
+01217 
+01218   /* We do not send resets in response to resets. */
+01219   if(BUF->flags & TCP_RST) {
+01220     goto drop;
+01221   }
+01222 
+01223   UIP_STAT(++uip_stat.tcp.rst);
+01224   
+01225   BUF->flags = TCP_RST | TCP_ACK;
+01226   uip_len = UIP_IPTCPH_LEN;
+01227   BUF->tcpoffset = 5 << 4;
+01228 
+01229   /* Flip the seqno and ackno fields in the TCP header. */
+01230   c = BUF->seqno[3];
+01231   BUF->seqno[3] = BUF->ackno[3];
+01232   BUF->ackno[3] = c;
+01233   
+01234   c = BUF->seqno[2];
+01235   BUF->seqno[2] = BUF->ackno[2];
+01236   BUF->ackno[2] = c;
+01237   
+01238   c = BUF->seqno[1];
+01239   BUF->seqno[1] = BUF->ackno[1];
+01240   BUF->ackno[1] = c;
+01241   
+01242   c = BUF->seqno[0];
+01243   BUF->seqno[0] = BUF->ackno[0];
+01244   BUF->ackno[0] = c;
+01245 
+01246   /* We also have to increase the sequence number we are
+01247      acknowledging. If the least significant byte overflowed, we need
+01248      to propagate the carry to the other bytes as well. */
+01249   if(++BUF->ackno[3] == 0) {
+01250     if(++BUF->ackno[2] == 0) {
+01251       if(++BUF->ackno[1] == 0) {
+01252         ++BUF->ackno[0];
+01253       }
+01254     }
+01255   }
+01256  
+01257   /* Swap port numbers. */
+01258   tmp16 = BUF->srcport;
+01259   BUF->srcport = BUF->destport;
+01260   BUF->destport = tmp16;
+01261   
+01262   /* Swap IP addresses. */
+01263   uip_ipaddr_copy(BUF->destipaddr, BUF->srcipaddr);
+01264   uip_ipaddr_copy(BUF->srcipaddr, uip_hostaddr);
+01265   
+01266   /* And send out the RST packet! */
+01267   goto tcp_send_noconn;
+01268 
+01269   /* This label will be jumped to if we matched the incoming packet
+01270      with a connection in LISTEN. In that case, we should create a new
+01271      connection and send a SYNACK in return. */
+01272  found_listen:
+01273   /* First we check if there are any connections avaliable. Unused
+01274      connections are kept in the same table as used connections, but
+01275      unused ones have the tcpstate set to CLOSED. Also, connections in
+01276      TIME_WAIT are kept track of and we'll use the oldest one if no
+01277      CLOSED connections are found. Thanks to Eddie C. Dost for a very
+01278      nice algorithm for the TIME_WAIT search. */
+01279   uip_connr = 0;
+01280   for(c = 0; c < UIP_CONNS; ++c) {
+01281     if(uip_conns[c].tcpstateflags == UIP_CLOSED) {
+01282       uip_connr = &uip_conns[c];
+01283       break;
+01284     }
+01285     if(uip_conns[c].tcpstateflags == UIP_TIME_WAIT) {
+01286       if(uip_connr == 0 ||
+01287          uip_conns[c].timer > uip_connr->timer) {
+01288         uip_connr = &uip_conns[c];
+01289       }
+01290     }
+01291   }
+01292 
+01293   if(uip_connr == 0) {
+01294     /* All connections are used already, we drop packet and hope that
+01295        the remote end will retransmit the packet at a time when we
+01296        have more spare connections. */
+01297     UIP_STAT(++uip_stat.tcp.syndrop);
+01298     UIP_LOG("tcp: found no unused connections.");
+01299     goto drop;
+01300   }
+01301   uip_conn = uip_connr;
+01302   
+01303   /* Fill in the necessary fields for the new connection. */
+01304   uip_connr->rto = uip_connr->timer = UIP_RTO;
+01305   uip_connr->sa = 0;
+01306   uip_connr->sv = 4;
+01307   uip_connr->nrtx = 0;
+01308   uip_connr->lport = BUF->destport;
+01309   uip_connr->rport = BUF->srcport;
+01310   uip_ipaddr_copy(uip_connr->ripaddr, BUF->srcipaddr);
+01311   uip_connr->tcpstateflags = UIP_SYN_RCVD;
+01312 
+01313   uip_connr->snd_nxt[0] = iss[0];
+01314   uip_connr->snd_nxt[1] = iss[1];
+01315   uip_connr->snd_nxt[2] = iss[2];
+01316   uip_connr->snd_nxt[3] = iss[3];
+01317   uip_connr->len = 1;
+01318 
+01319   /* rcv_nxt should be the seqno from the incoming packet + 1. */
+01320   uip_connr->rcv_nxt[3] = BUF->seqno[3];
+01321   uip_connr->rcv_nxt[2] = BUF->seqno[2];
+01322   uip_connr->rcv_nxt[1] = BUF->seqno[1];
+01323   uip_connr->rcv_nxt[0] = BUF->seqno[0];
+01324   uip_add_rcv_nxt(1);
+01325 
+01326   /* Parse the TCP MSS option, if present. */
+01327   if((BUF->tcpoffset & 0xf0) > 0x50) {
+01328     for(c = 0; c < ((BUF->tcpoffset >> 4) - 5) << 2 ;) {
+01329       opt = uip_buf[UIP_TCPIP_HLEN + UIP_LLH_LEN + c];
+01330       if(opt == TCP_OPT_END) {
+01331         /* End of options. */
+01332         break;
+01333       } else if(opt == TCP_OPT_NOOP) {
+01334         ++c;
+01335         /* NOP option. */
+01336       } else if(opt == TCP_OPT_MSS &&
+01337                 uip_buf[UIP_TCPIP_HLEN + UIP_LLH_LEN + 1 + c] == TCP_OPT_MSS_LEN) {
+01338         /* An MSS option with the right option length. */
+01339         tmp16 = ((u16_t)uip_buf[UIP_TCPIP_HLEN + UIP_LLH_LEN + 2 + c] << 8) |
+01340           (u16_t)uip_buf[UIP_IPTCPH_LEN + UIP_LLH_LEN + 3 + c];
+01341         uip_connr->initialmss = uip_connr->mss =
+01342           tmp16 > UIP_TCP_MSS? UIP_TCP_MSS: tmp16;
+01343         
+01344         /* And we are done processing options. */
+01345         break;
+01346       } else {
+01347         /* All other options have a length field, so that we easily
+01348            can skip past them. */
+01349         if(uip_buf[UIP_TCPIP_HLEN + UIP_LLH_LEN + 1 + c] == 0) {
+01350           /* If the length field is zero, the options are malformed
+01351              and we don't process them further. */
+01352           break;
+01353         }
+01354         c += uip_buf[UIP_TCPIP_HLEN + UIP_LLH_LEN + 1 + c];
+01355       }
+01356     }
+01357   }
+01358   
+01359   /* Our response will be a SYNACK. */
+01360 #if UIP_ACTIVE_OPEN
+01361  tcp_send_synack:
+01362   BUF->flags = TCP_ACK;
+01363   
+01364  tcp_send_syn:
+01365   BUF->flags |= TCP_SYN;
+01366 #else /* UIP_ACTIVE_OPEN */
+01367  tcp_send_synack:
+01368   BUF->flags = TCP_SYN | TCP_ACK;
+01369 #endif /* UIP_ACTIVE_OPEN */
+01370   
+01371   /* We send out the TCP Maximum Segment Size option with our
+01372      SYNACK. */
+01373   BUF->optdata[0] = TCP_OPT_MSS;
+01374   BUF->optdata[1] = TCP_OPT_MSS_LEN;
+01375   BUF->optdata[2] = (UIP_TCP_MSS) / 256;
+01376   BUF->optdata[3] = (UIP_TCP_MSS) & 255;
+01377   uip_len = UIP_IPTCPH_LEN + TCP_OPT_MSS_LEN;
+01378   BUF->tcpoffset = ((UIP_TCPH_LEN + TCP_OPT_MSS_LEN) / 4) << 4;
+01379   goto tcp_send;
+01380 
+01381   /* This label will be jumped to if we found an active connection. */
+01382  found:
+01383   uip_conn = uip_connr;
+01384   uip_flags = 0;
+01385   /* We do a very naive form of TCP reset processing; we just accept
+01386      any RST and kill our connection. We should in fact check if the
+01387      sequence number of this reset is wihtin our advertised window
+01388      before we accept the reset. */
+01389   if(BUF->flags & TCP_RST) {
+01390     uip_connr->tcpstateflags = UIP_CLOSED;
+01391     UIP_LOG("tcp: got reset, aborting connection.");
+01392     uip_flags = UIP_ABORT;
+01393     UIP_APPCALL();
+01394     goto drop;
+01395   }
+01396   /* Calculated the length of the data, if the application has sent
+01397      any data to us. */
+01398   c = (BUF->tcpoffset >> 4) << 2;
+01399   /* uip_len will contain the length of the actual TCP data. This is
+01400      calculated by subtracing the length of the TCP header (in
+01401      c) and the length of the IP header (20 bytes). */
+01402   uip_len = uip_len - c - UIP_IPH_LEN;
+01403 
+01404   /* First, check if the sequence number of the incoming packet is
+01405      what we're expecting next. If not, we send out an ACK with the
+01406      correct numbers in. */
+01407   if(!(((uip_connr->tcpstateflags & UIP_TS_MASK) == UIP_SYN_SENT) &&
+01408        ((BUF->flags & TCP_CTL) == (TCP_SYN | TCP_ACK)))) {
+01409     if((uip_len > 0 || ((BUF->flags & (TCP_SYN | TCP_FIN)) != 0)) &&
+01410        (BUF->seqno[0] != uip_connr->rcv_nxt[0] ||
+01411         BUF->seqno[1] != uip_connr->rcv_nxt[1] ||
+01412         BUF->seqno[2] != uip_connr->rcv_nxt[2] ||
+01413         BUF->seqno[3] != uip_connr->rcv_nxt[3])) {
+01414       goto tcp_send_ack;
+01415     }
+01416   }
+01417 
+01418   /* Next, check if the incoming segment acknowledges any outstanding
+01419      data. If so, we update the sequence number, reset the length of
+01420      the outstanding data, calculate RTT estimations, and reset the
+01421      retransmission timer. */
+01422   if((BUF->flags & TCP_ACK) && uip_outstanding(uip_connr)) {
+01423     uip_add32(uip_connr->snd_nxt, uip_connr->len);
+01424 
+01425     if(BUF->ackno[0] == uip_acc32[0] &&
+01426        BUF->ackno[1] == uip_acc32[1] &&
+01427        BUF->ackno[2] == uip_acc32[2] &&
+01428        BUF->ackno[3] == uip_acc32[3]) {
+01429       /* Update sequence number. */
+01430       uip_connr->snd_nxt[0] = uip_acc32[0];
+01431       uip_connr->snd_nxt[1] = uip_acc32[1];
+01432       uip_connr->snd_nxt[2] = uip_acc32[2];
+01433       uip_connr->snd_nxt[3] = uip_acc32[3];
+01434         
+01435 
+01436       /* Do RTT estimation, unless we have done retransmissions. */
+01437       if(uip_connr->nrtx == 0) {
+01438         signed char m;
+01439         m = uip_connr->rto - uip_connr->timer;
+01440         /* This is taken directly from VJs original code in his paper */
+01441         m = m - (uip_connr->sa >> 3);
+01442         uip_connr->sa += m;
+01443         if(m < 0) {
+01444           m = -m;
+01445         }
+01446         m = m - (uip_connr->sv >> 2);
+01447         uip_connr->sv += m;
+01448         uip_connr->rto = (uip_connr->sa >> 3) + uip_connr->sv;
+01449 
+01450       }
+01451       /* Set the acknowledged flag. */
+01452       uip_flags = UIP_ACKDATA;
+01453       /* Reset the retransmission timer. */
+01454       uip_connr->timer = uip_connr->rto;
+01455 
+01456       /* Reset length of outstanding data. */
+01457       uip_connr->len = 0;
+01458     }
+01459     
+01460   }
+01461 
+01462   /* Do different things depending on in what state the connection is. */
+01463   switch(uip_connr->tcpstateflags & UIP_TS_MASK) {
+01464     /* CLOSED and LISTEN are not handled here. CLOSE_WAIT is not
+01465         implemented, since we force the application to close when the
+01466         peer sends a FIN (hence the application goes directly from
+01467         ESTABLISHED to LAST_ACK). */
+01468   case UIP_SYN_RCVD:
+01469     /* In SYN_RCVD we have sent out a SYNACK in response to a SYN, and
+01470        we are waiting for an ACK that acknowledges the data we sent
+01471        out the last time. Therefore, we want to have the UIP_ACKDATA
+01472        flag set. If so, we enter the ESTABLISHED state. */
+01473     if(uip_flags & UIP_ACKDATA) {
+01474       uip_connr->tcpstateflags = UIP_ESTABLISHED;
+01475       uip_flags = UIP_CONNECTED;
+01476       uip_connr->len = 0;
+01477       if(uip_len > 0) {
+01478         uip_flags |= UIP_NEWDATA;
+01479         uip_add_rcv_nxt(uip_len);
+01480       }
+01481       uip_slen = 0;
+01482       UIP_APPCALL();
+01483       goto appsend;
+01484     }
+01485     goto drop;
+01486 #if UIP_ACTIVE_OPEN
+01487   case UIP_SYN_SENT:
+01488     /* In SYN_SENT, we wait for a SYNACK that is sent in response to
+01489        our SYN. The rcv_nxt is set to sequence number in the SYNACK
+01490        plus one, and we send an ACK. We move into the ESTABLISHED
+01491        state. */
+01492     if((uip_flags & UIP_ACKDATA) &&
+01493        (BUF->flags & TCP_CTL) == (TCP_SYN | TCP_ACK)) {
+01494 
+01495       /* Parse the TCP MSS option, if present. */
+01496       if((BUF->tcpoffset & 0xf0) > 0x50) {
+01497         for(c = 0; c < ((BUF->tcpoffset >> 4) - 5) << 2 ;) {
+01498           opt = uip_buf[UIP_IPTCPH_LEN + UIP_LLH_LEN + c];
+01499           if(opt == TCP_OPT_END) {
+01500             /* End of options. */
+01501             break;
+01502           } else if(opt == TCP_OPT_NOOP) {
+01503             ++c;
+01504             /* NOP option. */
+01505           } else if(opt == TCP_OPT_MSS &&
+01506                     uip_buf[UIP_TCPIP_HLEN + UIP_LLH_LEN + 1 + c] == TCP_OPT_MSS_LEN) {
+01507             /* An MSS option with the right option length. */
+01508             tmp16 = (uip_buf[UIP_TCPIP_HLEN + UIP_LLH_LEN + 2 + c] << 8) |
+01509               uip_buf[UIP_TCPIP_HLEN + UIP_LLH_LEN + 3 + c];
+01510             uip_connr->initialmss =
+01511               uip_connr->mss = tmp16 > UIP_TCP_MSS? UIP_TCP_MSS: tmp16;
+01512 
+01513             /* And we are done processing options. */
+01514             break;
+01515           } else {
+01516             /* All other options have a length field, so that we easily
+01517                can skip past them. */
+01518             if(uip_buf[UIP_TCPIP_HLEN + UIP_LLH_LEN + 1 + c] == 0) {
+01519               /* If the length field is zero, the options are malformed
+01520                  and we don't process them further. */
+01521               break;
+01522             }
+01523             c += uip_buf[UIP_TCPIP_HLEN + UIP_LLH_LEN + 1 + c];
+01524           }
+01525         }
+01526       }
+01527       uip_connr->tcpstateflags = UIP_ESTABLISHED;
+01528       uip_connr->rcv_nxt[0] = BUF->seqno[0];
+01529       uip_connr->rcv_nxt[1] = BUF->seqno[1];
+01530       uip_connr->rcv_nxt[2] = BUF->seqno[2];
+01531       uip_connr->rcv_nxt[3] = BUF->seqno[3];
+01532       uip_add_rcv_nxt(1);
+01533       uip_flags = UIP_CONNECTED | UIP_NEWDATA;
+01534       uip_connr->len = 0;
+01535       uip_len = 0;
+01536       uip_slen = 0;
+01537       UIP_APPCALL();
+01538       goto appsend;
+01539     }
+01540     /* Inform the application that the connection failed */
+01541     uip_flags = UIP_ABORT;
+01542     UIP_APPCALL();
+01543     /* The connection is closed after we send the RST */
+01544     uip_conn->tcpstateflags = UIP_CLOSED;
+01545     goto reset;
+01546 #endif /* UIP_ACTIVE_OPEN */
+01547     
+01548   case UIP_ESTABLISHED:
+01549     /* In the ESTABLISHED state, we call upon the application to feed
+01550     data into the uip_buf. If the UIP_ACKDATA flag is set, the
+01551     application should put new data into the buffer, otherwise we are
+01552     retransmitting an old segment, and the application should put that
+01553     data into the buffer.
+01554 
+01555     If the incoming packet is a FIN, we should close the connection on
+01556     this side as well, and we send out a FIN and enter the LAST_ACK
+01557     state. We require that there is no outstanding data; otherwise the
+01558     sequence numbers will be screwed up. */
+01559 
+01560     if(BUF->flags & TCP_FIN && !(uip_connr->tcpstateflags & UIP_STOPPED)) {
+01561       if(uip_outstanding(uip_connr)) {
+01562         goto drop;
+01563       }
+01564       uip_add_rcv_nxt(1 + uip_len);
+01565       uip_flags |= UIP_CLOSE;
+01566       if(uip_len > 0) {
+01567         uip_flags |= UIP_NEWDATA;
+01568       }
+01569       UIP_APPCALL();
+01570       uip_connr->len = 1;
+01571       uip_connr->tcpstateflags = UIP_LAST_ACK;
+01572       uip_connr->nrtx = 0;
+01573     tcp_send_finack:
+01574       BUF->flags = TCP_FIN | TCP_ACK;
+01575       goto tcp_send_nodata;
+01576     }
+01577 
+01578     /* Check the URG flag. If this is set, the segment carries urgent
+01579        data that we must pass to the application. */
+01580     if((BUF->flags & TCP_URG) != 0) {
+01581 #if UIP_URGDATA > 0
+01582       uip_urglen = (BUF->urgp[0] << 8) | BUF->urgp[1];
+01583       if(uip_urglen > uip_len) {
+01584         /* There is more urgent data in the next segment to come. */
+01585         uip_urglen = uip_len;
+01586       }
+01587       uip_add_rcv_nxt(uip_urglen);
+01588       uip_len -= uip_urglen;
+01589       uip_urgdata = uip_appdata;
+01590       uip_appdata += uip_urglen;
+01591     } else {
+01592       uip_urglen = 0;
+01593 #else /* UIP_URGDATA > 0 */
+01594       uip_appdata = ((char *)uip_appdata) + ((BUF->urgp[0] << 8) | BUF->urgp[1]);
+01595       uip_len -= (BUF->urgp[0] << 8) | BUF->urgp[1];
+01596 #endif /* UIP_URGDATA > 0 */
+01597     }
+01598 
+01599     /* If uip_len > 0 we have TCP data in the packet, and we flag this
+01600        by setting the UIP_NEWDATA flag and update the sequence number
+01601        we acknowledge. If the application has stopped the dataflow
+01602        using uip_stop(), we must not accept any data packets from the
+01603        remote host. */
+01604     if(uip_len > 0 && !(uip_connr->tcpstateflags & UIP_STOPPED)) {
+01605       uip_flags |= UIP_NEWDATA;
+01606       uip_add_rcv_nxt(uip_len);
+01607     }
+01608 
+01609     /* Check if the available buffer space advertised by the other end
+01610        is smaller than the initial MSS for this connection. If so, we
+01611        set the current MSS to the window size to ensure that the
+01612        application does not send more data than the other end can
+01613        handle.
+01614 
+01615        If the remote host advertises a zero window, we set the MSS to
+01616        the initial MSS so that the application will send an entire MSS
+01617        of data. This data will not be acknowledged by the receiver,
+01618        and the application will retransmit it. This is called the
+01619        "persistent timer" and uses the retransmission mechanim.
+01620     */
+01621     tmp16 = ((u16_t)BUF->wnd[0] << 8) + (u16_t)BUF->wnd[1];
+01622     if(tmp16 > uip_connr->initialmss ||
+01623        tmp16 == 0) {
+01624       tmp16 = uip_connr->initialmss;
+01625     }
+01626     uip_connr->mss = tmp16;
+01627 
+01628     /* If this packet constitutes an ACK for outstanding data (flagged
+01629        by the UIP_ACKDATA flag, we should call the application since it
+01630        might want to send more data. If the incoming packet had data
+01631        from the peer (as flagged by the UIP_NEWDATA flag), the
+01632        application must also be notified.
+01633 
+01634        When the application is called, the global variable uip_len
+01635        contains the length of the incoming data. The application can
+01636        access the incoming data through the global pointer
+01637        uip_appdata, which usually points UIP_IPTCPH_LEN + UIP_LLH_LEN
+01638        bytes into the uip_buf array.
+01639 
+01640        If the application wishes to send any data, this data should be
+01641        put into the uip_appdata and the length of the data should be
+01642        put into uip_len. If the application don't have any data to
+01643        send, uip_len must be set to 0. */
+01644     if(uip_flags & (UIP_NEWDATA | UIP_ACKDATA)) {
+01645       uip_slen = 0;
+01646       UIP_APPCALL();
+01647 
+01648     appsend:
+01649       
+01650       if(uip_flags & UIP_ABORT) {
+01651         uip_slen = 0;
+01652         uip_connr->tcpstateflags = UIP_CLOSED;
+01653         BUF->flags = TCP_RST | TCP_ACK;
+01654         goto tcp_send_nodata;
+01655       }
+01656 
+01657       if(uip_flags & UIP_CLOSE) {
+01658         uip_slen = 0;
+01659         uip_connr->len = 1;
+01660         uip_connr->tcpstateflags = UIP_FIN_WAIT_1;
+01661         uip_connr->nrtx = 0;
+01662         BUF->flags = TCP_FIN | TCP_ACK;
+01663         goto tcp_send_nodata;
+01664       }
+01665 
+01666       /* If uip_slen > 0, the application has data to be sent. */
+01667       if(uip_slen > 0) {
+01668 
+01669         /* If the connection has acknowledged data, the contents of
+01670            the ->len variable should be discarded. */
+01671         if((uip_flags & UIP_ACKDATA) != 0) {
+01672           uip_connr->len = 0;
+01673         }
+01674 
+01675         /* If the ->len variable is non-zero the connection has
+01676            already data in transit and cannot send anymore right
+01677            now. */
+01678         if(uip_connr->len == 0) {
+01679 
+01680           /* The application cannot send more than what is allowed by
+01681              the mss (the minumum of the MSS and the available
+01682              window). */
+01683           if(uip_slen > uip_connr->mss) {
+01684             uip_slen = uip_connr->mss;
+01685           }
+01686 
+01687           /* Remember how much data we send out now so that we know
+01688              when everything has been acknowledged. */
+01689           uip_connr->len = uip_slen;
+01690         } else {
+01691 
+01692           /* If the application already had unacknowledged data, we
+01693              make sure that the application does not send (i.e.,
+01694              retransmit) out more than it previously sent out. */
+01695           uip_slen = uip_connr->len;
+01696         }
+01697       }
+01698       uip_connr->nrtx = 0;
+01699     apprexmit:
+01700       uip_appdata = uip_sappdata;
+01701       
+01702       /* If the application has data to be sent, or if the incoming
+01703          packet had new data in it, we must send out a packet. */
+01704       if(uip_slen > 0 && uip_connr->len > 0) {
+01705         /* Add the length of the IP and TCP headers. */
+01706         uip_len = uip_connr->len + UIP_TCPIP_HLEN;
+01707         /* We always set the ACK flag in response packets. */
+01708         BUF->flags = TCP_ACK | TCP_PSH;
+01709         /* Send the packet. */
+01710         goto tcp_send_noopts;
+01711       }
+01712       /* If there is no data to send, just send out a pure ACK if
+01713          there is newdata. */
+01714       if(uip_flags & UIP_NEWDATA) {
+01715         uip_len = UIP_TCPIP_HLEN;
+01716         BUF->flags = TCP_ACK;
+01717         goto tcp_send_noopts;
+01718       }
+01719     }
+01720     goto drop;
+01721   case UIP_LAST_ACK:
+01722     /* We can close this connection if the peer has acknowledged our
+01723        FIN. This is indicated by the UIP_ACKDATA flag. */
+01724     if(uip_flags & UIP_ACKDATA) {
+01725       uip_connr->tcpstateflags = UIP_CLOSED;
+01726       uip_flags = UIP_CLOSE;
+01727       UIP_APPCALL();
+01728     }
+01729     break;
+01730     
+01731   case UIP_FIN_WAIT_1:
+01732     /* The application has closed the connection, but the remote host
+01733        hasn't closed its end yet. Thus we do nothing but wait for a
+01734        FIN from the other side. */
+01735     if(uip_len > 0) {
+01736       uip_add_rcv_nxt(uip_len);
+01737     }
+01738     if(BUF->flags & TCP_FIN) {
+01739       if(uip_flags & UIP_ACKDATA) {
+01740         uip_connr->tcpstateflags = UIP_TIME_WAIT;
+01741         uip_connr->timer = 0;
+01742         uip_connr->len = 0;
+01743       } else {
+01744         uip_connr->tcpstateflags = UIP_CLOSING;
+01745       }
+01746       uip_add_rcv_nxt(1);
+01747       uip_flags = UIP_CLOSE;
+01748       UIP_APPCALL();
+01749       goto tcp_send_ack;
+01750     } else if(uip_flags & UIP_ACKDATA) {
+01751       uip_connr->tcpstateflags = UIP_FIN_WAIT_2;
+01752       uip_connr->len = 0;
+01753       goto drop;
+01754     }
+01755     if(uip_len > 0) {
+01756       goto tcp_send_ack;
+01757     }
+01758     goto drop;
+01759       
+01760   case UIP_FIN_WAIT_2:
+01761     if(uip_len > 0) {
+01762       uip_add_rcv_nxt(uip_len);
+01763     }
+01764     if(BUF->flags & TCP_FIN) {
+01765       uip_connr->tcpstateflags = UIP_TIME_WAIT;
+01766       uip_connr->timer = 0;
+01767       uip_add_rcv_nxt(1);
+01768       uip_flags = UIP_CLOSE;
+01769       UIP_APPCALL();
+01770       goto tcp_send_ack;
+01771     }
+01772     if(uip_len > 0) {
+01773       goto tcp_send_ack;
+01774     }
+01775     goto drop;
+01776 
+01777   case UIP_TIME_WAIT:
+01778     goto tcp_send_ack;
+01779     
+01780   case UIP_CLOSING:
+01781     if(uip_flags & UIP_ACKDATA) {
+01782       uip_connr->tcpstateflags = UIP_TIME_WAIT;
+01783       uip_connr->timer = 0;
+01784     }
+01785   }
+01786   goto drop;
+01787   
+01788 
+01789   /* We jump here when we are ready to send the packet, and just want
+01790      to set the appropriate TCP sequence numbers in the TCP header. */
+01791  tcp_send_ack:
+01792   BUF->flags = TCP_ACK;
+01793  tcp_send_nodata:
+01794   uip_len = UIP_IPTCPH_LEN;
+01795  tcp_send_noopts:
+01796   BUF->tcpoffset = (UIP_TCPH_LEN / 4) << 4;
+01797  tcp_send:
+01798   /* We're done with the input processing. We are now ready to send a
+01799      reply. Our job is to fill in all the fields of the TCP and IP
+01800      headers before calculating the checksum and finally send the
+01801      packet. */
+01802   BUF->ackno[0] = uip_connr->rcv_nxt[0];
+01803   BUF->ackno[1] = uip_connr->rcv_nxt[1];
+01804   BUF->ackno[2] = uip_connr->rcv_nxt[2];
+01805   BUF->ackno[3] = uip_connr->rcv_nxt[3];
+01806   
+01807   BUF->seqno[0] = uip_connr->snd_nxt[0];
+01808   BUF->seqno[1] = uip_connr->snd_nxt[1];
+01809   BUF->seqno[2] = uip_connr->snd_nxt[2];
+01810   BUF->seqno[3] = uip_connr->snd_nxt[3];
+01811 
+01812   BUF->proto = UIP_PROTO_TCP;
+01813   
+01814   BUF->srcport  = uip_connr->lport;
+01815   BUF->destport = uip_connr->rport;
+01816 
+01817   uip_ipaddr_copy(BUF->srcipaddr, uip_hostaddr);
+01818   uip_ipaddr_copy(BUF->destipaddr, uip_connr->ripaddr);
+01819 
+01820   if(uip_connr->tcpstateflags & UIP_STOPPED) {
+01821     /* If the connection has issued uip_stop(), we advertise a zero
+01822        window so that the remote host will stop sending data. */
+01823     BUF->wnd[0] = BUF->wnd[1] = 0;
+01824   } else {
+01825     BUF->wnd[0] = ((UIP_RECEIVE_WINDOW) >> 8);
+01826     BUF->wnd[1] = ((UIP_RECEIVE_WINDOW) & 0xff);
+01827   }
+01828 
+01829  tcp_send_noconn:
+01830   BUF->ttl = UIP_TTL;
+01831 #if UIP_CONF_IPV6
+01832   /* For IPv6, the IP length field does not include the IPv6 IP header
+01833      length. */
+01834   BUF->len[0] = ((uip_len - UIP_IPH_LEN) >> 8);
+01835   BUF->len[1] = ((uip_len - UIP_IPH_LEN) & 0xff);
+01836 #else /* UIP_CONF_IPV6 */
+01837   BUF->len[0] = (uip_len >> 8);
+01838   BUF->len[1] = (uip_len & 0xff);
+01839 #endif /* UIP_CONF_IPV6 */
+01840 
+01841   BUF->urgp[0] = BUF->urgp[1] = 0;
+01842   
+01843   /* Calculate TCP checksum. */
+01844   BUF->tcpchksum = 0;
+01845   BUF->tcpchksum = ~(uip_tcpchksum());
+01846   
+01847  ip_send_nolen:
+01848 
+01849 #if UIP_CONF_IPV6
+01850   BUF->vtc = 0x60;
+01851   BUF->tcflow = 0x00;
+01852   BUF->flow = 0x00;
+01853 #else /* UIP_CONF_IPV6 */
+01854   BUF->vhl = 0x45;
+01855   BUF->tos = 0;
+01856   BUF->ipoffset[0] = BUF->ipoffset[1] = 0;
+01857   ++ipid;
+01858   BUF->ipid[0] = ipid >> 8;
+01859   BUF->ipid[1] = ipid & 0xff;
+01860   /* Calculate IP checksum. */
+01861   BUF->ipchksum = 0;
+01862   BUF->ipchksum = ~(uip_ipchksum());
+01863   DEBUG_PRINTF("uip ip_send_nolen: chkecum 0x%04x\n", uip_ipchksum());
+01864 #endif /* UIP_CONF_IPV6 */
+01865    
+01866   UIP_STAT(++uip_stat.tcp.sent);
+01867  send:
+01868   DEBUG_PRINTF("Sending packet with length %d (%d)\n", uip_len,
+01869                (BUF->len[0] << 8) | BUF->len[1]);
+01870   
+01871   UIP_STAT(++uip_stat.ip.sent);
+01872   /* Return and let the caller do the actual transmission. */
+01873   uip_flags = 0;
+01874   return;
+01875  drop:
+01876   uip_len = 0;
+01877   uip_flags = 0;
+01878   return;
+01879 }
+01880 /*---------------------------------------------------------------------------*/
+01881 u16_t
+01882 htons(u16_t val)
+01883 {
+01884   return HTONS(val);
+01885 }
+01886 /*---------------------------------------------------------------------------*/
+01887 void
+01888 uip_send(const void *data, int len)
+01889 {
+01890   if(len > 0) {
+01891     uip_slen = len;
+01892     if(data != uip_sappdata) {
+01893       memcpy(uip_sappdata, (data), uip_slen);
+01894     }
+01895   }
+01896 }
+01897 /** @} */
+