Obviate uip_init(); our bss is zeroed at startup already.
[people/oremanj/gpxe.git] / src / proto / uip / uip.c
1 /**
2  * \addtogroup uip
3  * @{
4  */
5
6 /**
7  * \file
8  * The uIP TCP/IP stack code.
9  * \author Adam Dunkels <adam@dunkels.com>
10  */
11
12 /*
13  * Copyright (c) 2001-2003, Adam Dunkels.
14  * All rights reserved. 
15  *
16  * Redistribution and use in source and binary forms, with or without 
17  * modification, are permitted provided that the following conditions 
18  * are met: 
19  * 1. Redistributions of source code must retain the above copyright 
20  *    notice, this list of conditions and the following disclaimer. 
21  * 2. Redistributions in binary form must reproduce the above copyright 
22  *    notice, this list of conditions and the following disclaimer in the 
23  *    documentation and/or other materials provided with the distribution. 
24  * 3. The name of the author may not be used to endorse or promote
25  *    products derived from this software without specific prior
26  *    written permission.  
27  *
28  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS
29  * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
30  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
31  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
32  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
33  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
34  * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
35  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
36  * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
37  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
38  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.  
39  *
40  * This file is part of the uIP TCP/IP stack.
41  *
42  * $Id$
43  *
44  */
45
46 /*
47 This is a small implementation of the IP and TCP protocols (as well as
48 some basic ICMP stuff). The implementation couples the IP, TCP and the
49 application layers very tightly. To keep the size of the compiled code
50 down, this code also features heavy usage of the goto statement.
51
52 The principle is that we have a small buffer, called the uip_buf, in
53 which the device driver puts an incoming packet. The TCP/IP stack
54 parses the headers in the packet, and calls upon the application. If
55 the remote host has sent data to the application, this data is present
56 in the uip_buf and the application read the data from there. It is up
57 to the application to put this data into a byte stream if needed. The
58 application will not be fed with data that is out of sequence.
59
60 If the application whishes to send data to the peer, it should put its
61 data into the uip_buf, 40 bytes from the start of the buffer. The
62 TCP/IP stack will calculate the checksums, and fill in the necessary
63 header fields and finally send the packet back to the peer.
64 */
65
66 #include "uip.h"
67 #include "uipopt.h"
68 #include "uip_arch.h"
69
70 /*-----------------------------------------------------------------------------------*/
71 /* Variable definitions. */
72
73
74 /* The IP address of this host. If it is defined to be fixed (by setting UIP_FIXEDADDR to 1 in uipopt.h), the address is set here. Otherwise, the address */
75 #if UIP_FIXEDADDR > 0
76 const u16_t uip_hostaddr[2] =
77   {HTONS((UIP_IPADDR0 << 8) | UIP_IPADDR1),
78    HTONS((UIP_IPADDR2 << 8) | UIP_IPADDR3)};
79 const u16_t uip_arp_draddr[2] =
80   {HTONS((UIP_DRIPADDR0 << 8) | UIP_DRIPADDR1),
81    HTONS((UIP_DRIPADDR2 << 8) | UIP_DRIPADDR3)};
82 const u16_t uip_arp_netmask[2] =
83   {HTONS((UIP_NETMASK0 << 8) | UIP_NETMASK1),
84    HTONS((UIP_NETMASK2 << 8) | UIP_NETMASK3)};
85 #else
86 u16_t uip_hostaddr[2];       
87 u16_t uip_arp_draddr[2], uip_arp_netmask[2];
88 #endif /* UIP_FIXEDADDR */
89
90 u8_t uip_buf[UIP_BUFSIZE+2];   /* The packet buffer that contains
91                                 incoming packets. */
92 volatile u8_t *uip_appdata;  /* The uip_appdata pointer points to
93                                 application data. */
94 volatile u8_t *uip_sappdata;  /* The uip_appdata pointer points to the
95                                  application data which is to be sent. */
96 #if UIP_URGDATA > 0
97 volatile u8_t *uip_urgdata;  /* The uip_urgdata pointer points to
98                                 urgent data (out-of-band data), if
99                                 present. */
100 volatile u8_t uip_urglen, uip_surglen;
101 #endif /* UIP_URGDATA > 0 */
102
103 volatile u16_t uip_len, uip_slen;
104                              /* The uip_len is either 8 or 16 bits,
105                                 depending on the maximum packet
106                                 size. */
107
108 volatile u8_t uip_flags;     /* The uip_flags variable is used for
109                                 communication between the TCP/IP stack
110                                 and the application program. */
111 struct uip_conn *uip_conn;   /* uip_conn always points to the current
112                                 connection. */
113
114 struct uip_conn uip_conns[UIP_CONNS];
115                              /* The uip_conns array holds all TCP
116                                 connections. */
117 u16_t uip_listenports[UIP_LISTENPORTS];
118                              /* The uip_listenports list all currently
119                                 listning ports. */
120 #if UIP_UDP
121 struct uip_udp_conn *uip_udp_conn;
122 struct uip_udp_conn uip_udp_conns[UIP_UDP_CONNS];
123 #endif /* UIP_UDP */
124
125
126 static u16_t ipid;           /* Ths ipid variable is an increasing
127                                 number that is used for the IP ID
128                                 field. */
129
130 static u8_t iss[4];          /* The iss variable is used for the TCP
131                                 initial sequence number. */
132
133 #if UIP_ACTIVE_OPEN
134 static u16_t lastport = 1024;  /* Keeps track of the last port used for
135                                 a new connection. */
136 #endif /* UIP_ACTIVE_OPEN */
137
138 /* Temporary variables. */
139 volatile u8_t uip_acc32[4];
140 static u8_t c, opt;
141 static u16_t tmp16;
142
143 /* Structures and definitions. */
144 #define TCP_FIN 0x01
145 #define TCP_SYN 0x02
146 #define TCP_RST 0x04
147 #define TCP_PSH 0x08
148 #define TCP_ACK 0x10
149 #define TCP_URG 0x20
150 #define TCP_CTL 0x3f
151
152 #define ICMP_ECHO_REPLY 0
153 #define ICMP_ECHO       8     
154
155 /* Macros. */
156 #define BUF ((uip_tcpip_hdr *)&uip_buf[UIP_LLH_LEN])
157 #define FBUF ((uip_tcpip_hdr *)&uip_reassbuf[0])
158 #define ICMPBUF ((uip_icmpip_hdr *)&uip_buf[UIP_LLH_LEN])
159 #define UDPBUF ((uip_udpip_hdr *)&uip_buf[UIP_LLH_LEN])
160
161 #if UIP_STATISTICS == 1
162 struct uip_stats uip_stat;
163 #define UIP_STAT(s) s
164 #else
165 #define UIP_STAT(s)
166 #endif /* UIP_STATISTICS == 1 */
167
168 #if UIP_LOGGING == 1
169 #include <stdio.h>
170 void uip_log(char *msg);
171 #define UIP_LOG(m) uip_log(m)
172 #else
173 #define UIP_LOG(m)
174 #endif /* UIP_LOGGING == 1 */
175
176 /*-----------------------------------------------------------------------------------*/
177 #if 0
178 void
179 uip_init(void)
180 {
181   for(c = 0; c < UIP_LISTENPORTS; ++c) {
182     uip_listenports[c] = 0;
183   }
184   for(c = 0; c < UIP_CONNS; ++c) {
185     uip_conns[c].tcpstateflags = CLOSED;
186   }
187 #if UIP_ACTIVE_OPEN
188   lastport = 1024;
189 #endif /* UIP_ACTIVE_OPEN */
190
191 #if UIP_UDP
192   for(c = 0; c < UIP_UDP_CONNS; ++c) {
193     uip_udp_conns[c].lport = 0;
194   }
195 #endif /* UIP_UDP */
196   
197
198   /* IPv4 initialization. */
199 #if UIP_FIXEDADDR == 0
200   uip_hostaddr[0] = uip_hostaddr[1] = 0;
201 #endif /* UIP_FIXEDADDR */
202
203 }
204 #endif
205 /*-----------------------------------------------------------------------------------*/
206 #if UIP_ACTIVE_OPEN
207 struct uip_conn *
208 uip_connect(u16_t *ripaddr, u16_t rport)
209 {
210   register struct uip_conn *conn, *cconn;
211   
212   /* Find an unused local port. */
213  again:
214   ++lastport;
215
216   if(lastport >= 32000) {
217     lastport = 4096;
218   }
219
220   /* Check if this port is already in use, and if so try to find
221      another one. */
222   for(c = 0; c < UIP_CONNS; ++c) {
223     conn = &uip_conns[c];
224     if(conn->tcpstateflags != CLOSED &&
225        conn->lport == htons(lastport)) {
226       goto again;
227     }
228   }
229
230
231   conn = 0;
232   for(c = 0; c < UIP_CONNS; ++c) {
233     cconn = &uip_conns[c]; 
234     if(cconn->tcpstateflags == CLOSED) {
235       conn = cconn;
236       break;
237     }
238     if(cconn->tcpstateflags == TIME_WAIT) {
239       if(conn == 0 ||
240          cconn->timer > uip_conn->timer) {
241         conn = cconn;
242       }
243     }
244   }
245
246   if(conn == 0) {
247     return 0;
248   }
249   
250   conn->tcpstateflags = SYN_SENT;
251
252   conn->snd_nxt[0] = iss[0];
253   conn->snd_nxt[1] = iss[1];
254   conn->snd_nxt[2] = iss[2];
255   conn->snd_nxt[3] = iss[3];
256
257   conn->initialmss = conn->mss = UIP_TCP_MSS;
258   
259   conn->len = 1;   /* TCP length of the SYN is one. */
260   conn->nrtx = 0;
261   conn->timer = 1; /* Send the SYN next time around. */
262   conn->rto = UIP_RTO;
263   conn->sa = 0;
264   conn->sv = 16;
265   conn->lport = htons(lastport);
266   conn->rport = rport;
267   conn->ripaddr[0] = ripaddr[0];
268   conn->ripaddr[1] = ripaddr[1];
269   
270   return conn;
271 }
272 #endif /* UIP_ACTIVE_OPEN */
273 /*-----------------------------------------------------------------------------------*/
274 #if UIP_UDP
275 struct uip_udp_conn *
276 uip_udp_new(u16_t *ripaddr, u16_t rport)
277 {
278   register struct uip_udp_conn *conn;
279   
280   /* Find an unused local port. */
281  again:
282   ++lastport;
283
284   if(lastport >= 32000) {
285     lastport = 4096;
286   }
287   
288   for(c = 0; c < UIP_UDP_CONNS; ++c) {
289     if(uip_udp_conns[c].lport == lastport) {
290       goto again;
291     }
292   }
293
294
295   conn = 0;
296   for(c = 0; c < UIP_UDP_CONNS; ++c) {
297     if(uip_udp_conns[c].lport == 0) {
298       conn = &uip_udp_conns[c]; 
299       break;
300     }
301   }
302
303   if(conn == 0) {
304     return 0;
305   }
306   
307   conn->lport = HTONS(lastport);
308   conn->rport = HTONS(rport);
309   conn->ripaddr[0] = ripaddr[0];
310   conn->ripaddr[1] = ripaddr[1];
311   
312   return conn;
313 }
314 #endif /* UIP_UDP */
315 /*-----------------------------------------------------------------------------------*/
316 void
317 uip_unlisten(u16_t port)
318 {
319   for(c = 0; c < UIP_LISTENPORTS; ++c) {
320     if(uip_listenports[c] == port) {
321       uip_listenports[c] = 0;
322       return;
323     }
324   }
325 }
326 /*-----------------------------------------------------------------------------------*/
327 void
328 uip_listen(u16_t port)
329 {
330   for(c = 0; c < UIP_LISTENPORTS; ++c) {
331     if(uip_listenports[c] == 0) {
332       uip_listenports[c] = port;
333       return;
334     }
335   }
336 }
337 /*-----------------------------------------------------------------------------------*/
338 /* XXX: IP fragment reassembly: not well-tested. */
339
340 #if UIP_REASSEMBLY
341 #define UIP_REASS_BUFSIZE (UIP_BUFSIZE - UIP_LLH_LEN)
342 static u8_t uip_reassbuf[UIP_REASS_BUFSIZE];
343 static u8_t uip_reassbitmap[UIP_REASS_BUFSIZE / (8 * 8)];
344 static const u8_t bitmap_bits[8] = {0xff, 0x7f, 0x3f, 0x1f,
345                                     0x0f, 0x07, 0x03, 0x01};
346 static u16_t uip_reasslen;
347 static u8_t uip_reassflags;
348 #define UIP_REASS_FLAG_LASTFRAG 0x01
349 static u8_t uip_reasstmr;
350
351 #define IP_HLEN 20
352 #define IP_MF   0x20
353
354 static u8_t
355 uip_reass(void)
356 {
357   u16_t offset, len;
358   u16_t i;
359
360   /* If ip_reasstmr is zero, no packet is present in the buffer, so we
361      write the IP header of the fragment into the reassembly
362      buffer. The timer is updated with the maximum age. */
363   if(uip_reasstmr == 0) {
364     memcpy(uip_reassbuf, &BUF->vhl, IP_HLEN);
365     uip_reasstmr = UIP_REASS_MAXAGE;
366     uip_reassflags = 0;
367     /* Clear the bitmap. */
368     memset(uip_reassbitmap, sizeof(uip_reassbitmap), 0);
369   }
370
371   /* Check if the incoming fragment matches the one currently present
372      in the reasembly buffer. If so, we proceed with copying the
373      fragment into the buffer. */
374   if(BUF->srcipaddr[0] == FBUF->srcipaddr[0] &&
375      BUF->srcipaddr[1] == FBUF->srcipaddr[1] &&
376      BUF->destipaddr[0] == FBUF->destipaddr[0] &&
377      BUF->destipaddr[1] == FBUF->destipaddr[1] &&
378      BUF->ipid[0] == FBUF->ipid[0] &&
379      BUF->ipid[1] == FBUF->ipid[1]) {
380
381     len = (BUF->len[0] << 8) + BUF->len[1] - (BUF->vhl & 0x0f) * 4;
382     offset = (((BUF->ipoffset[0] & 0x3f) << 8) + BUF->ipoffset[1]) * 8;
383
384     /* If the offset or the offset + fragment length overflows the
385        reassembly buffer, we discard the entire packet. */
386     if(offset > UIP_REASS_BUFSIZE ||
387        offset + len > UIP_REASS_BUFSIZE) {
388       uip_reasstmr = 0;
389       goto nullreturn;
390     }
391
392     /* Copy the fragment into the reassembly buffer, at the right
393        offset. */
394     memcpy(&uip_reassbuf[IP_HLEN + offset],
395            (char *)BUF + (int)((BUF->vhl & 0x0f) * 4),
396            len);
397       
398     /* Update the bitmap. */
399     if(offset / (8 * 8) == (offset + len) / (8 * 8)) {
400       /* If the two endpoints are in the same byte, we only update
401          that byte. */
402              
403       uip_reassbitmap[offset / (8 * 8)] |=
404              bitmap_bits[(offset / 8 ) & 7] &
405              ~bitmap_bits[((offset + len) / 8 ) & 7];
406     } else {
407       /* If the two endpoints are in different bytes, we update the
408          bytes in the endpoints and fill the stuff inbetween with
409          0xff. */
410       uip_reassbitmap[offset / (8 * 8)] |=
411         bitmap_bits[(offset / 8 ) & 7];
412       for(i = 1 + offset / (8 * 8); i < (offset + len) / (8 * 8); ++i) {
413         uip_reassbitmap[i] = 0xff;
414       }      
415       uip_reassbitmap[(offset + len) / (8 * 8)] |=
416         ~bitmap_bits[((offset + len) / 8 ) & 7];
417     }
418     
419     /* If this fragment has the More Fragments flag set to zero, we
420        know that this is the last fragment, so we can calculate the
421        size of the entire packet. We also set the
422        IP_REASS_FLAG_LASTFRAG flag to indicate that we have received
423        the final fragment. */
424
425     if((BUF->ipoffset[0] & IP_MF) == 0) {
426       uip_reassflags |= UIP_REASS_FLAG_LASTFRAG;
427       uip_reasslen = offset + len;
428     }
429     
430     /* Finally, we check if we have a full packet in the buffer. We do
431        this by checking if we have the last fragment and if all bits
432        in the bitmap are set. */
433     if(uip_reassflags & UIP_REASS_FLAG_LASTFRAG) {
434       /* Check all bytes up to and including all but the last byte in
435          the bitmap. */
436       for(i = 0; i < uip_reasslen / (8 * 8) - 1; ++i) {
437         if(uip_reassbitmap[i] != 0xff) {
438           goto nullreturn;
439         }
440       }
441       /* Check the last byte in the bitmap. It should contain just the
442          right amount of bits. */
443       if(uip_reassbitmap[uip_reasslen / (8 * 8)] !=
444          (u8_t)~bitmap_bits[uip_reasslen / 8 & 7]) {
445         goto nullreturn;
446       }
447
448       /* If we have come this far, we have a full packet in the
449          buffer, so we allocate a pbuf and copy the packet into it. We
450          also reset the timer. */
451       uip_reasstmr = 0;
452       memcpy(BUF, FBUF, uip_reasslen);
453
454       /* Pretend to be a "normal" (i.e., not fragmented) IP packet
455          from now on. */
456       BUF->ipoffset[0] = BUF->ipoffset[1] = 0;
457       BUF->len[0] = uip_reasslen >> 8;
458       BUF->len[1] = uip_reasslen & 0xff;
459       BUF->ipchksum = 0;
460       BUF->ipchksum = ~(uip_ipchksum());
461
462       return uip_reasslen;
463     }
464   }
465
466  nullreturn:
467   return 0;
468 }
469 #endif /* UIP_REASSEMBL */
470 /*-----------------------------------------------------------------------------------*/
471 static void
472 uip_add_rcv_nxt(u16_t n)
473 {
474   uip_add32(uip_conn->rcv_nxt, n);
475   uip_conn->rcv_nxt[0] = uip_acc32[0];
476   uip_conn->rcv_nxt[1] = uip_acc32[1];
477   uip_conn->rcv_nxt[2] = uip_acc32[2];
478   uip_conn->rcv_nxt[3] = uip_acc32[3];
479 }
480 /*-----------------------------------------------------------------------------------*/
481 void
482 uip_process(u8_t flag)
483 {
484   register struct uip_conn *uip_connr = uip_conn;
485   
486   uip_appdata = &uip_buf[40 + UIP_LLH_LEN];
487
488   
489   /* Check if we were invoked because of the perodic timer fireing. */
490   if(flag == UIP_TIMER) {
491 #if UIP_REASSEMBLY
492     if(uip_reasstmr != 0) {
493       --uip_reasstmr;
494     }
495 #endif /* UIP_REASSEMBLY */
496     /* Increase the initial sequence number. */
497     if(++iss[3] == 0) {
498       if(++iss[2] == 0) {
499         if(++iss[1] == 0) {
500           ++iss[0];
501         }
502       }
503     }    
504     uip_len = 0;
505     if(uip_connr->tcpstateflags == TIME_WAIT ||
506        uip_connr->tcpstateflags == FIN_WAIT_2) {
507       ++(uip_connr->timer);
508       if(uip_connr->timer == UIP_TIME_WAIT_TIMEOUT) {
509         uip_connr->tcpstateflags = CLOSED;
510       }
511     } else if(uip_connr->tcpstateflags != CLOSED) {
512       /* If the connection has outstanding data, we increase the
513          connection's timer and see if it has reached the RTO value
514          in which case we retransmit. */
515       if(uip_outstanding(uip_connr)) {
516         if(uip_connr->timer-- == 0) {
517           if(uip_connr->nrtx == UIP_MAXRTX ||
518              ((uip_connr->tcpstateflags == SYN_SENT ||
519                uip_connr->tcpstateflags == SYN_RCVD) &&
520               uip_connr->nrtx == UIP_MAXSYNRTX)) {
521             uip_connr->tcpstateflags = CLOSED;
522
523             /* We call UIP_APPCALL() with uip_flags set to
524                UIP_TIMEDOUT to inform the application that the
525                connection has timed out. */
526             uip_flags = UIP_TIMEDOUT;
527             UIP_APPCALL();
528
529             /* We also send a reset packet to the remote host. */
530             BUF->flags = TCP_RST | TCP_ACK;
531             goto tcp_send_nodata;
532           }
533
534           /* Exponential backoff. */
535           uip_connr->timer = UIP_RTO << (uip_connr->nrtx > 4?
536                                          4:
537                                          uip_connr->nrtx);
538           ++(uip_connr->nrtx);
539           
540           /* Ok, so we need to retransmit. We do this differently
541              depending on which state we are in. In ESTABLISHED, we
542              call upon the application so that it may prepare the
543              data for the retransmit. In SYN_RCVD, we resend the
544              SYNACK that we sent earlier and in LAST_ACK we have to
545              retransmit our FINACK. */
546           UIP_STAT(++uip_stat.tcp.rexmit);
547           switch(uip_connr->tcpstateflags & TS_MASK) {
548           case SYN_RCVD:
549             /* In the SYN_RCVD state, we should retransmit our
550                SYNACK. */
551             goto tcp_send_synack;
552             
553 #if UIP_ACTIVE_OPEN
554           case SYN_SENT:
555             /* In the SYN_SENT state, we retransmit out SYN. */
556             BUF->flags = 0;
557             goto tcp_send_syn;
558 #endif /* UIP_ACTIVE_OPEN */
559             
560           case ESTABLISHED:
561             /* In the ESTABLISHED state, we call upon the application
562                to do the actual retransmit after which we jump into
563                the code for sending out the packet (the apprexmit
564                label). */
565             uip_len = 0;
566             uip_slen = 0;
567             uip_flags = UIP_REXMIT;
568             UIP_APPCALL();
569             goto apprexmit;
570             
571           case FIN_WAIT_1:
572           case CLOSING:
573           case LAST_ACK:
574             /* In all these states we should retransmit a FINACK. */
575             goto tcp_send_finack;
576             
577           }
578         }
579       } else if((uip_connr->tcpstateflags & TS_MASK) == ESTABLISHED) {
580         /* If there was no need for a retransmission, we poll the
581            application for new data. */
582         uip_len = 0;
583         uip_slen = 0;
584         uip_flags = UIP_POLL;
585         UIP_APPCALL();
586         goto appsend;
587       }
588     }
589     goto drop;
590   }
591 #if UIP_UDP 
592   if(flag == UIP_UDP_TIMER) {
593     if(uip_udp_conn->lport != 0) {
594       uip_appdata = &uip_buf[UIP_LLH_LEN + 28];
595       uip_len = uip_slen = 0;
596       uip_flags = UIP_POLL;
597       UIP_UDP_APPCALL();
598       goto udp_send;
599     } else {
600       goto drop;
601     }
602   }
603 #endif
604
605   /* This is where the input processing starts. */
606   UIP_STAT(++uip_stat.ip.recv);
607
608
609   /* Start of IPv4 input header processing code. */
610   
611   /* Check validity of the IP header. */  
612   if(BUF->vhl != 0x45)  { /* IP version and header length. */
613     UIP_STAT(++uip_stat.ip.drop);
614     UIP_STAT(++uip_stat.ip.vhlerr);
615     UIP_LOG("ip: invalid version or header length.");
616     goto drop;
617   }
618   
619   /* Check the size of the packet. If the size reported to us in
620      uip_len doesn't match the size reported in the IP header, there
621      has been a transmission error and we drop the packet. */
622   
623   if(BUF->len[0] != (uip_len >> 8)) { /* IP length, high byte. */
624     uip_len = (uip_len & 0xff) | (BUF->len[0] << 8);
625   }
626   if(BUF->len[1] != (uip_len & 0xff)) { /* IP length, low byte. */
627     uip_len = (uip_len & 0xff00) | BUF->len[1];
628   }
629
630   /* Check the fragment flag. */
631   if((BUF->ipoffset[0] & 0x3f) != 0 ||
632      BUF->ipoffset[1] != 0) { 
633 #if UIP_REASSEMBLY
634     uip_len = uip_reass();
635     if(uip_len == 0) {
636       goto drop;
637     }
638 #else
639     UIP_STAT(++uip_stat.ip.drop);
640     UIP_STAT(++uip_stat.ip.fragerr);
641     UIP_LOG("ip: fragment dropped.");    
642     goto drop;
643 #endif /* UIP_REASSEMBLY */
644   }
645
646   /* If we are configured to use ping IP address configuration and
647      hasn't been assigned an IP address yet, we accept all ICMP
648      packets. */
649 #if UIP_PINGADDRCONF
650   if((uip_hostaddr[0] | uip_hostaddr[1]) == 0) {
651     if(BUF->proto == UIP_PROTO_ICMP) {
652       UIP_LOG("ip: possible ping config packet received.");
653       goto icmp_input;
654     } else {
655       UIP_LOG("ip: packet dropped since no address assigned.");
656       goto drop;
657     }
658   }
659 #endif /* UIP_PINGADDRCONF */
660   
661   /* Check if the packet is destined for our IP address. */  
662   if(BUF->destipaddr[0] != uip_hostaddr[0]) {
663     UIP_STAT(++uip_stat.ip.drop);
664     UIP_LOG("ip: packet not for us.");        
665     goto drop;
666   }
667   if(BUF->destipaddr[1] != uip_hostaddr[1]) {
668     UIP_STAT(++uip_stat.ip.drop);
669     UIP_LOG("ip: packet not for us.");        
670     goto drop;
671   }
672
673   if(uip_ipchksum() != 0xffff) { /* Compute and check the IP header
674                                     checksum. */
675     UIP_STAT(++uip_stat.ip.drop);
676     UIP_STAT(++uip_stat.ip.chkerr);
677     UIP_LOG("ip: bad checksum.");    
678     goto drop;
679   }
680
681   if(BUF->proto == UIP_PROTO_TCP)  /* Check for TCP packet. If so, jump
682                                      to the tcp_input label. */
683     goto tcp_input;
684
685 #if UIP_UDP
686   if(BUF->proto == UIP_PROTO_UDP)
687     goto udp_input;
688 #endif /* UIP_UDP */
689
690   if(BUF->proto != UIP_PROTO_ICMP) { /* We only allow ICMP packets from
691                                         here. */
692     UIP_STAT(++uip_stat.ip.drop);
693     UIP_STAT(++uip_stat.ip.protoerr);
694     UIP_LOG("ip: neither tcp nor icmp.");        
695     goto drop;
696   }
697   
698  icmp_input:
699   UIP_STAT(++uip_stat.icmp.recv);
700   
701   /* ICMP echo (i.e., ping) processing. This is simple, we only change
702      the ICMP type from ECHO to ECHO_REPLY and adjust the ICMP
703      checksum before we return the packet. */
704   if(ICMPBUF->type != ICMP_ECHO) {
705     UIP_STAT(++uip_stat.icmp.drop);
706     UIP_STAT(++uip_stat.icmp.typeerr);
707     UIP_LOG("icmp: not icmp echo.");
708     goto drop;
709   }
710
711   /* If we are configured to use ping IP address assignment, we use
712      the destination IP address of this ping packet and assign it to
713      ourself. */
714 #if UIP_PINGADDRCONF
715   if((uip_hostaddr[0] | uip_hostaddr[1]) == 0) {
716     uip_hostaddr[0] = BUF->destipaddr[0];
717     uip_hostaddr[1] = BUF->destipaddr[1];
718   }
719 #endif /* UIP_PINGADDRCONF */  
720   
721   ICMPBUF->type = ICMP_ECHO_REPLY;
722   
723   if(ICMPBUF->icmpchksum >= HTONS(0xffff - (ICMP_ECHO << 8))) {
724     ICMPBUF->icmpchksum += HTONS(ICMP_ECHO << 8) + 1;
725   } else {
726     ICMPBUF->icmpchksum += HTONS(ICMP_ECHO << 8);
727   }
728   
729   /* Swap IP addresses. */
730   tmp16 = BUF->destipaddr[0];
731   BUF->destipaddr[0] = BUF->srcipaddr[0];
732   BUF->srcipaddr[0] = tmp16;
733   tmp16 = BUF->destipaddr[1];
734   BUF->destipaddr[1] = BUF->srcipaddr[1];
735   BUF->srcipaddr[1] = tmp16;
736
737   UIP_STAT(++uip_stat.icmp.sent);
738   goto send;
739
740   /* End of IPv4 input header processing code. */
741   
742
743 #if UIP_UDP
744   /* UDP input processing. */
745  udp_input:
746   /* UDP processing is really just a hack. We don't do anything to the
747      UDP/IP headers, but let the UDP application do all the hard
748      work. If the application sets uip_slen, it has a packet to
749      send. */
750 #if UIP_UDP_CHECKSUMS
751   if(uip_udpchksum() != 0xffff) { 
752     UIP_STAT(++uip_stat.udp.drop);
753     UIP_STAT(++uip_stat.udp.chkerr);
754     UIP_LOG("udp: bad checksum.");    
755     goto drop;
756   }  
757 #endif /* UIP_UDP_CHECKSUMS */
758
759   /* Demultiplex this UDP packet between the UDP "connections". */
760   for(uip_udp_conn = &uip_udp_conns[0];
761       uip_udp_conn < &uip_udp_conns[UIP_UDP_CONNS];
762       ++uip_udp_conn) {
763     if(uip_udp_conn->lport != 0 &&
764        UDPBUF->destport == uip_udp_conn->lport &&
765        (uip_udp_conn->rport == 0 ||
766         UDPBUF->srcport == uip_udp_conn->rport) &&
767        BUF->srcipaddr[0] == uip_udp_conn->ripaddr[0] &&
768        BUF->srcipaddr[1] == uip_udp_conn->ripaddr[1]) {
769       goto udp_found; 
770     }
771   }
772   goto drop;
773   
774  udp_found:
775   uip_len = uip_len - 28;
776   uip_appdata = &uip_buf[UIP_LLH_LEN + 28];
777   uip_flags = UIP_NEWDATA;
778   uip_slen = 0;
779   UIP_UDP_APPCALL();
780  udp_send:
781   if(uip_slen == 0) {
782     goto drop;      
783   }
784   uip_len = uip_slen + 28;
785
786   BUF->len[0] = (uip_len >> 8);
787   BUF->len[1] = (uip_len & 0xff);
788   
789   BUF->proto = UIP_PROTO_UDP;
790
791   UDPBUF->udplen = HTONS(uip_slen + 8);
792   UDPBUF->udpchksum = 0;
793 #if UIP_UDP_CHECKSUMS 
794   /* Calculate UDP checksum. */
795   UDPBUF->udpchksum = ~(uip_udpchksum());
796   if(UDPBUF->udpchksum == 0) {
797     UDPBUF->udpchksum = 0xffff;
798   }
799 #endif /* UIP_UDP_CHECKSUMS */
800
801   BUF->srcport  = uip_udp_conn->lport;
802   BUF->destport = uip_udp_conn->rport;
803
804   BUF->srcipaddr[0] = uip_hostaddr[0];
805   BUF->srcipaddr[1] = uip_hostaddr[1];
806   BUF->destipaddr[0] = uip_udp_conn->ripaddr[0];
807   BUF->destipaddr[1] = uip_udp_conn->ripaddr[1];
808  
809   uip_appdata = &uip_buf[UIP_LLH_LEN + 40];
810   goto ip_send_nolen;
811 #endif /* UIP_UDP */
812   
813   /* TCP input processing. */  
814  tcp_input:
815   UIP_STAT(++uip_stat.tcp.recv);
816
817   /* Start of TCP input header processing code. */
818   
819   if(uip_tcpchksum() != 0xffff) {   /* Compute and check the TCP
820                                        checksum. */
821     UIP_STAT(++uip_stat.tcp.drop);
822     UIP_STAT(++uip_stat.tcp.chkerr);
823     UIP_LOG("tcp: bad checksum.");    
824     goto drop;
825   }
826   
827   /* Demultiplex this segment. */
828   /* First check any active connections. */
829   for(uip_connr = &uip_conns[0]; uip_connr < &uip_conns[UIP_CONNS]; ++uip_connr) {
830     if(uip_connr->tcpstateflags != CLOSED &&
831        BUF->destport == uip_connr->lport &&
832        BUF->srcport == uip_connr->rport &&
833        BUF->srcipaddr[0] == uip_connr->ripaddr[0] &&
834        BUF->srcipaddr[1] == uip_connr->ripaddr[1]) {
835       goto found;    
836     }
837   }
838
839   /* If we didn't find and active connection that expected the packet,
840      either this packet is an old duplicate, or this is a SYN packet
841      destined for a connection in LISTEN. If the SYN flag isn't set,
842      it is an old packet and we send a RST. */
843   if((BUF->flags & TCP_CTL) != TCP_SYN)
844     goto reset;
845   
846   tmp16 = BUF->destport;
847   /* Next, check listening connections. */  
848   for(c = 0; c < UIP_LISTENPORTS; ++c) {
849     if(tmp16 == uip_listenports[c])
850       goto found_listen;
851   }
852   
853   /* No matching connection found, so we send a RST packet. */
854   UIP_STAT(++uip_stat.tcp.synrst);
855  reset:
856
857   /* We do not send resets in response to resets. */
858   if(BUF->flags & TCP_RST) 
859     goto drop;
860
861   UIP_STAT(++uip_stat.tcp.rst);
862   
863   BUF->flags = TCP_RST | TCP_ACK;
864   uip_len = 40;
865   BUF->tcpoffset = 5 << 4;
866
867   /* Flip the seqno and ackno fields in the TCP header. */
868   c = BUF->seqno[3];
869   BUF->seqno[3] = BUF->ackno[3];  
870   BUF->ackno[3] = c;
871   
872   c = BUF->seqno[2];
873   BUF->seqno[2] = BUF->ackno[2];  
874   BUF->ackno[2] = c;
875   
876   c = BUF->seqno[1];
877   BUF->seqno[1] = BUF->ackno[1];
878   BUF->ackno[1] = c;
879   
880   c = BUF->seqno[0];
881   BUF->seqno[0] = BUF->ackno[0];  
882   BUF->ackno[0] = c;
883
884   /* We also have to increase the sequence number we are
885      acknowledging. If the least significant byte overflowed, we need
886      to propagate the carry to the other bytes as well. */
887   if(++BUF->ackno[3] == 0) {
888     if(++BUF->ackno[2] == 0) {
889       if(++BUF->ackno[1] == 0) {
890         ++BUF->ackno[0];
891       }
892     }
893   }
894  
895   /* Swap port numbers. */
896   tmp16 = BUF->srcport;
897   BUF->srcport = BUF->destport;
898   BUF->destport = tmp16;
899   
900   /* Swap IP addresses. */
901   tmp16 = BUF->destipaddr[0];
902   BUF->destipaddr[0] = BUF->srcipaddr[0];
903   BUF->srcipaddr[0] = tmp16;
904   tmp16 = BUF->destipaddr[1];
905   BUF->destipaddr[1] = BUF->srcipaddr[1];
906   BUF->srcipaddr[1] = tmp16;
907
908   
909   /* And send out the RST packet! */
910   goto tcp_send_noconn;
911
912   /* This label will be jumped to if we matched the incoming packet
913      with a connection in LISTEN. In that case, we should create a new
914      connection and send a SYNACK in return. */
915  found_listen:
916   /* First we check if there are any connections avaliable. Unused
917      connections are kept in the same table as used connections, but
918      unused ones have the tcpstate set to CLOSED. Also, connections in
919      TIME_WAIT are kept track of and we'll use the oldest one if no
920      CLOSED connections are found. Thanks to Eddie C. Dost for a very
921      nice algorithm for the TIME_WAIT search. */
922   uip_connr = 0;
923   for(c = 0; c < UIP_CONNS; ++c) {
924     if(uip_conns[c].tcpstateflags == CLOSED) {
925       uip_connr = &uip_conns[c];
926       break;
927     }
928     if(uip_conns[c].tcpstateflags == TIME_WAIT) {
929       if(uip_connr == 0 ||
930          uip_conns[c].timer > uip_connr->timer) {
931         uip_connr = &uip_conns[c];
932       }
933     }
934   }
935
936   if(uip_connr == 0) {
937     /* All connections are used already, we drop packet and hope that
938        the remote end will retransmit the packet at a time when we
939        have more spare connections. */
940     UIP_STAT(++uip_stat.tcp.syndrop);
941     UIP_LOG("tcp: found no unused connections.");
942     goto drop;
943   }
944   uip_conn = uip_connr;
945   
946   /* Fill in the necessary fields for the new connection. */
947   uip_connr->rto = uip_connr->timer = UIP_RTO;
948   uip_connr->sa = 0;
949   uip_connr->sv = 4;  
950   uip_connr->nrtx = 0;
951   uip_connr->lport = BUF->destport;
952   uip_connr->rport = BUF->srcport;
953   uip_connr->ripaddr[0] = BUF->srcipaddr[0];
954   uip_connr->ripaddr[1] = BUF->srcipaddr[1];
955   uip_connr->tcpstateflags = SYN_RCVD;
956
957   uip_connr->snd_nxt[0] = iss[0];
958   uip_connr->snd_nxt[1] = iss[1];
959   uip_connr->snd_nxt[2] = iss[2];
960   uip_connr->snd_nxt[3] = iss[3];
961   uip_connr->len = 1;
962
963   /* rcv_nxt should be the seqno from the incoming packet + 1. */
964   uip_connr->rcv_nxt[3] = BUF->seqno[3];
965   uip_connr->rcv_nxt[2] = BUF->seqno[2];
966   uip_connr->rcv_nxt[1] = BUF->seqno[1];
967   uip_connr->rcv_nxt[0] = BUF->seqno[0];
968   uip_add_rcv_nxt(1);
969
970   /* Parse the TCP MSS option, if present. */
971   if((BUF->tcpoffset & 0xf0) > 0x50) {
972     for(c = 0; c < ((BUF->tcpoffset >> 4) - 5) << 2 ;) {
973       opt = uip_buf[UIP_TCPIP_HLEN + UIP_LLH_LEN + c];
974       if(opt == 0x00) {
975         /* End of options. */   
976         break;
977       } else if(opt == 0x01) {
978         ++c;
979         /* NOP option. */
980       } else if(opt == 0x02 &&
981                 uip_buf[UIP_TCPIP_HLEN + UIP_LLH_LEN + 1 + c] == 0x04) {
982         /* An MSS option with the right option length. */       
983         tmp16 = ((u16_t)uip_buf[UIP_TCPIP_HLEN + UIP_LLH_LEN + 2 + c] << 8) |
984           (u16_t)uip_buf[40 + UIP_LLH_LEN + 3 + c];
985         uip_connr->initialmss = uip_connr->mss =
986           tmp16 > UIP_TCP_MSS? UIP_TCP_MSS: tmp16;
987         
988         /* And we are done processing options. */
989         break;
990       } else {
991         /* All other options have a length field, so that we easily
992            can skip past them. */
993         if(uip_buf[UIP_TCPIP_HLEN + UIP_LLH_LEN + 1 + c] == 0) {
994           /* If the length field is zero, the options are malformed
995              and we don't process them further. */
996           break;
997         }
998         c += uip_buf[UIP_TCPIP_HLEN + UIP_LLH_LEN + 1 + c];
999       }      
1000     }
1001   }
1002   
1003   /* Our response will be a SYNACK. */
1004 #if UIP_ACTIVE_OPEN
1005  tcp_send_synack:
1006   BUF->flags = TCP_ACK;    
1007   
1008  tcp_send_syn:
1009   BUF->flags |= TCP_SYN;    
1010 #else /* UIP_ACTIVE_OPEN */
1011  tcp_send_synack:
1012   BUF->flags = TCP_SYN | TCP_ACK;    
1013 #endif /* UIP_ACTIVE_OPEN */
1014   
1015   /* We send out the TCP Maximum Segment Size option with our
1016      SYNACK. */
1017   BUF->optdata[0] = 2;
1018   BUF->optdata[1] = 4;
1019   BUF->optdata[2] = (UIP_TCP_MSS) / 256;
1020   BUF->optdata[3] = (UIP_TCP_MSS) & 255;
1021   uip_len = 44;
1022   BUF->tcpoffset = 6 << 4;
1023   goto tcp_send;
1024
1025   /* This label will be jumped to if we found an active connection. */
1026  found:
1027   uip_conn = uip_connr;
1028   uip_flags = 0;
1029
1030   /* We do a very naive form of TCP reset processing; we just accept
1031      any RST and kill our connection. We should in fact check if the
1032      sequence number of this reset is wihtin our advertised window
1033      before we accept the reset. */
1034   if(BUF->flags & TCP_RST) {
1035     uip_connr->tcpstateflags = CLOSED;
1036     UIP_LOG("tcp: got reset, aborting connection.");
1037     uip_flags = UIP_ABORT;
1038     UIP_APPCALL();
1039     goto drop;
1040   }      
1041   /* Calculated the length of the data, if the application has sent
1042      any data to us. */
1043   c = (BUF->tcpoffset >> 4) << 2;
1044   /* uip_len will contain the length of the actual TCP data. This is
1045      calculated by subtracing the length of the TCP header (in
1046      c) and the length of the IP header (20 bytes). */
1047   uip_len = uip_len - c - 20;
1048
1049   /* First, check if the sequence number of the incoming packet is
1050      what we're expecting next. If not, we send out an ACK with the
1051      correct numbers in. */
1052   if(uip_len > 0 &&
1053      (BUF->seqno[0] != uip_connr->rcv_nxt[0] ||
1054       BUF->seqno[1] != uip_connr->rcv_nxt[1] ||
1055       BUF->seqno[2] != uip_connr->rcv_nxt[2] ||
1056       BUF->seqno[3] != uip_connr->rcv_nxt[3])) {
1057     goto tcp_send_ack;
1058   }
1059
1060   /* Next, check if the incoming segment acknowledges any outstanding
1061      data. If so, we update the sequence number, reset the length of
1062      the outstanding data, calculate RTT estimations, and reset the
1063      retransmission timer. */
1064   if((BUF->flags & TCP_ACK) && uip_outstanding(uip_connr)) {
1065     uip_add32(uip_connr->snd_nxt, uip_connr->len);
1066     if(BUF->ackno[0] == uip_acc32[0] &&
1067        BUF->ackno[1] == uip_acc32[1] &&
1068        BUF->ackno[2] == uip_acc32[2] &&
1069        BUF->ackno[3] == uip_acc32[3]) {
1070       /* Update sequence number. */
1071       uip_connr->snd_nxt[0] = uip_acc32[0];
1072       uip_connr->snd_nxt[1] = uip_acc32[1];
1073       uip_connr->snd_nxt[2] = uip_acc32[2];
1074       uip_connr->snd_nxt[3] = uip_acc32[3];
1075         
1076
1077       /* Do RTT estimation, unless we have done retransmissions. */
1078       if(uip_connr->nrtx == 0) {
1079         signed char m;
1080         m = uip_connr->rto - uip_connr->timer;
1081         /* This is taken directly from VJs original code in his paper */
1082         m = m - (uip_connr->sa >> 3);
1083         uip_connr->sa += m;
1084         if(m < 0) {
1085           m = -m;
1086         }
1087         m = m - (uip_connr->sv >> 2);
1088         uip_connr->sv += m;
1089         uip_connr->rto = (uip_connr->sa >> 3) + uip_connr->sv;
1090
1091       }
1092       /* Set the acknowledged flag. */
1093       uip_flags = UIP_ACKDATA;
1094       /* Reset the retransmission timer. */
1095       uip_connr->timer = uip_connr->rto;
1096     }
1097     
1098   }
1099
1100   /* Do different things depending on in what state the connection is. */
1101   switch(uip_connr->tcpstateflags & TS_MASK) {
1102     /* CLOSED and LISTEN are not handled here. CLOSE_WAIT is not
1103         implemented, since we force the application to close when the
1104         peer sends a FIN (hence the application goes directly from
1105         ESTABLISHED to LAST_ACK). */
1106   case SYN_RCVD:
1107     /* In SYN_RCVD we have sent out a SYNACK in response to a SYN, and
1108        we are waiting for an ACK that acknowledges the data we sent
1109        out the last time. Therefore, we want to have the UIP_ACKDATA
1110        flag set. If so, we enter the ESTABLISHED state. */
1111     if(uip_flags & UIP_ACKDATA) {
1112       uip_connr->tcpstateflags = ESTABLISHED;
1113       uip_flags = UIP_CONNECTED;
1114       uip_connr->len = 0;
1115       if(uip_len > 0) {
1116         uip_flags |= UIP_NEWDATA;
1117         uip_add_rcv_nxt(uip_len);
1118       }
1119       uip_slen = 0;
1120       UIP_APPCALL();
1121       goto appsend;
1122     }
1123     goto drop;
1124 #if UIP_ACTIVE_OPEN
1125   case SYN_SENT:
1126     /* In SYN_SENT, we wait for a SYNACK that is sent in response to
1127        our SYN. The rcv_nxt is set to sequence number in the SYNACK
1128        plus one, and we send an ACK. We move into the ESTABLISHED
1129        state. */
1130     if((uip_flags & UIP_ACKDATA) &&
1131        BUF->flags == (TCP_SYN | TCP_ACK)) {
1132
1133       /* Parse the TCP MSS option, if present. */
1134       if((BUF->tcpoffset & 0xf0) > 0x50) {
1135         for(c = 0; c < ((BUF->tcpoffset >> 4) - 5) << 2 ;) {
1136           opt = uip_buf[40 + UIP_LLH_LEN + c];
1137           if(opt == 0x00) {
1138             /* End of options. */       
1139             break;
1140           } else if(opt == 0x01) {
1141             ++c;
1142             /* NOP option. */
1143           } else if(opt == 0x02 &&
1144                     uip_buf[UIP_TCPIP_HLEN + UIP_LLH_LEN + 1 + c] == 0x04) {
1145             /* An MSS option with the right option length. */
1146             tmp16 = (uip_buf[UIP_TCPIP_HLEN + UIP_LLH_LEN + 2 + c] << 8) |
1147               uip_buf[UIP_TCPIP_HLEN + UIP_LLH_LEN + 3 + c];
1148             uip_connr->initialmss =
1149               uip_connr->mss = tmp16 > UIP_TCP_MSS? UIP_TCP_MSS: tmp16;
1150
1151             /* And we are done processing options. */
1152             break;
1153           } else {
1154             /* All other options have a length field, so that we easily
1155                can skip past them. */
1156             if(uip_buf[UIP_TCPIP_HLEN + UIP_LLH_LEN + 1 + c] == 0) {
1157               /* If the length field is zero, the options are malformed
1158                  and we don't process them further. */
1159               break;
1160             }
1161             c += uip_buf[UIP_TCPIP_HLEN + UIP_LLH_LEN + 1 + c];
1162           }      
1163         }
1164       }
1165       uip_connr->tcpstateflags = ESTABLISHED;      
1166       uip_connr->rcv_nxt[0] = BUF->seqno[0];
1167       uip_connr->rcv_nxt[1] = BUF->seqno[1];
1168       uip_connr->rcv_nxt[2] = BUF->seqno[2];
1169       uip_connr->rcv_nxt[3] = BUF->seqno[3];
1170       uip_add_rcv_nxt(1);
1171       uip_flags = UIP_CONNECTED | UIP_NEWDATA;
1172       uip_connr->len = 0;
1173       uip_len = 0;
1174       uip_slen = 0;
1175       UIP_APPCALL();
1176       goto appsend;
1177     }
1178     goto reset;
1179 #endif /* UIP_ACTIVE_OPEN */
1180     
1181   case ESTABLISHED:
1182     /* In the ESTABLISHED state, we call upon the application to feed
1183     data into the uip_buf. If the UIP_ACKDATA flag is set, the
1184     application should put new data into the buffer, otherwise we are
1185     retransmitting an old segment, and the application should put that
1186     data into the buffer.
1187
1188     If the incoming packet is a FIN, we should close the connection on
1189     this side as well, and we send out a FIN and enter the LAST_ACK
1190     state. We require that there is no outstanding data; otherwise the
1191     sequence numbers will be screwed up. */
1192
1193     if(BUF->flags & TCP_FIN) {
1194       if(uip_outstanding(uip_connr)) {
1195         goto drop;
1196       }
1197       uip_add_rcv_nxt(1 + uip_len);      
1198       uip_flags = UIP_CLOSE;
1199       if(uip_len > 0) {
1200         uip_flags |= UIP_NEWDATA;
1201       }
1202       UIP_APPCALL();
1203       uip_connr->len = 1;
1204       uip_connr->tcpstateflags = LAST_ACK;
1205       uip_connr->nrtx = 0;
1206     tcp_send_finack:
1207       BUF->flags = TCP_FIN | TCP_ACK;      
1208       goto tcp_send_nodata;
1209     }
1210
1211     /* Check the URG flag. If this is set, the segment carries urgent
1212        data that we must pass to the application. */
1213     if(BUF->flags & TCP_URG) {
1214 #if UIP_URGDATA > 0
1215       uip_urglen = (BUF->urgp[0] << 8) | BUF->urgp[1];
1216       if(uip_urglen > uip_len) {
1217         /* There is more urgent data in the next segment to come. */
1218         uip_urglen = uip_len;
1219       }
1220       uip_add_rcv_nxt(uip_urglen);
1221       uip_len -= uip_urglen;
1222       uip_urgdata = uip_appdata;
1223       uip_appdata += uip_urglen;
1224     } else {
1225       uip_urglen = 0;
1226 #endif /* UIP_URGDATA > 0 */
1227       uip_appdata += (BUF->urgp[0] << 8) | BUF->urgp[1];
1228       uip_len -= (BUF->urgp[0] << 8) | BUF->urgp[1];
1229     }
1230     
1231     
1232     /* If uip_len > 0 we have TCP data in the packet, and we flag this
1233        by setting the UIP_NEWDATA flag and update the sequence number
1234        we acknowledge. If the application has stopped the dataflow
1235        using uip_stop(), we must not accept any data packets from the
1236        remote host. */
1237     if(uip_len > 0 && !(uip_connr->tcpstateflags & UIP_STOPPED)) {
1238       uip_flags |= UIP_NEWDATA;
1239       uip_add_rcv_nxt(uip_len);
1240     }
1241
1242     /* Check if the available buffer space advertised by the other end
1243        is smaller than the initial MSS for this connection. If so, we
1244        set the current MSS to the window size to ensure that the
1245        application does not send more data than the other end can
1246        handle.
1247
1248        If the remote host advertises a zero window, we set the MSS to
1249        the initial MSS so that the application will send an entire MSS
1250        of data. This data will not be acknowledged by the receiver,
1251        and the application will retransmit it. This is called the
1252        "persistent timer" and uses the retransmission mechanim.
1253     */
1254     tmp16 = ((u16_t)BUF->wnd[0] << 8) + (u16_t)BUF->wnd[1];
1255     if(tmp16 > uip_connr->initialmss ||
1256        tmp16 == 0) {
1257       tmp16 = uip_connr->initialmss;
1258     }
1259     uip_connr->mss = tmp16;
1260
1261     /* If this packet constitutes an ACK for outstanding data (flagged
1262        by the UIP_ACKDATA flag, we should call the application since it
1263        might want to send more data. If the incoming packet had data
1264        from the peer (as flagged by the UIP_NEWDATA flag), the
1265        application must also be notified.
1266
1267        When the application is called, the global variable uip_len
1268        contains the length of the incoming data. The application can
1269        access the incoming data through the global pointer
1270        uip_appdata, which usually points 40 bytes into the uip_buf
1271        array.
1272
1273        If the application wishes to send any data, this data should be
1274        put into the uip_appdata and the length of the data should be
1275        put into uip_len. If the application don't have any data to
1276        send, uip_len must be set to 0. */
1277     if(uip_flags & (UIP_NEWDATA | UIP_ACKDATA)) {
1278       uip_slen = 0;
1279       UIP_APPCALL();
1280
1281     appsend:
1282       
1283       if(uip_flags & UIP_ABORT) {
1284         uip_slen = 0;
1285         uip_connr->tcpstateflags = CLOSED;
1286         BUF->flags = TCP_RST | TCP_ACK;
1287         goto tcp_send_nodata;
1288       }
1289
1290       if(uip_flags & UIP_CLOSE) {
1291         uip_slen = 0;
1292         uip_connr->len = 1;
1293         uip_connr->tcpstateflags = FIN_WAIT_1;
1294         uip_connr->nrtx = 0;
1295         BUF->flags = TCP_FIN | TCP_ACK;
1296         goto tcp_send_nodata;   
1297       }
1298
1299       /* If uip_slen > 0, the application has data to be sent. */
1300       if(uip_slen > 0) {
1301
1302         /* If the connection has acknowledged data, the contents of
1303            the ->len variable should be discarded. */ 
1304         if((uip_flags & UIP_ACKDATA) != 0) {
1305           uip_connr->len = 0;
1306         }
1307
1308         /* If the ->len variable is non-zero the connection has
1309            already data in transit and cannot send anymore right
1310            now. */
1311         if(uip_connr->len == 0) {
1312
1313           /* The application cannot send more than what is allowed by
1314              the mss (the minumum of the MSS and the available
1315              window). */
1316           if(uip_slen > uip_connr->mss) {
1317             uip_slen = uip_connr->mss;
1318           }
1319
1320           /* Remember how much data we send out now so that we know
1321              when everything has been acknowledged. */
1322           uip_connr->len = uip_slen;
1323         } else {
1324
1325           /* If the application already had unacknowledged data, we
1326              make sure that the application does not send (i.e.,
1327              retransmit) out more than it previously sent out. */
1328           uip_slen = uip_connr->len;
1329         }
1330       } else {
1331         uip_connr->len = 0;
1332       }
1333       uip_connr->nrtx = 0;
1334     apprexmit:
1335       uip_appdata = uip_sappdata;
1336       
1337       /* If the application has data to be sent, or if the incoming
1338          packet had new data in it, we must send out a packet. */
1339       if(uip_slen > 0 && uip_connr->len > 0) {
1340         /* Add the length of the IP and TCP headers. */
1341         uip_len = uip_connr->len + UIP_TCPIP_HLEN;
1342         /* We always set the ACK flag in response packets. */
1343         BUF->flags = TCP_ACK | TCP_PSH;
1344         /* Send the packet. */
1345         goto tcp_send_noopts;
1346       }
1347       /* If there is no data to send, just send out a pure ACK if
1348          there is newdata. */
1349       if(uip_flags & UIP_NEWDATA) {
1350         uip_len = UIP_TCPIP_HLEN;
1351         BUF->flags = TCP_ACK;
1352         goto tcp_send_noopts;
1353       }
1354     }
1355     goto drop;
1356   case LAST_ACK:
1357     /* We can close this connection if the peer has acknowledged our
1358        FIN. This is indicated by the UIP_ACKDATA flag. */     
1359     if(uip_flags & UIP_ACKDATA) {
1360       uip_connr->tcpstateflags = CLOSED;
1361       uip_flags = UIP_CLOSE;
1362       UIP_APPCALL();
1363     }
1364     break;
1365     
1366   case FIN_WAIT_1:
1367     /* The application has closed the connection, but the remote host
1368        hasn't closed its end yet. Thus we do nothing but wait for a
1369        FIN from the other side. */
1370     if(uip_len > 0) {
1371       uip_add_rcv_nxt(uip_len);
1372     }
1373     if(BUF->flags & TCP_FIN) {
1374       if(uip_flags & UIP_ACKDATA) {
1375         uip_connr->tcpstateflags = TIME_WAIT;
1376         uip_connr->timer = 0;
1377         uip_connr->len = 0;
1378       } else {
1379         uip_connr->tcpstateflags = CLOSING;
1380       }
1381       uip_add_rcv_nxt(1);
1382       uip_flags = UIP_CLOSE;
1383       UIP_APPCALL();
1384       goto tcp_send_ack;
1385     } else if(uip_flags & UIP_ACKDATA) {
1386       uip_connr->tcpstateflags = FIN_WAIT_2;
1387       uip_connr->len = 0;
1388       goto drop;
1389     }
1390     if(uip_len > 0) {
1391       goto tcp_send_ack;
1392     }
1393     goto drop;
1394       
1395   case FIN_WAIT_2:
1396     if(uip_len > 0) {
1397       uip_add_rcv_nxt(uip_len);
1398     }
1399     if(BUF->flags & TCP_FIN) {
1400       uip_connr->tcpstateflags = TIME_WAIT;
1401       uip_connr->timer = 0;
1402       uip_add_rcv_nxt(1);
1403       uip_flags = UIP_CLOSE;
1404       UIP_APPCALL();
1405       goto tcp_send_ack;
1406     }
1407     if(uip_len > 0) {
1408       goto tcp_send_ack;
1409     }
1410     goto drop;
1411
1412   case TIME_WAIT:
1413     goto tcp_send_ack;
1414     
1415   case CLOSING:
1416     if(uip_flags & UIP_ACKDATA) {
1417       uip_connr->tcpstateflags = TIME_WAIT;
1418       uip_connr->timer = 0;
1419     }
1420   }  
1421   goto drop;
1422   
1423
1424   /* We jump here when we are ready to send the packet, and just want
1425      to set the appropriate TCP sequence numbers in the TCP header. */
1426  tcp_send_ack:
1427   BUF->flags = TCP_ACK;
1428  tcp_send_nodata:
1429   uip_len = 40;
1430  tcp_send_noopts:
1431   BUF->tcpoffset = 5 << 4;
1432  tcp_send:
1433   /* We're done with the input processing. We are now ready to send a
1434      reply. Our job is to fill in all the fields of the TCP and IP
1435      headers before calculating the checksum and finally send the
1436      packet. */
1437   BUF->ackno[0] = uip_connr->rcv_nxt[0];
1438   BUF->ackno[1] = uip_connr->rcv_nxt[1];
1439   BUF->ackno[2] = uip_connr->rcv_nxt[2];
1440   BUF->ackno[3] = uip_connr->rcv_nxt[3];
1441   
1442   BUF->seqno[0] = uip_connr->snd_nxt[0];
1443   BUF->seqno[1] = uip_connr->snd_nxt[1];
1444   BUF->seqno[2] = uip_connr->snd_nxt[2];
1445   BUF->seqno[3] = uip_connr->snd_nxt[3];
1446
1447   BUF->proto = UIP_PROTO_TCP;
1448   
1449   BUF->srcport  = uip_connr->lport;
1450   BUF->destport = uip_connr->rport;
1451
1452   BUF->srcipaddr[0] = uip_hostaddr[0];
1453   BUF->srcipaddr[1] = uip_hostaddr[1];
1454   BUF->destipaddr[0] = uip_connr->ripaddr[0];
1455   BUF->destipaddr[1] = uip_connr->ripaddr[1];
1456  
1457
1458   if(uip_connr->tcpstateflags & UIP_STOPPED) {
1459     /* If the connection has issued uip_stop(), we advertise a zero
1460        window so that the remote host will stop sending data. */
1461     BUF->wnd[0] = BUF->wnd[1] = 0;
1462   } else {
1463     BUF->wnd[0] = ((UIP_RECEIVE_WINDOW) >> 8);
1464     BUF->wnd[1] = ((UIP_RECEIVE_WINDOW) & 0xff); 
1465   }
1466
1467  tcp_send_noconn:
1468
1469   BUF->len[0] = (uip_len >> 8);
1470   BUF->len[1] = (uip_len & 0xff);
1471
1472   /* Calculate TCP checksum. */
1473   BUF->tcpchksum = 0;
1474   BUF->tcpchksum = ~(uip_tcpchksum());
1475   
1476  ip_send_nolen:
1477
1478   BUF->vhl = 0x45;
1479   BUF->tos = 0;
1480   BUF->ipoffset[0] = BUF->ipoffset[1] = 0;
1481   BUF->ttl  = UIP_TTL;
1482   ++ipid;
1483   BUF->ipid[0] = ipid >> 8;
1484   BUF->ipid[1] = ipid & 0xff;
1485   
1486   /* Calculate IP checksum. */
1487   BUF->ipchksum = 0;
1488   BUF->ipchksum = ~(uip_ipchksum());
1489
1490   UIP_STAT(++uip_stat.tcp.sent);
1491  send:
1492   UIP_STAT(++uip_stat.ip.sent);
1493   /* Return and let the caller do the actual transmission. */
1494   return;
1495  drop:
1496   uip_len = 0;
1497   return;
1498 }
1499 /** @} */