projects / pub / USBasp.git / blob
? search:


1abefd5dcc2d5579449be21f05d7f603555680b2
[pub/USBasp.git] / Projects / Webserver / Lib / uip / uip.c
1 #define DEBUG_PRINTF(...) /*printf(__VA_ARGS__)*/
2
3 /**
4 * \addtogroup uip
5 * @{
6 */
7
8 /**
9 * \file
10 * The uIP TCP/IP stack code.
11 * \author Adam Dunkels <adam@dunkels.com>
12 */
13
14 /*
15 * Copyright (c) 2001-2003, Adam Dunkels.
16 * All rights reserved.
17 *
18 * Redistribution and use in source and binary forms, with or without
19 * modification, are permitted provided that the following conditions
20 * are met:
21 * 1. Redistributions of source code must retain the above copyright
22 * notice, this list of conditions and the following disclaimer.
23 * 2. Redistributions in binary form must reproduce the above copyright
24 * notice, this list of conditions and the following disclaimer in the
25 * documentation and/or other materials provided with the distribution.
26 * 3. The name of the author may not be used to endorse or promote
27 * products derived from this software without specific prior
28 * written permission.
29 *
30 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS
31 * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
32 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
33 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
34 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
35 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
36 * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
37 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
38 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
39 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
40 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
41 *
42 * This file is part of the uIP TCP/IP stack.
43 *
44 * $Id: uip.c,v 1.15 2008/10/15 08:08:32 adamdunkels Exp $
45 *
46 */
47
48 /*
49 * uIP is a small implementation of the IP, UDP and TCP protocols (as
50 * well as some basic ICMP stuff). The implementation couples the IP,
51 * UDP, TCP and the application layers very tightly. To keep the size
52 * of the compiled code down, this code frequently uses the goto
53 * statement. While it would be possible to break the uip_process()
54 * function into many smaller functions, this would increase the code
55 * size because of the overhead of parameter passing and the fact that
56 * the optimier would not be as efficient.
57 *
58 * The principle is that we have a small buffer, called the uip_buf,
59 * in which the device driver puts an incoming packet. The TCP/IP
60 * stack parses the headers in the packet, and calls the
61 * application. If the remote host has sent data to the application,
62 * this data is present in the uip_buf and the application read the
63 * data from there. It is up to the application to put this data into
64 * a byte stream if needed. The application will not be fed with data
65 * that is out of sequence.
66 *
67 * If the application whishes to send data to the peer, it should put
68 * its data into the uip_buf. The uip_appdata pointer points to the
69 * first available byte. The TCP/IP stack will calculate the
70 * checksums, and fill in the necessary header fields and finally send
71 * the packet back to the peer.
72 */
73
74 #include "uip.h"
75 #include "uipopt.h"
76 #include "uip_arp.h"
77
78 #if !UIP_CONF_IPV6 /* If UIP_CONF_IPV6 is defined, we compile the
79 uip6.c file instead of this one. Therefore
80 this #ifndef removes the entire compilation
81 output of the uip.c file */
82
83
84 #if UIP_CONF_IPV6
85 #include "net/uip-neighbor.h"
86 #endif /* UIP_CONF_IPV6 */
87
88 #include <string.h>
89
90 /*---------------------------------------------------------------------------*/
91 /* Variable definitions. */
92
93
94 /* The IP address of this host. If it is defined to be fixed (by
95 setting UIP_FIXEDADDR to 1 in uipopt.h), the address is set
96 here. Otherwise, the address */
97 #if UIP_FIXEDADDR > 0
98 const uip_ipaddr_t uip_hostaddr =
99 { UIP_IPADDR0, UIP_IPADDR1, UIP_IPADDR2, UIP_IPADDR3 };
100 const uip_ipaddr_t uip_draddr =
101 { UIP_DRIPADDR0, UIP_DRIPADDR1, UIP_DRIPADDR2, UIP_DRIPADDR3 };
102 const uip_ipaddr_t uip_netmask =
103 { UIP_NETMASK0, UIP_NETMASK1, UIP_NETMASK2, UIP_NETMASK3 };
104 #else
105 uip_ipaddr_t uip_hostaddr, uip_draddr, uip_netmask;
106 #endif /* UIP_FIXEDADDR */
107
108 const uip_ipaddr_t uip_broadcast_addr =
109 #if UIP_CONF_IPV6
110 { { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
111 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff } };
112 #else /* UIP_CONF_IPV6 */
113 { { 0xff, 0xff, 0xff, 0xff } };
114 #endif /* UIP_CONF_IPV6 */
115 const uip_ipaddr_t uip_all_zeroes_addr = { { 0x0, /* rest is 0 */ } };
116
117 #if UIP_FIXEDETHADDR
118 const struct uip_eth_addr uip_ethaddr = {{UIP_ETHADDR0,
119 UIP_ETHADDR1,
120 UIP_ETHADDR2,
121 UIP_ETHADDR3,
122 UIP_ETHADDR4,
123 UIP_ETHADDR5}};
124 #else
125 struct uip_eth_addr uip_ethaddr = {{0,0,0,0,0,0}};
126 #endif
127
128 #ifndef UIP_CONF_EXTERNAL_BUFFER
129 u8_t uip_buf[UIP_BUFSIZE + 2]; /* The packet buffer that contains
130 incoming packets. */
131 #endif /* UIP_CONF_EXTERNAL_BUFFER */
132
133 void *uip_appdata; /* The uip_appdata pointer points to
134 application data. */
135 void *uip_sappdata; /* The uip_appdata pointer points to
136 the application data which is to
137 be sent. */
138 #if UIP_URGDATA > 0
139 void *uip_urgdata; /* The uip_urgdata pointer points to
140 urgent data (out-of-band data), if
141 present. */
142 u16_t uip_urglen, uip_surglen;
143 #endif /* UIP_URGDATA > 0 */
144
145 u16_t uip_len, uip_slen;
146 /* The uip_len is either 8 or 16 bits,
147 depending on the maximum packet
148 size. */
149
150 u8_t uip_flags; /* The uip_flags variable is used for
151 communication between the TCP/IP stack
152 and the application program. */
153 struct uip_conn *uip_conn; /* uip_conn always points to the current
154 connection. */
155
156 struct uip_conn uip_conns[UIP_CONNS];
157 /* The uip_conns array holds all TCP
158 connections. */
159 u16_t uip_listenports[UIP_LISTENPORTS];
160 /* The uip_listenports list all currently
161 listning ports. */
162 #if UIP_UDP
163 struct uip_udp_conn *uip_udp_conn;
164 struct uip_udp_conn uip_udp_conns[UIP_UDP_CONNS];
165 #endif /* UIP_UDP */
166
167 static u16_t ipid; /* Ths ipid variable is an increasing
168 number that is used for the IP ID
169 field. */
170
171 void uip_setipid(u16_t id) { ipid = id; }
172
173 static u8_t iss[4]; /* The iss variable is used for the TCP
174 initial sequence number. */
175
176 #if UIP_ACTIVE_OPEN
177 static u16_t lastport; /* Keeps track of the last port used for
178 a new connection. */
179 #endif /* UIP_ACTIVE_OPEN */
180
181 /* Temporary variables. */
182 u8_t uip_acc32[4];
183 static u8_t c, opt;
184 static u16_t tmp16;
185
186 /* Structures and definitions. */
187 #define TCP_FIN 0x01
188 #define TCP_SYN 0x02
189 #define TCP_RST 0x04
190 #define TCP_PSH 0x08
191 #define TCP_ACK 0x10
192 #define TCP_URG 0x20
193 #define TCP_CTL 0x3f
194
195 #define TCP_OPT_END 0 /* End of TCP options list */
196 #define TCP_OPT_NOOP 1 /* "No-operation" TCP option */
197 #define TCP_OPT_MSS 2 /* Maximum segment size TCP option */
198
199 #define TCP_OPT_MSS_LEN 4 /* Length of TCP MSS option. */
200
201 #define ICMP_ECHO_REPLY 0
202 #define ICMP_ECHO 8
203
204 #define ICMP_DEST_UNREACHABLE 3
205 #define ICMP_PORT_UNREACHABLE 3
206
207 #define ICMP6_ECHO_REPLY 129
208 #define ICMP6_ECHO 128
209 #define ICMP6_NEIGHBOR_SOLICITATION 135
210 #define ICMP6_NEIGHBOR_ADVERTISEMENT 136
211
212 #define ICMP6_FLAG_S (1 << 6)
213
214 #define ICMP6_OPTION_SOURCE_LINK_ADDRESS 1
215 #define ICMP6_OPTION_TARGET_LINK_ADDRESS 2
216
217
218 /* Macros. */
219 #define BUF ((struct uip_tcpip_hdr *)&uip_buf[UIP_LLH_LEN])
220 #define FBUF ((struct uip_tcpip_hdr *)&uip_reassbuf[0])
221 #define ICMPBUF ((struct uip_icmpip_hdr *)&uip_buf[UIP_LLH_LEN])
222 #define UDPBUF ((struct uip_udpip_hdr *)&uip_buf[UIP_LLH_LEN])
223
224
225 #if UIP_STATISTICS == 1
226 struct uip_stats uip_stat;
227 #define UIP_STAT(s) s
228 #else
229 #define UIP_STAT(s)
230 #endif /* UIP_STATISTICS == 1 */
231
232 #if UIP_LOGGING == 1
233 #include <stdio.h>
234 void uip_log(char *msg);
235 #define UIP_LOG(m) uip_log(m)
236 #else
237 #define UIP_LOG(m)
238 #endif /* UIP_LOGGING == 1 */
239
240 #if ! UIP_ARCH_ADD32
241 void
242 uip_add32(u8_t *op32, u16_t op16)
243 {
244 uip_acc32[3] = op32[3] + (op16 & 0xff);
245 uip_acc32[2] = op32[2] + (op16 >> 8);
246 uip_acc32[1] = op32[1];
247 uip_acc32[0] = op32[0];
248
249 if(uip_acc32[2] < (op16 >> 8)) {
250 ++uip_acc32[1];
251 if(uip_acc32[1] == 0) {
252 ++uip_acc32[0];
253 }
254 }
255
256
257 if(uip_acc32[3] < (op16 & 0xff)) {
258 ++uip_acc32[2];
259 if(uip_acc32[2] == 0) {
260 ++uip_acc32[1];
261 if(uip_acc32[1] == 0) {
262 ++uip_acc32[0];
263 }
264 }
265 }
266 }
267
268 #endif /* UIP_ARCH_ADD32 */
269
270 #if ! UIP_ARCH_CHKSUM
271 /*---------------------------------------------------------------------------*/
272 static u16_t
273 chksum(u16_t sum, const u8_t *data, u16_t len)
274 {
275 u16_t t;
276 const u8_t *dataptr;
277 const u8_t *last_byte;
278
279 dataptr = data;
280 last_byte = data + len - 1;
281
282 while(dataptr < last_byte) { /* At least two more bytes */
283 t = (dataptr[0] << 8) + dataptr[1];
284 sum += t;
285 if(sum < t) {
286 sum++; /* carry */
287 }
288 dataptr += 2;
289 }
290
291 if(dataptr == last_byte) {
292 t = (dataptr[0] << 8) + 0;
293 sum += t;
294 if(sum < t) {
295 sum++; /* carry */
296 }
297 }
298
299 /* Return sum in host byte order. */
300 return sum;
301 }
302 /*---------------------------------------------------------------------------*/
303 u16_t
304 uip_chksum(u16_t *data, u16_t len)
305 {
306 return htons(chksum(0, (u8_t *)data, len));
307 }
308 /*---------------------------------------------------------------------------*/
309 #ifndef UIP_ARCH_IPCHKSUM
310 u16_t
311 uip_ipchksum(void)
312 {
313 u16_t sum;
314
315 sum = chksum(0, &uip_buf[UIP_LLH_LEN], UIP_IPH_LEN);
316 DEBUG_PRINTF("uip_ipchksum: sum 0x%04x\n", sum);
317 return (sum == 0) ? 0xffff : htons(sum);
318 }
319 #endif
320 /*---------------------------------------------------------------------------*/
321 static u16_t
322 upper_layer_chksum(u8_t proto)
323 {
324 u16_t upper_layer_len;
325 u16_t sum;
326
327 #if UIP_CONF_IPV6
328 upper_layer_len = (((u16_t)(BUF->len[0]) << 8) + BUF->len[1]);
329 #else /* UIP_CONF_IPV6 */
330 upper_layer_len = (((u16_t)(BUF->len[0]) << 8) + BUF->len[1]) - UIP_IPH_LEN;
331 #endif /* UIP_CONF_IPV6 */
332
333 /* First sum pseudoheader. */
334
335 /* IP protocol and length fields. This addition cannot carry. */
336 sum = upper_layer_len + proto;
337 /* Sum IP source and destination addresses. */
338 sum = chksum(sum, (u8_t *)&BUF->srcipaddr, 2 * sizeof(uip_ipaddr_t));
339
340 /* Sum TCP header and data. */
341 sum = chksum(sum, &uip_buf[UIP_IPH_LEN + UIP_LLH_LEN],
342 upper_layer_len);
343
344 return (sum == 0) ? 0xffff : htons(sum);
345 }
346 /*---------------------------------------------------------------------------*/
347 #if UIP_CONF_IPV6
348 u16_t
349 uip_icmp6chksum(void)
350 {
351 return upper_layer_chksum(UIP_PROTO_ICMP6);
352
353 }
354 #endif /* UIP_CONF_IPV6 */
355 /*---------------------------------------------------------------------------*/
356 u16_t
357 uip_tcpchksum(void)
358 {
359 return upper_layer_chksum(UIP_PROTO_TCP);
360 }
361 /*---------------------------------------------------------------------------*/
362 #if UIP_UDP_CHECKSUMS
363 u16_t
364 uip_udpchksum(void)
365 {
366 return upper_layer_chksum(UIP_PROTO_UDP);
367 }
368 #endif /* UIP_UDP_CHECKSUMS */
369 #endif /* UIP_ARCH_CHKSUM */
370 /*---------------------------------------------------------------------------*/
371 void
372 uip_init(void)
373 {
374 for(c = 0; c < UIP_LISTENPORTS; ++c) {
375 uip_listenports[c] = 0;
376 }
377 for(c = 0; c < UIP_CONNS; ++c) {
378 uip_conns[c].tcpstateflags = UIP_CLOSED;
379 }
380 #if UIP_ACTIVE_OPEN
381 lastport = 1024;
382 #endif /* UIP_ACTIVE_OPEN */
383
384 #if UIP_UDP
385 for(c = 0; c < UIP_UDP_CONNS; ++c) {
386 uip_udp_conns[c].lport = 0;
387 }
388 #endif /* UIP_UDP */
389
390
391 /* IPv4 initialization. */
392 #if UIP_FIXEDADDR == 0
393 /* uip_hostaddr[0] = uip_hostaddr[1] = 0;*/
394 #endif /* UIP_FIXEDADDR */
395
396 }
397 /*---------------------------------------------------------------------------*/
398 #if UIP_ACTIVE_OPEN
399 struct uip_conn *
400 uip_connect(uip_ipaddr_t *ripaddr, u16_t rport)
401 {
402 register struct uip_conn *conn, *cconn;
403
404 /* Find an unused local port. */
405 again:
406 ++lastport;
407
408 if(lastport >= 32000) {
409 lastport = 4096;
410 }
411
412 /* Check if this port is already in use, and if so try to find
413 another one. */
414 for(c = 0; c < UIP_CONNS; ++c) {
415 conn = &uip_conns[c];
416 if(conn->tcpstateflags != UIP_CLOSED &&
417 conn->lport == htons(lastport)) {
418 goto again;
419 }
420 }
421
422 conn = 0;
423 for(c = 0; c < UIP_CONNS; ++c) {
424 cconn = &uip_conns[c];
425 if(cconn->tcpstateflags == UIP_CLOSED) {
426 conn = cconn;
427 break;
428 }
429 if(cconn->tcpstateflags == UIP_TIME_WAIT) {
430 if(conn == 0 ||
431 cconn->timer > conn->timer) {
432 conn = cconn;
433 }
434 }
435 }
436
437 if(conn == 0) {
438 return 0;
439 }
440
441 conn->tcpstateflags = UIP_SYN_SENT;
442
443 conn->snd_nxt[0] = iss[0];
444 conn->snd_nxt[1] = iss[1];
445 conn->snd_nxt[2] = iss[2];
446 conn->snd_nxt[3] = iss[3];
447
448 conn->initialmss = conn->mss = UIP_TCP_MSS;
449
450 conn->len = 1; /* TCP length of the SYN is one. */
451 conn->nrtx = 0;
452 conn->timer = 1; /* Send the SYN next time around. */
453 conn->rto = UIP_RTO;
454 conn->sa = 0;
455 conn->sv = 16; /* Initial value of the RTT variance. */
456 conn->lport = htons(lastport);
457 conn->rport = rport;
458 uip_ipaddr_copy(&conn->ripaddr, ripaddr);
459
460 return conn;
461 }
462 #endif /* UIP_ACTIVE_OPEN */
463 /*---------------------------------------------------------------------------*/
464 #if UIP_UDP
465 struct uip_udp_conn *
466 uip_udp_new(const uip_ipaddr_t *ripaddr, u16_t rport)
467 {
468 register struct uip_udp_conn *conn;
469
470 /* Find an unused local port. */
471 again:
472 ++lastport;
473
474 if(lastport >= 32000) {
475 lastport = 4096;
476 }
477
478 for(c = 0; c < UIP_UDP_CONNS; ++c) {
479 if(uip_udp_conns[c].lport == htons(lastport)) {
480 goto again;
481 }
482 }
483
484
485 conn = 0;
486 for(c = 0; c < UIP_UDP_CONNS; ++c) {
487 if(uip_udp_conns[c].lport == 0) {
488 conn = &uip_udp_conns[c];
489 break;
490 }
491 }
492
493 if(conn == 0) {
494 return 0;
495 }
496
497 conn->lport = HTONS(lastport);
498 conn->rport = rport;
499 if(ripaddr == NULL) {
500 memset(&conn->ripaddr, 0, sizeof(uip_ipaddr_t));
501 } else {
502 uip_ipaddr_copy(&conn->ripaddr, ripaddr);
503 }
504 conn->ttl = UIP_TTL;
505
506 return conn;
507 }
508 #endif /* UIP_UDP */
509 /*---------------------------------------------------------------------------*/
510 void
511 uip_unlisten(u16_t port)
512 {
513 for(c = 0; c < UIP_LISTENPORTS; ++c) {
514 if(uip_listenports[c] == port) {
515 uip_listenports[c] = 0;
516 return;
517 }
518 }
519 }
520 /*---------------------------------------------------------------------------*/
521 void
522 uip_listen(u16_t port)
523 {
524 for(c = 0; c < UIP_LISTENPORTS; ++c) {
525 if(uip_listenports[c] == 0) {
526 uip_listenports[c] = port;
527 return;
528 }
529 }
530 }
531 /*---------------------------------------------------------------------------*/
532 /* XXX: IP fragment reassembly: not well-tested. */
533
534 #if UIP_REASSEMBLY && !UIP_CONF_IPV6
535 #define UIP_REASS_BUFSIZE (UIP_BUFSIZE - UIP_LLH_LEN)
536 static u8_t uip_reassbuf[UIP_REASS_BUFSIZE];
537 static u8_t uip_reassbitmap[UIP_REASS_BUFSIZE / (8 * 8)];
538 static const u8_t bitmap_bits[8] = {0xff, 0x7f, 0x3f, 0x1f,
539 0x0f, 0x07, 0x03, 0x01};
540 static u16_t uip_reasslen;
541 static u8_t uip_reassflags;
542 #define UIP_REASS_FLAG_LASTFRAG 0x01
543 static u8_t uip_reasstmr;
544
545 #define IP_MF 0x20
546
547 static u8_t
548 uip_reass(void)
549 {
550 u16_t offset, len;
551 u16_t i;
552
553 /* If ip_reasstmr is zero, no packet is present in the buffer, so we
554 write the IP header of the fragment into the reassembly
555 buffer. The timer is updated with the maximum age. */
556 if(uip_reasstmr == 0) {
557 memcpy(uip_reassbuf, &BUF->vhl, UIP_IPH_LEN);
558 uip_reasstmr = UIP_REASS_MAXAGE;
559 uip_reassflags = 0;
560 /* Clear the bitmap. */
561 memset(uip_reassbitmap, 0, sizeof(uip_reassbitmap));
562 }
563
564 /* Check if the incoming fragment matches the one currently present
565 in the reasembly buffer. If so, we proceed with copying the
566 fragment into the buffer. */
567 if(BUF->srcipaddr[0] == FBUF->srcipaddr[0] &&
568 BUF->srcipaddr[1] == FBUF->srcipaddr[1] &&
569 BUF->destipaddr[0] == FBUF->destipaddr[0] &&
570 BUF->destipaddr[1] == FBUF->destipaddr[1] &&
571 BUF->ipid[0] == FBUF->ipid[0] &&
572 BUF->ipid[1] == FBUF->ipid[1]) {
573
574 len = (BUF->len[0] << 8) + BUF->len[1] - (BUF->vhl & 0x0f) * 4;
575 offset = (((BUF->ipoffset[0] & 0x3f) << 8) + BUF->ipoffset[1]) * 8;
576
577 /* If the offset or the offset + fragment length overflows the
578 reassembly buffer, we discard the entire packet. */
579 if(offset > UIP_REASS_BUFSIZE ||
580 offset + len > UIP_REASS_BUFSIZE) {
581 uip_reasstmr = 0;
582 goto nullreturn;
583 }
584
585 /* Copy the fragment into the reassembly buffer, at the right
586 offset. */
587 memcpy(&uip_reassbuf[UIP_IPH_LEN + offset],
588 (char *)BUF + (int)((BUF->vhl & 0x0f) * 4),
589 len);
590
591 /* Update the bitmap. */
592 if(offset / (8 * 8) == (offset + len) / (8 * 8)) {
593 /* If the two endpoints are in the same byte, we only update
594 that byte. */
595
596 uip_reassbitmap[offset / (8 * 8)] |=
597 bitmap_bits[(offset / 8 ) & 7] &
598 ~bitmap_bits[((offset + len) / 8 ) & 7];
599 } else {
600 /* If the two endpoints are in different bytes, we update the
601 bytes in the endpoints and fill the stuff inbetween with
602 0xff. */
603 uip_reassbitmap[offset / (8 * 8)] |=
604 bitmap_bits[(offset / 8 ) & 7];
605 for(i = 1 + offset / (8 * 8); i < (offset + len) / (8 * 8); ++i) {
606 uip_reassbitmap[i] = 0xff;
607 }
608 uip_reassbitmap[(offset + len) / (8 * 8)] |=
609 ~bitmap_bits[((offset + len) / 8 ) & 7];
610 }
611
612 /* If this fragment has the More Fragments flag set to zero, we
613 know that this is the last fragment, so we can calculate the
614 size of the entire packet. We also set the
615 IP_REASS_FLAG_LASTFRAG flag to indicate that we have received
616 the final fragment. */
617
618 if((BUF->ipoffset[0] & IP_MF) == 0) {
619 uip_reassflags |= UIP_REASS_FLAG_LASTFRAG;
620 uip_reasslen = offset + len;
621 }
622
623 /* Finally, we check if we have a full packet in the buffer. We do
624 this by checking if we have the last fragment and if all bits
625 in the bitmap are set. */
626 if(uip_reassflags & UIP_REASS_FLAG_LASTFRAG) {
627 /* Check all bytes up to and including all but the last byte in
628 the bitmap. */
629 for(i = 0; i < uip_reasslen / (8 * 8) - 1; ++i) {
630 if(uip_reassbitmap[i] != 0xff) {
631 goto nullreturn;
632 }
633 }
634 /* Check the last byte in the bitmap. It should contain just the
635 right amount of bits. */
636 if(uip_reassbitmap[uip_reasslen / (8 * 8)] !=
637 (u8_t)~bitmap_bits[uip_reasslen / 8 & 7]) {
638 goto nullreturn;
639 }
640
641 /* If we have come this far, we have a full packet in the
642 buffer, so we allocate a pbuf and copy the packet into it. We
643 also reset the timer. */
644 uip_reasstmr = 0;
645 memcpy(BUF, FBUF, uip_reasslen);
646
647 /* Pretend to be a "normal" (i.e., not fragmented) IP packet
648 from now on. */
649 BUF->ipoffset[0] = BUF->ipoffset[1] = 0;
650 BUF->len[0] = uip_reasslen >> 8;
651 BUF->len[1] = uip_reasslen & 0xff;
652 BUF->ipchksum = 0;
653 BUF->ipchksum = ~(uip_ipchksum());
654
655 return uip_reasslen;
656 }
657 }
658
659 nullreturn:
660 return 0;
661 }
662 #endif /* UIP_REASSEMBLY */
663 /*---------------------------------------------------------------------------*/
664 static void
665 uip_add_rcv_nxt(u16_t n)
666 {
667 uip_add32(uip_conn->rcv_nxt, n);
668 uip_conn->rcv_nxt[0] = uip_acc32[0];
669 uip_conn->rcv_nxt[1] = uip_acc32[1];
670 uip_conn->rcv_nxt[2] = uip_acc32[2];
671 uip_conn->rcv_nxt[3] = uip_acc32[3];
672 }
673 /*---------------------------------------------------------------------------*/
674 void
675 uip_process(u8_t flag)
676 {
677 register struct uip_conn *uip_connr = uip_conn;
678
679 #if UIP_UDP
680 if(flag == UIP_UDP_SEND_CONN) {
681 goto udp_send;
682 }
683 #endif /* UIP_UDP */
684
685 uip_sappdata = uip_appdata = &uip_buf[UIP_IPTCPH_LEN + UIP_LLH_LEN];
686
687 /* Check if we were invoked because of a poll request for a
688 particular connection. */
689 if(flag == UIP_POLL_REQUEST) {
690 if((uip_connr->tcpstateflags & UIP_TS_MASK) == UIP_ESTABLISHED &&
691 !uip_outstanding(uip_connr)) {
692 uip_flags = UIP_POLL;
693 UIP_APPCALL();
694 goto appsend;
695 }
696 goto drop;
697
698 /* Check if we were invoked because of the perodic timer fireing. */
699 } else if(flag == UIP_TIMER) {
700 #if UIP_REASSEMBLY
701 if(uip_reasstmr != 0) {
702 --uip_reasstmr;
703 }
704 #endif /* UIP_REASSEMBLY */
705 /* Increase the initial sequence number. */
706 if(++iss[3] == 0) {
707 if(++iss[2] == 0) {
708 if(++iss[1] == 0) {
709 ++iss[0];
710 }
711 }
712 }
713
714 /* Reset the length variables. */
715 uip_len = 0;
716 uip_slen = 0;
717
718 /* Check if the connection is in a state in which we simply wait
719 for the connection to time out. If so, we increase the
720 connection's timer and remove the connection if it times
721 out. */
722 if(uip_connr->tcpstateflags == UIP_TIME_WAIT ||
723 uip_connr->tcpstateflags == UIP_FIN_WAIT_2) {
724 ++(uip_connr->timer);
725 if(uip_connr->timer == UIP_TIME_WAIT_TIMEOUT) {
726 uip_connr->tcpstateflags = UIP_CLOSED;
727 }
728 } else if(uip_connr->tcpstateflags != UIP_CLOSED) {
729 /* If the connection has outstanding data, we increase the
730 connection's timer and see if it has reached the RTO value
731 in which case we retransmit. */
732 if(uip_outstanding(uip_connr)) {
733 if(uip_connr->timer-- == 0) {
734 if(uip_connr->nrtx == UIP_MAXRTX ||
735 ((uip_connr->tcpstateflags == UIP_SYN_SENT ||
736 uip_connr->tcpstateflags == UIP_SYN_RCVD) &&
737 uip_connr->nrtx == UIP_MAXSYNRTX)) {
738 uip_connr->tcpstateflags = UIP_CLOSED;
739
740 /* We call UIP_APPCALL() with uip_flags set to
741 UIP_TIMEDOUT to inform the application that the
742 connection has timed out. */
743 uip_flags = UIP_TIMEDOUT;
744 UIP_APPCALL();
745
746 /* We also send a reset packet to the remote host. */
747 BUF->flags = TCP_RST | TCP_ACK;
748 goto tcp_send_nodata;
749 }
750
751 /* Exponential backoff. */
752 uip_connr->timer = UIP_RTO << (uip_connr->nrtx > 4?
753 4:
754 uip_connr->nrtx);
755 ++(uip_connr->nrtx);
756
757 /* Ok, so we need to retransmit. We do this differently
758 depending on which state we are in. In ESTABLISHED, we
759 call upon the application so that it may prepare the
760 data for the retransmit. In SYN_RCVD, we resend the
761 SYNACK that we sent earlier and in LAST_ACK we have to
762 retransmit our FINACK. */
763 UIP_STAT(++uip_stat.tcp.rexmit);
764 switch(uip_connr->tcpstateflags & UIP_TS_MASK) {
765 case UIP_SYN_RCVD:
766 /* In the SYN_RCVD state, we should retransmit our
767 SYNACK. */
768 goto tcp_send_synack;
769
770 #if UIP_ACTIVE_OPEN
771 case UIP_SYN_SENT:
772 /* In the SYN_SENT state, we retransmit out SYN. */
773 BUF->flags = 0;
774 goto tcp_send_syn;
775 #endif /* UIP_ACTIVE_OPEN */
776
777 case UIP_ESTABLISHED:
778 /* In the ESTABLISHED state, we call upon the application
779 to do the actual retransmit after which we jump into
780 the code for sending out the packet (the apprexmit
781 label). */
782 uip_flags = UIP_REXMIT;
783 UIP_APPCALL();
784 goto apprexmit;
785
786 case UIP_FIN_WAIT_1:
787 case UIP_CLOSING:
788 case UIP_LAST_ACK:
789 /* In all these states we should retransmit a FINACK. */
790 goto tcp_send_finack;
791
792 }
793 }
794 } else if((uip_connr->tcpstateflags & UIP_TS_MASK) == UIP_ESTABLISHED) {
795 /* If there was no need for a retransmission, we poll the
796 application for new data. */
797 uip_flags = UIP_POLL;
798 UIP_APPCALL();
799 goto appsend;
800 }
801 }
802 goto drop;
803 }
804 #if UIP_UDP
805 if(flag == UIP_UDP_TIMER) {
806 if(uip_udp_conn->lport != 0) {
807 uip_conn = NULL;
808 uip_sappdata = uip_appdata = &uip_buf[UIP_LLH_LEN + UIP_IPUDPH_LEN];
809 uip_len = uip_slen = 0;
810 uip_flags = UIP_POLL;
811 UIP_UDP_APPCALL();
812 goto udp_send;
813 } else {
814 goto drop;
815 }
816 }
817 #endif
818
819 /* This is where the input processing starts. */
820 UIP_STAT(++uip_stat.ip.recv);
821
822 /* Start of IP input header processing code. */
823
824 #if UIP_CONF_IPV6
825 /* Check validity of the IP header. */
826 if((BUF->vtc & 0xf0) != 0x60) { /* IP version and header length. */
827 UIP_STAT(++uip_stat.ip.drop);
828 UIP_STAT(++uip_stat.ip.vhlerr);
829 UIP_LOG("ipv6: invalid version.");
830 goto drop;
831 }
832 #else /* UIP_CONF_IPV6 */
833 /* Check validity of the IP header. */
834 if(BUF->vhl != 0x45) { /* IP version and header length. */
835 UIP_STAT(++uip_stat.ip.drop);
836 UIP_STAT(++uip_stat.ip.vhlerr);
837 UIP_LOG("ip: invalid version or header length.");
838 goto drop;
839 }
840 #endif /* UIP_CONF_IPV6 */
841
842 /* Check the size of the packet. If the size reported to us in
843 uip_len is smaller the size reported in the IP header, we assume
844 that the packet has been corrupted in transit. If the size of
845 uip_len is larger than the size reported in the IP packet header,
846 the packet has been padded and we set uip_len to the correct
847 value.. */
848
849 if((BUF->len[0] << 8) + BUF->len[1] <= uip_len) {
850 uip_len = (BUF->len[0] << 8) + BUF->len[1];
851 #if UIP_CONF_IPV6
852 uip_len += 40; /* The length reported in the IPv6 header is the
853 length of the payload that follows the
854 header. However, uIP uses the uip_len variable
855 for holding the size of the entire packet,
856 including the IP header. For IPv4 this is not a
857 problem as the length field in the IPv4 header
858 contains the length of the entire packet. But
859 for IPv6 we need to add the size of the IPv6
860 header (40 bytes). */
861 #endif /* UIP_CONF_IPV6 */
862 } else {
863 UIP_LOG("ip: packet shorter than reported in IP header.");
864 goto drop;
865 }
866
867 #if !UIP_CONF_IPV6
868 /* Check the fragment flag. */
869 if((BUF->ipoffset[0] & 0x3f) != 0 ||
870 BUF->ipoffset[1] != 0) {
871 #if UIP_REASSEMBLY
872 uip_len = uip_reass();
873 if(uip_len == 0) {
874 goto drop;
875 }
876 #else /* UIP_REASSEMBLY */
877 UIP_STAT(++uip_stat.ip.drop);
878 UIP_STAT(++uip_stat.ip.fragerr);
879 UIP_LOG("ip: fragment dropped.");
880 goto drop;
881 #endif /* UIP_REASSEMBLY */
882 }
883 #endif /* UIP_CONF_IPV6 */
884
885 if(uip_ipaddr_cmp(&uip_hostaddr, &uip_all_zeroes_addr)) {
886 /* If we are configured to use ping IP address configuration and
887 hasn't been assigned an IP address yet, we accept all ICMP
888 packets. */
889 #if UIP_PINGADDRCONF && !UIP_CONF_IPV6
890 if(BUF->proto == UIP_PROTO_ICMP) {
891 UIP_LOG("ip: possible ping config packet received.");
892 goto icmp_input;
893 } else {
894 UIP_LOG("ip: packet dropped since no address assigned.");
895 goto drop;
896 }
897 #endif /* UIP_PINGADDRCONF */
898
899 } else {
900 /* If IP broadcast support is configured, we check for a broadcast
901 UDP packet, which may be destined to us. */
902 #if UIP_BROADCAST
903 DEBUG_PRINTF("UDP IP checksum 0x%04x\n", uip_ipchksum());
904 if(BUF->proto == UIP_PROTO_UDP &&
905 uip_ipaddr_cmp(&BUF->destipaddr, &uip_broadcast_addr)
906 /*&&
907 uip_ipchksum() == 0xffff*/) {
908 goto udp_input;
909 }
910 #endif /* UIP_BROADCAST */
911
912 /* Check if the packet is destined for our IP address. */
913 #if !UIP_CONF_IPV6
914 if(!uip_ipaddr_cmp(&BUF->destipaddr, &uip_hostaddr)) {
915 UIP_STAT(++uip_stat.ip.drop);
916 goto drop;
917 }
918 #else /* UIP_CONF_IPV6 */
919 /* For IPv6, packet reception is a little trickier as we need to
920 make sure that we listen to certain multicast addresses (all
921 hosts multicast address, and the solicited-node multicast
922 address) as well. However, we will cheat here and accept all
923 multicast packets that are sent to the ff02::/16 addresses. */
924 if(!uip_ipaddr_cmp(&BUF->destipaddr, &uip_hostaddr) &&
925 BUF->destipaddr.u16[0] != HTONS(0xff02)) {
926 UIP_STAT(++uip_stat.ip.drop);
927 goto drop;
928 }
929 #endif /* UIP_CONF_IPV6 */
930 }
931
932 #if !UIP_CONF_IPV6
933 if(uip_ipchksum() != 0xffff) { /* Compute and check the IP header
934 checksum. */
935 UIP_STAT(++uip_stat.ip.drop);
936 UIP_STAT(++uip_stat.ip.chkerr);
937 UIP_LOG("ip: bad checksum.");
938 goto drop;
939 }
940 #endif /* UIP_CONF_IPV6 */
941
942 if(BUF->proto == UIP_PROTO_TCP) { /* Check for TCP packet. If so,
943 proceed with TCP input
944 processing. */
945 goto tcp_input;
946 }
947
948 #if UIP_UDP
949 if(BUF->proto == UIP_PROTO_UDP) {
950 goto udp_input;
951 }
952 #endif /* UIP_UDP */
953
954 #if !UIP_CONF_IPV6
955 /* ICMPv4 processing code follows. */
956 if(BUF->proto != UIP_PROTO_ICMP) { /* We only allow ICMP packets from
957 here. */
958 UIP_STAT(++uip_stat.ip.drop);
959 UIP_STAT(++uip_stat.ip.protoerr);
960 UIP_LOG("ip: neither tcp nor icmp.");
961 goto drop;
962 }
963
964 #if UIP_PINGADDRCONF
965 icmp_input:
966 #endif /* UIP_PINGADDRCONF */
967 UIP_STAT(++uip_stat.icmp.recv);
968
969 /* ICMP echo (i.e., ping) processing. This is simple, we only change
970 the ICMP type from ECHO to ECHO_REPLY and adjust the ICMP
971 checksum before we return the packet. */
972 if(ICMPBUF->type != ICMP_ECHO) {
973 UIP_STAT(++uip_stat.icmp.drop);
974 UIP_STAT(++uip_stat.icmp.typeerr);
975 UIP_LOG("icmp: not icmp echo.");
976 goto drop;
977 }
978
979 /* If we are configured to use ping IP address assignment, we use
980 the destination IP address of this ping packet and assign it to
981 ourself. */
982 #if UIP_PINGADDRCONF
983 if(uip_ipaddr_cmp(&uip_hostaddr, &uip_all_zeroes_addr)) {
984 uip_hostaddr = BUF->destipaddr;
985 }
986 #endif /* UIP_PINGADDRCONF */
987
988 ICMPBUF->type = ICMP_ECHO_REPLY;
989
990 if(ICMPBUF->icmpchksum >= HTONS(0xffff - (ICMP_ECHO << 8))) {
991 ICMPBUF->icmpchksum += HTONS(ICMP_ECHO << 8) + 1;
992 } else {
993 ICMPBUF->icmpchksum += HTONS(ICMP_ECHO << 8);
994 }
995
996 /* Swap IP addresses. */
997 uip_ipaddr_copy(&BUF->destipaddr, &BUF->srcipaddr);
998 uip_ipaddr_copy(&BUF->srcipaddr, &uip_hostaddr);
999
1000 UIP_STAT(++uip_stat.icmp.sent);
1001 BUF->ttl = UIP_TTL;
1002 goto ip_send_nolen;
1003
1004 /* End of IPv4 input header processing code. */
1005 #else /* !UIP_CONF_IPV6 */
1006
1007 /* This is IPv6 ICMPv6 processing code. */
1008 DEBUG_PRINTF("icmp6_input: length %d\n", uip_len);
1009
1010 if(BUF->proto != UIP_PROTO_ICMP6) { /* We only allow ICMPv6 packets from
1011 here. */
1012 UIP_STAT(++uip_stat.ip.drop);
1013 UIP_STAT(++uip_stat.ip.protoerr);
1014 UIP_LOG("ip: neither tcp nor icmp6.");
1015 goto drop;
1016 }
1017
1018 UIP_STAT(++uip_stat.icmp.recv);
1019
1020 /* If we get a neighbor solicitation for our address we should send
1021 a neighbor advertisement message back. */
1022 if(ICMPBUF->type == ICMP6_NEIGHBOR_SOLICITATION) {
1023 if(uip_ipaddr_cmp(&ICMPBUF->icmp6data, &uip_hostaddr)) {
1024
1025 if(ICMPBUF->options[0] == ICMP6_OPTION_SOURCE_LINK_ADDRESS) {
1026 /* Save the sender's address in our neighbor list. */
1027 uip_neighbor_add(&ICMPBUF->srcipaddr, &(ICMPBUF->options[2]));
1028 }
1029
1030 /* We should now send a neighbor advertisement back to where the
1031 neighbor solicication came from. */
1032 ICMPBUF->type = ICMP6_NEIGHBOR_ADVERTISEMENT;
1033 ICMPBUF->flags = ICMP6_FLAG_S; /* Solicited flag. */
1034
1035 ICMPBUF->reserved1 = ICMPBUF->reserved2 = ICMPBUF->reserved3 = 0;
1036
1037 uip_ipaddr_copy(&ICMPBUF->destipaddr, &ICMPBUF->srcipaddr);
1038 uip_ipaddr_copy(&ICMPBUF->srcipaddr, &uip_hostaddr);
1039 ICMPBUF->options[0] = ICMP6_OPTION_TARGET_LINK_ADDRESS;
1040 ICMPBUF->options[1] = 1; /* Options length, 1 = 8 bytes. */
1041 memcpy(&(ICMPBUF->options[2]), &uip_ethaddr, sizeof(uip_ethaddr));
1042 ICMPBUF->icmpchksum = 0;
1043 ICMPBUF->icmpchksum = ~uip_icmp6chksum();
1044
1045 goto send;
1046
1047 }
1048 goto drop;
1049 } else if(ICMPBUF->type == ICMP6_ECHO) {
1050 /* ICMP echo (i.e., ping) processing. This is simple, we only
1051 change the ICMP type from ECHO to ECHO_REPLY and update the
1052 ICMP checksum before we return the packet. */
1053
1054 ICMPBUF->type = ICMP6_ECHO_REPLY;
1055
1056 uip_ipaddr_copy(&BUF->destipaddr, &BUF->srcipaddr);
1057 uip_ipaddr_copy(&BUF->srcipaddr, &uip_hostaddr);
1058 ICMPBUF->icmpchksum = 0;
1059 ICMPBUF->icmpchksum = ~uip_icmp6chksum();
1060
1061 UIP_STAT(++uip_stat.icmp.sent);
1062 goto send;
1063 } else {
1064 DEBUG_PRINTF("Unknown icmp6 message type %d\n", ICMPBUF->type);
1065 UIP_STAT(++uip_stat.icmp.drop);
1066 UIP_STAT(++uip_stat.icmp.typeerr);
1067 UIP_LOG("icmp: unknown ICMP message.");
1068 goto drop;
1069 }
1070
1071 /* End of IPv6 ICMP processing. */
1072
1073 #endif /* !UIP_CONF_IPV6 */
1074
1075 #if UIP_UDP
1076 /* UDP input processing. */
1077 udp_input:
1078 /* UDP processing is really just a hack. We don't do anything to the
1079 UDP/IP headers, but let the UDP application do all the hard
1080 work. If the application sets uip_slen, it has a packet to
1081 send. */
1082 #if UIP_UDP_CHECKSUMS
1083 uip_len = uip_len - UIP_IPUDPH_LEN;
1084 uip_appdata = &uip_buf[UIP_LLH_LEN + UIP_IPUDPH_LEN];
1085 if(UDPBUF->udpchksum != 0 && uip_udpchksum() != 0xffff) {
1086 UIP_STAT(++uip_stat.udp.drop);
1087 UIP_STAT(++uip_stat.udp.chkerr);
1088 UIP_LOG("udp: bad checksum.");
1089 goto drop;
1090 }
1091 #else /* UIP_UDP_CHECKSUMS */
1092 uip_len = uip_len - UIP_IPUDPH_LEN;
1093 #endif /* UIP_UDP_CHECKSUMS */
1094
1095 /* Demultiplex this UDP packet between the UDP "connections". */
1096 for(uip_udp_conn = &uip_udp_conns[0];
1097 uip_udp_conn < &uip_udp_conns[UIP_UDP_CONNS];
1098 ++uip_udp_conn) {
1099 /* If the local UDP port is non-zero, the connection is considered
1100 to be used. If so, the local port number is checked against the
1101 destination port number in the received packet. If the two port
1102 numbers match, the remote port number is checked if the
1103 connection is bound to a remote port. Finally, if the
1104 connection is bound to a remote IP address, the source IP
1105 address of the packet is checked. */
1106 if(uip_udp_conn->lport != 0 &&
1107 UDPBUF->destport == uip_udp_conn->lport &&
1108 (uip_udp_conn->rport == 0 ||
1109 UDPBUF->srcport == uip_udp_conn->rport) &&
1110 (uip_ipaddr_cmp(&uip_udp_conn->ripaddr, &uip_all_zeroes_addr) ||
1111 uip_ipaddr_cmp(&uip_udp_conn->ripaddr, &uip_broadcast_addr) ||
1112 uip_ipaddr_cmp(&BUF->srcipaddr, &uip_udp_conn->ripaddr))) {
1113 goto udp_found;
1114 }
1115 }
1116 UIP_LOG("udp: no matching connection found");
1117 #if UIP_CONF_ICMP_DEST_UNREACH && !UIP_CONF_IPV6
1118 /* Copy fields from packet header into payload of this ICMP packet. */
1119 memcpy(&(ICMPBUF->payload[0]), ICMPBUF, UIP_IPH_LEN + 8);
1120
1121 /* Set the ICMP type and code. */
1122 ICMPBUF->type = ICMP_DEST_UNREACHABLE;
1123 ICMPBUF->icode = ICMP_PORT_UNREACHABLE;
1124
1125 /* Calculate the ICMP checksum. */
1126 ICMPBUF->icmpchksum = 0;
1127 ICMPBUF->icmpchksum = ~uip_chksum((u16_t *)&(ICMPBUF->type), 36);
1128
1129 /* Set the IP destination address to be the source address of the
1130 original packet. */
1131 uip_ipaddr_copy(&BUF->destipaddr, &BUF->srcipaddr);
1132
1133 /* Set our IP address as the source address. */
1134 uip_ipaddr_copy(&BUF->srcipaddr, &uip_hostaddr);
1135
1136 /* The size of the ICMP destination unreachable packet is 36 + the
1137 size of the IP header (20) = 56. */
1138 uip_len = 36 + UIP_IPH_LEN;
1139 ICMPBUF->len[0] = 0;
1140 ICMPBUF->len[1] = (u8_t)uip_len;
1141 ICMPBUF->ttl = UIP_TTL;
1142 ICMPBUF->proto = UIP_PROTO_ICMP;
1143
1144 goto ip_send_nolen;
1145 #else /* UIP_CONF_ICMP_DEST_UNREACH */
1146 goto drop;
1147 #endif /* UIP_CONF_ICMP_DEST_UNREACH */
1148
1149 udp_found:
1150 uip_conn = NULL;
1151 uip_flags = UIP_NEWDATA;
1152 uip_sappdata = uip_appdata = &uip_buf[UIP_LLH_LEN + UIP_IPUDPH_LEN];
1153 uip_slen = 0;
1154 UIP_UDP_APPCALL();
1155
1156 udp_send:
1157 if(uip_slen == 0) {
1158 goto drop;
1159 }
1160 uip_len = uip_slen + UIP_IPUDPH_LEN;
1161
1162 #if UIP_CONF_IPV6
1163 /* For IPv6, the IP length field does not include the IPv6 IP header
1164 length. */
1165 BUF->len[0] = ((uip_len - UIP_IPH_LEN) >> 8);
1166 BUF->len[1] = ((uip_len - UIP_IPH_LEN) & 0xff);
1167 #else /* UIP_CONF_IPV6 */
1168 BUF->len[0] = (uip_len >> 8);
1169 BUF->len[1] = (uip_len & 0xff);
1170 #endif /* UIP_CONF_IPV6 */
1171
1172 BUF->ttl = uip_udp_conn->ttl;
1173 BUF->proto = UIP_PROTO_UDP;
1174
1175 UDPBUF->udplen = HTONS(uip_slen + UIP_UDPH_LEN);
1176 UDPBUF->udpchksum = 0;
1177
1178 BUF->srcport = uip_udp_conn->lport;
1179 BUF->destport = uip_udp_conn->rport;
1180
1181 uip_ipaddr_copy(&BUF->srcipaddr, &uip_hostaddr);
1182 uip_ipaddr_copy(&BUF->destipaddr, &uip_udp_conn->ripaddr);
1183
1184 uip_appdata = &uip_buf[UIP_LLH_LEN + UIP_IPTCPH_LEN];
1185
1186 #if UIP_UDP_CHECKSUMS
1187 /* Calculate UDP checksum. */
1188 UDPBUF->udpchksum = ~(uip_udpchksum());
1189 if(UDPBUF->udpchksum == 0) {
1190 UDPBUF->udpchksum = 0xffff;
1191 }
1192 #endif /* UIP_UDP_CHECKSUMS */
1193
1194 goto ip_send_nolen;
1195 #endif /* UIP_UDP */
1196
1197 /* TCP input processing. */
1198 tcp_input:
1199 UIP_STAT(++uip_stat.tcp.recv);
1200
1201 /* Start of TCP input header processing code. */
1202
1203 if(uip_tcpchksum() != 0xffff) { /* Compute and check the TCP
1204 checksum. */
1205 UIP_STAT(++uip_stat.tcp.drop);
1206 UIP_STAT(++uip_stat.tcp.chkerr);
1207 UIP_LOG("tcp: bad checksum.");
1208 goto drop;
1209 }
1210
1211 /* Demultiplex this segment. */
1212 /* First check any active connections. */
1213 for(uip_connr = &uip_conns[0]; uip_connr <= &uip_conns[UIP_CONNS - 1];
1214 ++uip_connr) {
1215 if(uip_connr->tcpstateflags != UIP_CLOSED &&
1216 BUF->destport == uip_connr->lport &&
1217 BUF->srcport == uip_connr->rport &&
1218 uip_ipaddr_cmp(&BUF->srcipaddr, &uip_connr->ripaddr)) {
1219 goto found;
1220 }
1221 }
1222
1223 /* If we didn't find and active connection that expected the packet,
1224 either this packet is an old duplicate, or this is a SYN packet
1225 destined for a connection in LISTEN. If the SYN flag isn't set,
1226 it is an old packet and we send a RST. */
1227 if((BUF->flags & TCP_CTL) != TCP_SYN) {
1228 goto reset;
1229 }
1230
1231 tmp16 = BUF->destport;
1232 /* Next, check listening connections. */
1233 for(c = 0; c < UIP_LISTENPORTS; ++c) {
1234 if(tmp16 == uip_listenports[c]) {
1235 goto found_listen;
1236 }
1237 }
1238
1239 /* No matching connection found, so we send a RST packet. */
1240 UIP_STAT(++uip_stat.tcp.synrst);
1241
1242 reset:
1243 /* We do not send resets in response to resets. */
1244 if(BUF->flags & TCP_RST) {
1245 goto drop;
1246 }
1247
1248 UIP_STAT(++uip_stat.tcp.rst);
1249
1250 BUF->flags = TCP_RST | TCP_ACK;
1251 uip_len = UIP_IPTCPH_LEN;
1252 BUF->tcpoffset = 5 << 4;
1253
1254 /* Flip the seqno and ackno fields in the TCP header. */
1255 c = BUF->seqno[3];
1256 BUF->seqno[3] = BUF->ackno[3];
1257 BUF->ackno[3] = c;
1258
1259 c = BUF->seqno[2];
1260 BUF->seqno[2] = BUF->ackno[2];
1261 BUF->ackno[2] = c;
1262
1263 c = BUF->seqno[1];
1264 BUF->seqno[1] = BUF->ackno[1];
1265 BUF->ackno[1] = c;
1266
1267 c = BUF->seqno[0];
1268 BUF->seqno[0] = BUF->ackno[0];
1269 BUF->ackno[0] = c;
1270
1271 /* We also have to increase the sequence number we are
1272 acknowledging. If the least significant byte overflowed, we need
1273 to propagate the carry to the other bytes as well. */
1274 if(++BUF->ackno[3] == 0) {
1275 if(++BUF->ackno[2] == 0) {
1276 if(++BUF->ackno[1] == 0) {
1277 ++BUF->ackno[0];
1278 }
1279 }
1280 }
1281
1282 /* Swap port numbers. */
1283 tmp16 = BUF->srcport;
1284 BUF->srcport = BUF->destport;
1285 BUF->destport = tmp16;
1286
1287 /* Swap IP addresses. */
1288 uip_ipaddr_copy(&BUF->destipaddr, &BUF->srcipaddr);
1289 uip_ipaddr_copy(&BUF->srcipaddr, &uip_hostaddr);
1290
1291 /* And send out the RST packet! */
1292 goto tcp_send_noconn;
1293
1294 /* This label will be jumped to if we matched the incoming packet
1295 with a connection in LISTEN. In that case, we should create a new
1296 connection and send a SYNACK in return. */
1297 found_listen:
1298 /* First we check if there are any connections avaliable. Unused
1299 connections are kept in the same table as used connections, but
1300 unused ones have the tcpstate set to CLOSED. Also, connections in
1301 TIME_WAIT are kept track of and we'll use the oldest one if no
1302 CLOSED connections are found. Thanks to Eddie C. Dost for a very
1303 nice algorithm for the TIME_WAIT search. */
1304 uip_connr = 0;
1305 for(c = 0; c < UIP_CONNS; ++c) {
1306 if(uip_conns[c].tcpstateflags == UIP_CLOSED) {
1307 uip_connr = &uip_conns[c];
1308 break;
1309 }
1310 if(uip_conns[c].tcpstateflags == UIP_TIME_WAIT) {
1311 if(uip_connr == 0 ||
1312 uip_conns[c].timer > uip_connr->timer) {
1313 uip_connr = &uip_conns[c];
1314 }
1315 }
1316 }
1317
1318 if(uip_connr == 0) {
1319 /* All connections are used already, we drop packet and hope that
1320 the remote end will retransmit the packet at a time when we
1321 have more spare connections. */
1322 UIP_STAT(++uip_stat.tcp.syndrop);
1323 UIP_LOG("tcp: found no unused connections.");
1324 goto drop;
1325 }
1326 uip_conn = uip_connr;
1327
1328 /* Fill in the necessary fields for the new connection. */
1329 uip_connr->rto = uip_connr->timer = UIP_RTO;
1330 uip_connr->sa = 0;
1331 uip_connr->sv = 4;
1332 uip_connr->nrtx = 0;
1333 uip_connr->lport = BUF->destport;
1334 uip_connr->rport = BUF->srcport;
1335 uip_ipaddr_copy(&uip_connr->ripaddr, &BUF->srcipaddr);
1336 uip_connr->tcpstateflags = UIP_SYN_RCVD;
1337
1338 uip_connr->snd_nxt[0] = iss[0];
1339 uip_connr->snd_nxt[1] = iss[1];
1340 uip_connr->snd_nxt[2] = iss[2];
1341 uip_connr->snd_nxt[3] = iss[3];
1342 uip_connr->len = 1;
1343
1344 /* rcv_nxt should be the seqno from the incoming packet + 1. */
1345 uip_connr->rcv_nxt[3] = BUF->seqno[3];
1346 uip_connr->rcv_nxt[2] = BUF->seqno[2];
1347 uip_connr->rcv_nxt[1] = BUF->seqno[1];
1348 uip_connr->rcv_nxt[0] = BUF->seqno[0];
1349 uip_add_rcv_nxt(1);
1350
1351 /* Parse the TCP MSS option, if present. */
1352 if((BUF->tcpoffset & 0xf0) > 0x50) {
1353 for(c = 0; c < ((BUF->tcpoffset >> 4) - 5) << 2 ;) {
1354 opt = uip_buf[UIP_TCPIP_HLEN + UIP_LLH_LEN + c];
1355 if(opt == TCP_OPT_END) {
1356 /* End of options. */
1357 break;
1358 } else if(opt == TCP_OPT_NOOP) {
1359 ++c;
1360 /* NOP option. */
1361 } else if(opt == TCP_OPT_MSS &&
1362 uip_buf[UIP_TCPIP_HLEN + UIP_LLH_LEN + 1 + c] == TCP_OPT_MSS_LEN) {
1363 /* An MSS option with the right option length. */
1364 tmp16 = ((u16_t)uip_buf[UIP_TCPIP_HLEN + UIP_LLH_LEN + 2 + c] << 8) |
1365 (u16_t)uip_buf[UIP_IPTCPH_LEN + UIP_LLH_LEN + 3 + c];
1366 uip_connr->initialmss = uip_connr->mss =
1367 tmp16 > UIP_TCP_MSS? UIP_TCP_MSS: tmp16;
1368
1369 /* And we are done processing options. */
1370 break;
1371 } else {
1372 /* All other options have a length field, so that we easily
1373 can skip past them. */
1374 if(uip_buf[UIP_TCPIP_HLEN + UIP_LLH_LEN + 1 + c] == 0) {
1375 /* If the length field is zero, the options are malformed
1376 and we don't process them further. */
1377 break;
1378 }
1379 c += uip_buf[UIP_TCPIP_HLEN + UIP_LLH_LEN + 1 + c];
1380 }
1381 }
1382 }
1383
1384 /* Our response will be a SYNACK. */
1385 #if UIP_ACTIVE_OPEN
1386 tcp_send_synack:
1387 BUF->flags = TCP_ACK;
1388
1389 tcp_send_syn:
1390 BUF->flags |= TCP_SYN;
1391 #else /* UIP_ACTIVE_OPEN */
1392 tcp_send_synack:
1393 BUF->flags = TCP_SYN | TCP_ACK;
1394 #endif /* UIP_ACTIVE_OPEN */
1395
1396 /* We send out the TCP Maximum Segment Size option with our
1397 SYNACK. */
1398 BUF->optdata[0] = TCP_OPT_MSS;
1399 BUF->optdata[1] = TCP_OPT_MSS_LEN;
1400 BUF->optdata[2] = (UIP_TCP_MSS) / 256;
1401 BUF->optdata[3] = (UIP_TCP_MSS) & 255;
1402 uip_len = UIP_IPTCPH_LEN + TCP_OPT_MSS_LEN;
1403 BUF->tcpoffset = ((UIP_TCPH_LEN + TCP_OPT_MSS_LEN) / 4) << 4;
1404 goto tcp_send;
1405
1406 /* This label will be jumped to if we found an active connection. */
1407 found:
1408 uip_conn = uip_connr;
1409 uip_flags = 0;
1410 /* We do a very naive form of TCP reset processing; we just accept
1411 any RST and kill our connection. We should in fact check if the
1412 sequence number of this reset is wihtin our advertised window
1413 before we accept the reset. */
1414 if(BUF->flags & TCP_RST) {
1415 uip_connr->tcpstateflags = UIP_CLOSED;
1416 UIP_LOG("tcp: got reset, aborting connection.");
1417 uip_flags = UIP_ABORT;
1418 UIP_APPCALL();
1419 goto drop;
1420 }
1421 /* Calculate the length of the data, if the application has sent
1422 any data to us. */
1423 c = (BUF->tcpoffset >> 4) << 2;
1424 /* uip_len will contain the length of the actual TCP data. This is
1425 calculated by subtracing the length of the TCP header (in
1426 c) and the length of the IP header (20 bytes). */
1427 uip_len = uip_len - c - UIP_IPH_LEN;
1428
1429 /* First, check if the sequence number of the incoming packet is
1430 what we're expecting next. If not, we send out an ACK with the
1431 correct numbers in. */
1432 if(!(((uip_connr->tcpstateflags & UIP_TS_MASK) == UIP_SYN_SENT) &&
1433 ((BUF->flags & TCP_CTL) == (TCP_SYN | TCP_ACK)))) {
1434 if((uip_len > 0 || ((BUF->flags & (TCP_SYN | TCP_FIN)) != 0)) &&
1435 (BUF->seqno[0] != uip_connr->rcv_nxt[0] ||
1436 BUF->seqno[1] != uip_connr->rcv_nxt[1] ||
1437 BUF->seqno[2] != uip_connr->rcv_nxt[2] ||
1438 BUF->seqno[3] != uip_connr->rcv_nxt[3])) {
1439 goto tcp_send_ack;
1440 }
1441 }
1442
1443 /* Next, check if the incoming segment acknowledges any outstanding
1444 data. If so, we update the sequence number, reset the length of
1445 the outstanding data, calculate RTT estimations, and reset the
1446 retransmission timer. */
1447 if((BUF->flags & TCP_ACK) && uip_outstanding(uip_connr)) {
1448 uip_add32(uip_connr->snd_nxt, uip_connr->len);
1449
1450 if(BUF->ackno[0] == uip_acc32[0] &&
1451 BUF->ackno[1] == uip_acc32[1] &&
1452 BUF->ackno[2] == uip_acc32[2] &&
1453 BUF->ackno[3] == uip_acc32[3]) {
1454 /* Update sequence number. */
1455 uip_connr->snd_nxt[0] = uip_acc32[0];
1456 uip_connr->snd_nxt[1] = uip_acc32[1];
1457 uip_connr->snd_nxt[2] = uip_acc32[2];
1458 uip_connr->snd_nxt[3] = uip_acc32[3];
1459
1460 /* Do RTT estimation, unless we have done retransmissions. */
1461 if(uip_connr->nrtx == 0) {
1462 signed char m;
1463 m = uip_connr->rto - uip_connr->timer;
1464 /* This is taken directly from VJs original code in his paper */
1465 m = m - (uip_connr->sa >> 3);
1466 uip_connr->sa += m;
1467 if(m < 0) {
1468 m = -m;
1469 }
1470 m = m - (uip_connr->sv >> 2);
1471 uip_connr->sv += m;
1472 uip_connr->rto = (uip_connr->sa >> 3) + uip_connr->sv;
1473
1474 }
1475 /* Set the acknowledged flag. */
1476 uip_flags = UIP_ACKDATA;
1477 /* Reset the retransmission timer. */
1478 uip_connr->timer = uip_connr->rto;
1479
1480 /* Reset length of outstanding data. */
1481 uip_connr->len = 0;
1482 }
1483
1484 }
1485
1486 /* Do different things depending on in what state the connection is. */
1487 switch(uip_connr->tcpstateflags & UIP_TS_MASK) {
1488 /* CLOSED and LISTEN are not handled here. CLOSE_WAIT is not
1489 implemented, since we force the application to close when the
1490 peer sends a FIN (hence the application goes directly from
1491 ESTABLISHED to LAST_ACK). */
1492 case UIP_SYN_RCVD:
1493 /* In SYN_RCVD we have sent out a SYNACK in response to a SYN, and
1494 we are waiting for an ACK that acknowledges the data we sent
1495 out the last time. Therefore, we want to have the UIP_ACKDATA
1496 flag set. If so, we enter the ESTABLISHED state. */
1497 if(uip_flags & UIP_ACKDATA) {
1498 uip_connr->tcpstateflags = UIP_ESTABLISHED;
1499 uip_flags = UIP_CONNECTED;
1500 uip_connr->len = 0;
1501 if(uip_len > 0) {
1502 uip_flags |= UIP_NEWDATA;
1503 uip_add_rcv_nxt(uip_len);
1504 }
1505 uip_slen = 0;
1506 UIP_APPCALL();
1507 goto appsend;
1508 }
1509 goto drop;
1510 #if UIP_ACTIVE_OPEN
1511 case UIP_SYN_SENT:
1512 /* In SYN_SENT, we wait for a SYNACK that is sent in response to
1513 our SYN. The rcv_nxt is set to sequence number in the SYNACK
1514 plus one, and we send an ACK. We move into the ESTABLISHED
1515 state. */
1516 if((uip_flags & UIP_ACKDATA) &&
1517 (BUF->flags & TCP_CTL) == (TCP_SYN | TCP_ACK)) {
1518
1519 /* Parse the TCP MSS option, if present. */
1520 if((BUF->tcpoffset & 0xf0) > 0x50) {
1521 for(c = 0; c < ((BUF->tcpoffset >> 4) - 5) << 2 ;) {
1522 opt = uip_buf[UIP_IPTCPH_LEN + UIP_LLH_LEN + c];
1523 if(opt == TCP_OPT_END) {
1524 /* End of options. */
1525 break;
1526 } else if(opt == TCP_OPT_NOOP) {
1527 ++c;
1528 /* NOP option. */
1529 } else if(opt == TCP_OPT_MSS &&
1530 uip_buf[UIP_TCPIP_HLEN + UIP_LLH_LEN + 1 + c] == TCP_OPT_MSS_LEN) {
1531 /* An MSS option with the right option length. */
1532 tmp16 = (uip_buf[UIP_TCPIP_HLEN + UIP_LLH_LEN + 2 + c] << 8) |
1533 uip_buf[UIP_TCPIP_HLEN + UIP_LLH_LEN + 3 + c];
1534 uip_connr->initialmss =
1535 uip_connr->mss = tmp16 > UIP_TCP_MSS? UIP_TCP_MSS: tmp16;
1536
1537 /* And we are done processing options. */
1538 break;
1539 } else {
1540 /* All other options have a length field, so that we easily
1541 can skip past them. */
1542 if(uip_buf[UIP_TCPIP_HLEN + UIP_LLH_LEN + 1 + c] == 0) {
1543 /* If the length field is zero, the options are malformed
1544 and we don't process them further. */
1545 break;
1546 }
1547 c += uip_buf[UIP_TCPIP_HLEN + UIP_LLH_LEN + 1 + c];
1548 }
1549 }
1550 }
1551 uip_connr->tcpstateflags = UIP_ESTABLISHED;
1552 uip_connr->rcv_nxt[0] = BUF->seqno[0];
1553 uip_connr->rcv_nxt[1] = BUF->seqno[1];
1554 uip_connr->rcv_nxt[2] = BUF->seqno[2];
1555 uip_connr->rcv_nxt[3] = BUF->seqno[3];
1556 uip_add_rcv_nxt(1);
1557 uip_flags = UIP_CONNECTED | UIP_NEWDATA;
1558 uip_connr->len = 0;
1559 uip_len = 0;
1560 uip_slen = 0;
1561 UIP_APPCALL();
1562 goto appsend;
1563 }
1564 /* Inform the application that the connection failed */
1565 uip_flags = UIP_ABORT;
1566 UIP_APPCALL();
1567 /* The connection is closed after we send the RST */
1568 uip_conn->tcpstateflags = UIP_CLOSED;
1569 goto reset;
1570 #endif /* UIP_ACTIVE_OPEN */
1571
1572 case UIP_ESTABLISHED:
1573 /* In the ESTABLISHED state, we call upon the application to feed
1574 data into the uip_buf. If the UIP_ACKDATA flag is set, the
1575 application should put new data into the buffer, otherwise we are
1576 retransmitting an old segment, and the application should put that
1577 data into the buffer.
1578
1579 If the incoming packet is a FIN, we should close the connection on
1580 this side as well, and we send out a FIN and enter the LAST_ACK
1581 state. We require that there is no outstanding data; otherwise the
1582 sequence numbers will be screwed up. */
1583
1584 if(BUF->flags & TCP_FIN && !(uip_connr->tcpstateflags & UIP_STOPPED)) {
1585 if(uip_outstanding(uip_connr)) {
1586 goto drop;
1587 }
1588 uip_add_rcv_nxt(1 + uip_len);
1589 uip_flags |= UIP_CLOSE;
1590 if(uip_len > 0) {
1591 uip_flags |= UIP_NEWDATA;
1592 }
1593 UIP_APPCALL();
1594 uip_connr->len = 1;
1595 uip_connr->tcpstateflags = UIP_LAST_ACK;
1596 uip_connr->nrtx = 0;
1597 tcp_send_finack:
1598 BUF->flags = TCP_FIN | TCP_ACK;
1599 goto tcp_send_nodata;
1600 }
1601
1602 /* Check the URG flag. If this is set, the segment carries urgent
1603 data that we must pass to the application. */
1604 if((BUF->flags & TCP_URG) != 0) {
1605 #if UIP_URGDATA > 0
1606 uip_urglen = (BUF->urgp[0] << 8) | BUF->urgp[1];
1607 if(uip_urglen > uip_len) {
1608 /* There is more urgent data in the next segment to come. */
1609 uip_urglen = uip_len;
1610 }
1611 uip_add_rcv_nxt(uip_urglen);
1612 uip_len -= uip_urglen;
1613 uip_urgdata = uip_appdata;
1614 uip_appdata += uip_urglen;
1615 } else {
1616 uip_urglen = 0;
1617 #else /* UIP_URGDATA > 0 */
1618 uip_appdata = ((char *)uip_appdata) + ((BUF->urgp[0] << 8) | BUF->urgp[1]);
1619 uip_len -= (BUF->urgp[0] << 8) | BUF->urgp[1];
1620 #endif /* UIP_URGDATA > 0 */
1621 }
1622
1623 /* If uip_len > 0 we have TCP data in the packet, and we flag this
1624 by setting the UIP_NEWDATA flag and update the sequence number
1625 we acknowledge. If the application has stopped the dataflow
1626 using uip_stop(), we must not accept any data packets from the
1627 remote host. */
1628 if(uip_len > 0 && !(uip_connr->tcpstateflags & UIP_STOPPED)) {
1629 uip_flags |= UIP_NEWDATA;
1630 uip_add_rcv_nxt(uip_len);
1631 }
1632
1633 /* Check if the available buffer space advertised by the other end
1634 is smaller than the initial MSS for this connection. If so, we
1635 set the current MSS to the window size to ensure that the
1636 application does not send more data than the other end can
1637 handle.
1638
1639 If the remote host advertises a zero window, we set the MSS to
1640 the initial MSS so that the application will send an entire MSS
1641 of data. This data will not be acknowledged by the receiver,
1642 and the application will retransmit it. This is called the
1643 "persistent timer" and uses the retransmission mechanim.
1644 */
1645 tmp16 = ((u16_t)BUF->wnd[0] << 8) + (u16_t)BUF->wnd[1];
1646 if(tmp16 > uip_connr->initialmss ||
1647 tmp16 == 0) {
1648 tmp16 = uip_connr->initialmss;
1649 }
1650 uip_connr->mss = tmp16;
1651
1652 /* If this packet constitutes an ACK for outstanding data (flagged
1653 by the UIP_ACKDATA flag, we should call the application since it
1654 might want to send more data. If the incoming packet had data
1655 from the peer (as flagged by the UIP_NEWDATA flag), the
1656 application must also be notified.
1657
1658 When the application is called, the global variable uip_len
1659 contains the length of the incoming data. The application can
1660 access the incoming data through the global pointer
1661 uip_appdata, which usually points UIP_IPTCPH_LEN + UIP_LLH_LEN
1662 bytes into the uip_buf array.
1663
1664 If the application wishes to send any data, this data should be
1665 put into the uip_appdata and the length of the data should be
1666 put into uip_len. If the application don't have any data to
1667 send, uip_len must be set to 0. */
1668 if(uip_flags & (UIP_NEWDATA | UIP_ACKDATA)) {
1669 uip_slen = 0;
1670 UIP_APPCALL();
1671
1672 appsend:
1673
1674 if(uip_flags & UIP_ABORT) {
1675 uip_slen = 0;
1676 uip_connr->tcpstateflags = UIP_CLOSED;
1677 BUF->flags = TCP_RST | TCP_ACK;
1678 goto tcp_send_nodata;
1679 }
1680
1681 if(uip_flags & UIP_CLOSE) {
1682 uip_slen = 0;
1683 uip_connr->len = 1;
1684 uip_connr->tcpstateflags = UIP_FIN_WAIT_1;
1685 uip_connr->nrtx = 0;
1686 BUF->flags = TCP_FIN | TCP_ACK;
1687 goto tcp_send_nodata;
1688 }
1689
1690 /* If uip_slen > 0, the application has data to be sent. */
1691 if(uip_slen > 0) {
1692
1693 /* If the connection has acknowledged data, the contents of
1694 the ->len variable should be discarded. */
1695 if((uip_flags & UIP_ACKDATA) != 0) {
1696 uip_connr->len = 0;
1697 }
1698
1699 /* If the ->len variable is non-zero the connection has
1700 already data in transit and cannot send anymore right
1701 now. */
1702 if(uip_connr->len == 0) {
1703
1704 /* The application cannot send more than what is allowed by
1705 the mss (the minumum of the MSS and the available
1706 window). */
1707 if(uip_slen > uip_connr->mss) {
1708 uip_slen = uip_connr->mss;
1709 }
1710
1711 /* Remember how much data we send out now so that we know
1712 when everything has been acknowledged. */
1713 uip_connr->len = uip_slen;
1714 } else {
1715
1716 /* If the application already had unacknowledged data, we
1717 make sure that the application does not send (i.e.,
1718 retransmit) out more than it previously sent out. */
1719 uip_slen = uip_connr->len;
1720 }
1721 }
1722 uip_connr->nrtx = 0;
1723 apprexmit:
1724 uip_appdata = uip_sappdata;
1725
1726 /* If the application has data to be sent, or if the incoming
1727 packet had new data in it, we must send out a packet. */
1728 if(uip_slen > 0 && uip_connr->len > 0) {
1729 /* Add the length of the IP and TCP headers. */
1730 uip_len = uip_connr->len + UIP_TCPIP_HLEN;
1731 /* We always set the ACK flag in response packets. */
1732 BUF->flags = TCP_ACK | TCP_PSH;
1733 /* Send the packet. */
1734 goto tcp_send_noopts;
1735 }
1736 /* If there is no data to send, just send out a pure ACK if
1737 there is newdata. */
1738 if(uip_flags & UIP_NEWDATA) {
1739 uip_len = UIP_TCPIP_HLEN;
1740 BUF->flags = TCP_ACK;
1741 goto tcp_send_noopts;
1742 }
1743 }
1744 goto drop;
1745 case UIP_LAST_ACK:
1746 /* We can close this connection if the peer has acknowledged our
1747 FIN. This is indicated by the UIP_ACKDATA flag. */
1748 if(uip_flags & UIP_ACKDATA) {
1749 uip_connr->tcpstateflags = UIP_CLOSED;
1750 uip_flags = UIP_CLOSE;
1751 UIP_APPCALL();
1752 }
1753 break;
1754
1755 case UIP_FIN_WAIT_1:
1756 /* The application has closed the connection, but the remote host
1757 hasn't closed its end yet. Thus we do nothing but wait for a
1758 FIN from the other side. */
1759 if(uip_len > 0) {
1760 uip_add_rcv_nxt(uip_len);
1761 }
1762 if(BUF->flags & TCP_FIN) {
1763 if(uip_flags & UIP_ACKDATA) {
1764 uip_connr->tcpstateflags = UIP_TIME_WAIT;
1765 uip_connr->timer = 0;
1766 uip_connr->len = 0;
1767 } else {
1768 uip_connr->tcpstateflags = UIP_CLOSING;
1769 }
1770 uip_add_rcv_nxt(1);
1771 uip_flags = UIP_CLOSE;
1772 UIP_APPCALL();
1773 goto tcp_send_ack;
1774 } else if(uip_flags & UIP_ACKDATA) {
1775 uip_connr->tcpstateflags = UIP_FIN_WAIT_2;
1776 uip_connr->len = 0;
1777 goto drop;
1778 }
1779 if(uip_len > 0) {
1780 goto tcp_send_ack;
1781 }
1782 goto drop;
1783
1784 case UIP_FIN_WAIT_2:
1785 if(uip_len > 0) {
1786 uip_add_rcv_nxt(uip_len);
1787 }
1788 if(BUF->flags & TCP_FIN) {
1789 uip_connr->tcpstateflags = UIP_TIME_WAIT;
1790 uip_connr->timer = 0;
1791 uip_add_rcv_nxt(1);
1792 uip_flags = UIP_CLOSE;
1793 UIP_APPCALL();
1794 goto tcp_send_ack;
1795 }
1796 if(uip_len > 0) {
1797 goto tcp_send_ack;
1798 }
1799 goto drop;
1800
1801 case UIP_TIME_WAIT:
1802 goto tcp_send_ack;
1803
1804 case UIP_CLOSING:
1805 if(uip_flags & UIP_ACKDATA) {
1806 uip_connr->tcpstateflags = UIP_TIME_WAIT;
1807 uip_connr->timer = 0;
1808 }
1809 }
1810 goto drop;
1811
1812 /* We jump here when we are ready to send the packet, and just want
1813 to set the appropriate TCP sequence numbers in the TCP header. */
1814 tcp_send_ack:
1815 BUF->flags = TCP_ACK;
1816
1817 tcp_send_nodata:
1818 uip_len = UIP_IPTCPH_LEN;
1819
1820 tcp_send_noopts:
1821 BUF->tcpoffset = (UIP_TCPH_LEN / 4) << 4;
1822
1823 /* We're done with the input processing. We are now ready to send a
1824 reply. Our job is to fill in all the fields of the TCP and IP
1825 headers before calculating the checksum and finally send the
1826 packet. */
1827 tcp_send:
1828 BUF->ackno[0] = uip_connr->rcv_nxt[0];
1829 BUF->ackno[1] = uip_connr->rcv_nxt[1];
1830 BUF->ackno[2] = uip_connr->rcv_nxt[2];
1831 BUF->ackno[3] = uip_connr->rcv_nxt[3];
1832
1833 BUF->seqno[0] = uip_connr->snd_nxt[0];
1834 BUF->seqno[1] = uip_connr->snd_nxt[1];
1835 BUF->seqno[2] = uip_connr->snd_nxt[2];
1836 BUF->seqno[3] = uip_connr->snd_nxt[3];
1837
1838 BUF->proto = UIP_PROTO_TCP;
1839
1840 BUF->srcport = uip_connr->lport;
1841 BUF->destport = uip_connr->rport;
1842
1843 uip_ipaddr_copy(&BUF->srcipaddr, &uip_hostaddr);
1844 uip_ipaddr_copy(&BUF->destipaddr, &uip_connr->ripaddr);
1845
1846 if(uip_connr->tcpstateflags & UIP_STOPPED) {
1847 /* If the connection has issued uip_stop(), we advertise a zero
1848 window so that the remote host will stop sending data. */
1849 BUF->wnd[0] = BUF->wnd[1] = 0;
1850 } else {
1851 BUF->wnd[0] = ((UIP_RECEIVE_WINDOW) >> 8);
1852 BUF->wnd[1] = ((UIP_RECEIVE_WINDOW) & 0xff);
1853 }
1854
1855 tcp_send_noconn:
1856 BUF->ttl = UIP_TTL;
1857 #if UIP_CONF_IPV6
1858 /* For IPv6, the IP length field does not include the IPv6 IP header
1859 length. */
1860 BUF->len[0] = ((uip_len - UIP_IPH_LEN) >> 8);
1861 BUF->len[1] = ((uip_len - UIP_IPH_LEN) & 0xff);
1862 #else /* UIP_CONF_IPV6 */
1863 BUF->len[0] = (uip_len >> 8);
1864 BUF->len[1] = (uip_len & 0xff);
1865 #endif /* UIP_CONF_IPV6 */
1866
1867 BUF->urgp[0] = BUF->urgp[1] = 0;
1868
1869 /* Calculate TCP checksum. */
1870 BUF->tcpchksum = 0;
1871 BUF->tcpchksum = ~(uip_tcpchksum());
1872
1873 ip_send_nolen:
1874 #if UIP_CONF_IPV6
1875 BUF->vtc = 0x60;
1876 BUF->tcflow = 0x00;
1877 BUF->flow = 0x00;
1878 #else /* UIP_CONF_IPV6 */
1879 BUF->vhl = 0x45;
1880 BUF->tos = 0;
1881 BUF->ipoffset[0] = BUF->ipoffset[1] = 0;
1882 ++ipid;
1883 BUF->ipid[0] = ipid >> 8;
1884 BUF->ipid[1] = ipid & 0xff;
1885 /* Calculate IP checksum. */
1886 BUF->ipchksum = 0;
1887 BUF->ipchksum = ~(uip_ipchksum());
1888 DEBUG_PRINTF("uip ip_send_nolen: chkecum 0x%04x\n", uip_ipchksum());
1889 #endif /* UIP_CONF_IPV6 */
1890 UIP_STAT(++uip_stat.tcp.sent);
1891 #if UIP_CONF_IPV6
1892 send:
1893 #endif /* UIP_CONF_IPV6 */
1894 DEBUG_PRINTF("Sending packet with length %d (%d)\n", uip_len,
1895 (BUF->len[0] << 8) | BUF->len[1]);
1896
1897 UIP_STAT(++uip_stat.ip.sent);
1898 /* Return and let the caller do the actual transmission. */
1899 uip_flags = 0;
1900 return;
1901
1902 drop:
1903 uip_len = 0;
1904 uip_flags = 0;
1905 return;
1906 }
1907 /*---------------------------------------------------------------------------*/
1908 u16_t
1909 htons(u16_t val)
1910 {
1911 return HTONS(val);
1912 }
1913
1914 u32_t
1915 htonl(u32_t val)
1916 {
1917 return HTONL(val);
1918 }
1919 /*---------------------------------------------------------------------------*/
1920 void
1921 uip_send(const void *data, int len)
1922 {
1923 int copylen;
1924 #define MIN(a,b) ((a) < (b)? (a): (b))
1925 copylen = MIN(len, UIP_BUFSIZE - UIP_LLH_LEN - UIP_TCPIP_HLEN -
1926 (int)((char *)uip_sappdata - (char *)&uip_buf[UIP_LLH_LEN + UIP_TCPIP_HLEN]));
1927 if(copylen > 0) {
1928 uip_slen = copylen;
1929 if(data != uip_sappdata) {
1930 memcpy(uip_sappdata, (data), uip_slen);
1931 }
1932 }
1933 }
1934 /*---------------------------------------------------------------------------*/
1935 /** @} */
1936 #endif /* UIP_CONF_IPV6 */
USB isp AVR programmer