projects / openwrt.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
[package] base-files: prime root password with "x" to notify programs that there...
[openwrt.git] / package / uboot-lantiq / patches / 200-httpd.patch
1 --- a/common/cmd_net.c
2 +++ b/common/cmd_net.c
3 @@ -43,6 +43,18 @@ U_BOOT_CMD(
4 "[loadAddress] [[hostIPaddr:]bootfilename]"
5 );
6
7 +#if defined(CONFIG_CMD_HTTPD)
8 +int do_httpd (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
9 +{
10 + return NetLoopHttpd();
11 +}
12 +
13 +U_BOOT_CMD(
14 + httpd, 1, 1, do_httpd,
15 + "httpd\t- start webserver", ""
16 +);
17 +#endif
18 +
19 int do_tftpb (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
20 {
21 return netboot_common (TFTP, cmdtp, argc, argv);
22 --- /dev/null
23 +++ b/include/httpd.h
24 @@ -0,0 +1,17 @@
25 +#ifndef _UIP_HTTPD_H__
26 +#define _UIP_HTTPD_H__
27 +
28 +void HttpdStart (void);
29 +void HttpdHandler (void);
30 +
31 +/* board specific implementation */
32 +extern int do_http_upgrade(const unsigned char *data, const ulong size);
33 +
34 +#define HTTP_PROGRESS_START 0
35 +#define HTTP_PROGRESS_TIMEOUT 1
36 +#define HTTP_PROGRESS_UPLOAD_READY 2
37 +#define HTTP_PROGRESS_UGRADE_READY 3
38 +#define HTTP_PROGRESS_UGRADE_FAILED 4
39 +extern int do_http_progress(const int state);
40 +
41 +#endif
42 --- a/include/net.h
43 +++ b/include/net.h
44 @@ -383,7 +383,8 @@ extern int NetTimeOffset; /* offset ti
45
46 /* Initialize the network adapter */
47 extern int NetLoop(proto_t);
48 -
49 +extern int NetLoopHttpd(void);
50 +extern void NetSendHttpd(void);
51 /* Shutdown adapters and cleanup */
52 extern void NetStop(void);
53
54 --- a/net/Makefile
55 +++ b/net/Makefile
56 @@ -26,6 +26,8 @@ include $(TOPDIR)/config.mk
57 # CFLAGS += -DDEBUG
58
59 LIB = $(obj)libnet.a
60 +UIPDIR = uip-0.9
61 +$(shell mkdir -p $(obj)$(UIPDIR))
62
63 COBJS-$(CONFIG_CMD_NET) += bootp.o
64 COBJS-$(CONFIG_CMD_DNS) += dns.o
65 @@ -36,6 +40,8 @@ COBJS-$(CONFIG_CMD_NET) += rarp.o
66 COBJS-$(CONFIG_CMD_SNTP) += sntp.o
67 COBJS-$(CONFIG_CMD_NET) += tftp.o
68
69 +COBJS-$(CONFIG_CMD_HTTPD) += httpd.o $(UIPDIR)/fs.o $(UIPDIR)/httpd.o $(UIPDIR)/uip_arp.o $(UIPDIR)/uip_arch.o $(UIPDIR)/uip.o
70 +
71 COBJS := $(COBJS-y)
72 SRCS := $(COBJS:.o=.c)
73 OBJS := $(addprefix $(obj),$(COBJS))
74 --- /dev/null
75 +++ b/net/httpd.c
76 @@ -0,0 +1,52 @@
77 +/*
78 + * Copyright 1994, 1995, 2000 Neil Russell.
79 + * (See License)
80 + * Copyright 2000, 2001 DENX Software Engineering, Wolfgang Denk, wd@denx.de
81 + */
82 +
83 +#include <common.h>
84 +#include <command.h>
85 +#include <net.h>
86 +#include "uip-0.9/uipopt.h"
87 +#include "uip-0.9/uip.h"
88 +#include "uip-0.9/uip_arp.h"
89 +
90 +
91 +#if defined(CONFIG_CMD_HTTPD)
92 +
93 +#define TIMEOUT 5
94 +
95 +static int arptimer = 0;
96 +
97 +void
98 +HttpdHandler (void)
99 +{
100 + int i;
101 + for(i = 0; i < UIP_CONNS; i++) {
102 + uip_periodic(i);
103 + if(uip_len > 0) {
104 + uip_arp_out();
105 + NetSendHttpd();
106 + }
107 + }
108 + if(++arptimer == 20) {
109 + uip_arp_timer();
110 + arptimer = 0;
111 + }
112 +}
113 +
114 +static void
115 +HttpdTimeout (void)
116 +{
117 + puts ("T ");
118 + NetSetTimeout (TIMEOUT * 1000, HttpdTimeout);
119 +}
120 +
121 +void
122 +HttpdStart (void)
123 +{
124 + uip_init();
125 + httpd_init();
126 +}
127 +
128 +#endif
129 --- a/net/net.c
130 +++ b/net/net.c
131 @@ -95,6 +95,19 @@
132 #if defined(CONFIG_CMD_DNS)
133 #include "dns.h"
134 #endif
135 +#if defined(CONFIG_CMD_HTTPD)
136 +#include "httpd.h"
137 +#include "uip-0.9/uipopt.h"
138 +#include "uip-0.9/uip.h"
139 +#include "uip-0.9/uip_arp.h"
140 +static int https_running = 0;
141 +int httpd_upload_complete = 0;
142 +unsigned char *httpd_upload_data = 0;
143 +extern int upload_running;
144 +void NetReceiveHttpd(volatile uchar * inpkt, int len);
145 +void NetSendHttpd(void);
146 +extern int do_reset (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[]);
147 +#endif
148
149 DECLARE_GLOBAL_DATA_PTR;
150
151 @@ -1308,6 +1321,13 @@ NetReceive(volatile uchar * inpkt, int l
152
153 debug("packet received\n");
154
155 +#if defined(CONFIG_CMD_HTTPD)
156 + if(https_running) {
157 + NetReceiveHttpd(inpkt, len);
158 + return;
159 + }
160 +#endif
161 +
162 NetRxPacket = inpkt;
163 NetRxPacketLen = len;
164 et = (Ethernet_t *)inpkt;
165 @@ -1922,3 +1942,162 @@ ushort getenv_VLAN(char *var)
166 {
167 return (string_to_VLAN(getenv(var)));
168 }
169 +
170 +#if defined(CONFIG_CMD_HTTPD)
171 +
172 +void
173 +NetSendHttpd(void)
174 +{
175 + volatile uchar *tmpbuf = NetTxPacket;
176 + int i;
177 +
178 + for(i = 0; i < 40 + UIP_LLH_LEN; i++) {
179 + tmpbuf[i] = uip_buf[i];
180 + }
181 +
182 + for(; i < uip_len; i++) {
183 + tmpbuf[i] = uip_appdata[i - 40 - UIP_LLH_LEN];
184 + }
185 + eth_send(NetTxPacket, uip_len);
186 +}
187 +
188 +#define BUF ((struct uip_eth_hdr *)&uip_buf[0])
189 +
190 +void
191 +NetReceiveHttpd(volatile uchar * inpkt, int len)
192 +{
193 + memcpy(uip_buf, inpkt, len);
194 + uip_len = len;
195 + if(BUF->type == htons(UIP_ETHTYPE_IP)) {
196 + uip_arp_ipin();
197 + uip_input();
198 + if(uip_len > 0) {
199 + uip_arp_out();
200 + NetSendHttpd();
201 + }
202 + } else if(BUF->type == htons(UIP_ETHTYPE_ARP)) {
203 + uip_arp_arpin();
204 + if(uip_len > 0) {
205 + NetSendHttpd();
206 + }
207 + }
208 +}
209 +
210 +int
211 +NetLoopHttpd(void)
212 +{
213 + unsigned long long tout = 0;
214 + bd_t *bd = gd->bd;
215 + unsigned short int ip[2];
216 +
217 +#ifdef CONFIG_NET_MULTI
218 + NetRestarted = 0;
219 + NetDevExists = 0;
220 +#endif
221 +
222 + /* XXX problem with bss workaround */
223 + NetArpWaitPacketMAC = NULL;
224 + NetArpWaitTxPacket = NULL;
225 + NetArpWaitPacketIP = 0;
226 + NetArpWaitReplyIP = 0;
227 + NetArpWaitTxPacket = NULL;
228 + NetTxPacket = NULL;
229 + NetTryCount = 1;
230 +
231 + if (!NetTxPacket) {
232 + int i;
233 + /*
234 + * Setup packet buffers, aligned correctly.
235 + */
236 + NetTxPacket = &PktBuf[0] + (PKTALIGN - 1);
237 + NetTxPacket -= (ulong)NetTxPacket % PKTALIGN;
238 + for (i = 0; i < PKTBUFSRX; i++) {
239 + NetRxPackets[i] = NetTxPacket + (i+1)*PKTSIZE_ALIGN;
240 + }
241 + }
242 +
243 + if (!NetArpWaitTxPacket) {
244 + NetArpWaitTxPacket = &NetArpWaitPacketBuf[0] + (PKTALIGN - 1);
245 + NetArpWaitTxPacket -= (ulong)NetArpWaitTxPacket % PKTALIGN;
246 + NetArpWaitTxPacketSize = 0;
247 + }
248 +
249 +restart:
250 +
251 + eth_halt();
252 +#ifdef CONFIG_NET_MULTI
253 + eth_set_current();
254 +#endif
255 + if (eth_init(bd) < 0) {
256 + eth_halt();
257 + return(-1);
258 + }
259 +
260 +#ifdef CONFIG_NET_MULTI
261 + memcpy (NetOurEther, eth_get_dev()->enetaddr, 6);
262 +#else
263 + eth_getenv_enetaddr("ethaddr", NetOurEther);
264 +#endif
265 +
266 + NetCopyIP(&NetOurIP, &bd->bi_ip_addr);
267 + NetOurGatewayIP = getenv_IPaddr ("gatewayip");
268 + NetOurSubnetMask= getenv_IPaddr ("netmask");
269 + NetOurVLAN = getenv_VLAN("vlan");
270 + NetOurNativeVLAN = getenv_VLAN("nvlan");
271 +
272 + printf("starting httpd server from server %ld.%ld.%ld.%ld\n",
273 + (bd->bi_ip_addr & 0xff000000) >> 24,
274 + (bd->bi_ip_addr & 0x00ff0000) >> 16,
275 + (bd->bi_ip_addr & 0x0000ff00) >> 8,
276 + (bd->bi_ip_addr & 0x000000ff));
277 +
278 + HttpdStart();
279 +
280 + ip[0] = ((bd->bi_ip_addr & 0xffff0000) >> 16);
281 + ip[1] = (bd->bi_ip_addr & 0x0000ffff);
282 + uip_sethostaddr(ip);
283 +
284 + do_http_progress(HTTP_PROGRESS_START);
285 +
286 + https_running = 1;
287 + for (;;) {
288 + unsigned long long t1;
289 + WATCHDOG_RESET();
290 + if(eth_rx() > 0) {
291 + HttpdHandler();
292 + } else {
293 + t1 = get_ticks();
294 + if(t1 - tout > 1000) {
295 + do_http_progress(HTTP_PROGRESS_TIMEOUT);
296 + tout = t1;
297 + }
298 + }
299 + if(!httpd_upload_complete)
300 + continue;
301 + printf("Bytes transferred = %ld (%lx hex)\n",
302 + NetBootFileXferSize,
303 + NetBootFileXferSize);
304 + eth_halt();
305 + do_http_progress(HTTP_PROGRESS_UPLOAD_READY);
306 + if(do_http_upgrade(&httpd_upload_data[0], NetBootFileXferSize) == 0) {
307 + do_http_progress(HTTP_PROGRESS_UGRADE_READY);
308 + udelay(1000 * 10);
309 + do_reset (0,0,0,0);
310 + return 0;
311 + }
312 + break;
313 + }
314 + https_running = 0;
315 + NetBootFileXferSize = 0;
316 + httpd_upload_complete = 0;
317 + upload_running = 0;
318 +// free(httpd_upload_data);
319 +
320 + do_http_progress(HTTP_PROGRESS_UGRADE_FAILED);
321 +
322 + goto restart;
323 +
324 + return -1;
325 +}
326 +
327 +#endif
328 --- /dev/null
329 +++ b/net/uip-0.9/Makefile
330 @@ -0,0 +1,54 @@
331 +# Copyright (c) 2001, Adam Dunkels.
332 +# All rights reserved.
333 +#
334 +# Redistribution and use in source and binary forms, with or without
335 +# modification, are permitted provided that the following conditions
336 +# are met:
337 +# 1. Redistributions of source code must retain the above copyright
338 +# notice, this list of conditions and the following disclaimer.
339 +# 2. Redistributions in binary form must reproduce the above copyright
340 +# notice, this list of conditions and the following disclaimer in the
341 +# documentation and/or other materials provided with the distribution.
342 +# 3. All advertising materials mentioning features or use of this software
343 +# must display the following acknowledgement:
344 +# This product includes software developed by Adam Dunkels.
345 +# 4. The name of the author may not be used to endorse or promote
346 +# products derived from this software without specific prior
347 +# written permission.
348 +#
349 +# THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS
350 +# OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
351 +# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
352 +# ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
353 +# DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
354 +# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
355 +# GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
356 +# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
357 +# WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
358 +# NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
359 +# SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
360 +#
361 +# This file is part of the uIP TCP/IP stack.
362 +#
363 +# $Id: Makefile,v 1.8.2.2 2003/10/04 22:54:17 adam Exp $
364 +#
365 +
366 +CC=gcc
367 +CFLAGS=-Wall -fpack-struct -DDUMP=0
368 +
369 +all: uip
370 +
371 +uip: uip.o uip_arch.o tapdev.o httpd.o main.o fs.o uip_arp.o
372 + $(CC) $(CFLAGS) $(LDFLAGS) $^ -o $@
373 +
374 +%.o: %.c
375 + $(CC) $(CFLAGS) -c $^ -o $@
376 +
377 +clean:
378 + rm -f *.o *~ *core uip
379 +
380 +
381 +
382 +
383 +
384 +
385 --- /dev/null
386 +++ b/net/uip-0.9/fs.c
387 @@ -0,0 +1,154 @@
388 +/**
389 + * \addtogroup httpd
390 + * @{
391 + */
392 +
393 +/**
394 + * \file
395 + * HTTP server read-only file system code.
396 + * \author Adam Dunkels <adam@dunkels.com>
397 + *
398 + * A simple read-only filesystem.
399 + */
400 +
401 +/*
402 + * Copyright (c) 2001, Swedish Institute of Computer Science.
403 + * All rights reserved.
404 + *
405 + * Redistribution and use in source and binary forms, with or without
406 + * modification, are permitted provided that the following conditions
407 + * are met:
408 + * 1. Redistributions of source code must retain the above copyright
409 + * notice, this list of conditions and the following disclaimer.
410 + * 2. Redistributions in binary form must reproduce the above copyright
411 + * notice, this list of conditions and the following disclaimer in the
412 + * documentation and/or other materials provided with the distribution.
413 + * 3. Neither the name of the Institute nor the names of its contributors
414 + * may be used to endorse or promote products derived from this software
415 + * without specific prior written permission.
416 + *
417 + * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
418 + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
419 + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
420 + * ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
421 + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
422 + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
423 + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
424 + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
425 + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
426 + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
427 + * SUCH DAMAGE.
428 + *
429 + * This file is part of the lwIP TCP/IP stack.
430 + *
431 + * Author: Adam Dunkels <adam@sics.se>
432 + *
433 + * $Id: fs.c,v 1.7.2.3 2003/10/07 13:22:27 adam Exp $
434 + */
435 +
436 +#include "uip.h"
437 +#include "httpd.h"
438 +#include "fs.h"
439 +#include "fsdata.h"
440 +
441 +#include "fsdata.c"
442 +
443 +#ifdef FS_STATISTICS
444 +#if FS_STATISTICS == 1
445 +static u16_t count[FS_NUMFILES];
446 +#endif /* FS_STATISTICS */
447 +#endif /* FS_STATISTICS */
448 +
449 +/*-----------------------------------------------------------------------------------*/
450 +static u8_t
451 +fs_strcmp(const char *str1, const char *str2)
452 +{
453 + u8_t i;
454 + i = 0;
455 + loop:
456 +
457 + if(str2[i] == 0 ||
458 + str1[i] == '\r' ||
459 + str1[i] == '\n') {
460 + return 0;
461 + }
462 +
463 + if(str1[i] != str2[i]) {
464 + return 1;
465 + }
466 +
467 +
468 + ++i;
469 + goto loop;
470 +}
471 +/*-----------------------------------------------------------------------------------*/
472 +int
473 +fs_open(const char *name, struct fs_file *file)
474 +{
475 +#ifdef FS_STATISTICS
476 +#if FS_STATISTICS == 1
477 + u16_t i = 0;
478 +#endif /* FS_STATISTICS */
479 +#endif /* FS_STATISTICS */
480 + struct fsdata_file_noconst *f;
481 +
482 + for(f = (struct fsdata_file_noconst *)FS_ROOT;
483 + f != NULL;
484 + f = (struct fsdata_file_noconst *)f->next) {
485 +
486 + if(fs_strcmp(name, f->name) == 0) {
487 + file->data = f->data;
488 + file->len = f->len;
489 +#ifdef FS_STATISTICS
490 +#if FS_STATISTICS == 1
491 + ++count[i];
492 +#endif /* FS_STATISTICS */
493 +#endif /* FS_STATISTICS */
494 + return 1;
495 + }
496 +#ifdef FS_STATISTICS
497 +#if FS_STATISTICS == 1
498 + ++i;
499 +#endif /* FS_STATISTICS */
500 +#endif /* FS_STATISTICS */
501 +
502 + }
503 + return 0;
504 +}
505 +/*-----------------------------------------------------------------------------------*/
506 +void
507 +fs_init(void)
508 +{
509 +#ifdef FS_STATISTICS
510 +#if FS_STATISTICS == 1
511 + u16_t i;
512 + for(i = 0; i < FS_NUMFILES; i++) {
513 + count[i] = 0;
514 + }
515 +#endif /* FS_STATISTICS */
516 +#endif /* FS_STATISTICS */
517 +}
518 +/*-----------------------------------------------------------------------------------*/
519 +#ifdef FS_STATISTICS
520 +#if FS_STATISTICS == 1
521 +u16_t fs_count
522 +(char *name)
523 +{
524 + struct fsdata_file_noconst *f;
525 + u16_t i;
526 +
527 + i = 0;
528 + for(f = (struct fsdata_file_noconst *)FS_ROOT;
529 + f != NULL;
530 + f = (struct fsdata_file_noconst *)f->next) {
531 +
532 + if(fs_strcmp(name, f->name) == 0) {
533 + return count[i];
534 + }
535 + ++i;
536 + }
537 + return 0;
538 +}
539 +#endif /* FS_STATISTICS */
540 +#endif /* FS_STATISTICS */
541 +/*-----------------------------------------------------------------------------------*/
542 --- /dev/null
543 +++ b/net/uip-0.9/fs.h
544 @@ -0,0 +1,80 @@
545 +/**
546 + * \addtogroup httpd
547 + * @{
548 + */
549 +
550 +/**
551 + * \file
552 + * HTTP server read-only file system header file.
553 + * \author Adam Dunkels <adam@dunkels.com>
554 + */
555 +
556 +/*
557 + * Copyright (c) 2001, Swedish Institute of Computer Science.
558 + * All rights reserved.
559 + *
560 + * Redistribution and use in source and binary forms, with or without
561 + * modification, are permitted provided that the following conditions
562 + * are met:
563 + * 1. Redistributions of source code must retain the above copyright
564 + * notice, this list of conditions and the following disclaimer.
565 + * 2. Redistributions in binary form must reproduce the above copyright
566 + * notice, this list of conditions and the following disclaimer in the
567 + * documentation and/or other materials provided with the distribution.
568 + * 3. Neither the name of the Institute nor the names of its contributors
569 + * may be used to endorse or promote products derived from this software
570 + * without specific prior written permission.
571 + *
572 + * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
573 + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
574 + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
575 + * ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
576 + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
577 + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
578 + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
579 + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
580 + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
581 + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
582 + * SUCH DAMAGE.
583 + *
584 + * This file is part of the lwIP TCP/IP stack.
585 + *
586 + * Author: Adam Dunkels <adam@sics.se>
587 + *
588 + * $Id: fs.h,v 1.6.2.3 2003/10/07 13:22:27 adam Exp $
589 + */
590 +#ifndef __FS_H__
591 +#define __FS_H__
592 +
593 +#include "uip.h"
594 +
595 +/**
596 + * An open file in the read-only file system.
597 + */
598 +struct fs_file {
599 + char *data; /**< The actual file data. */
600 + int len; /**< The length of the file data. */
601 +};
602 +
603 +/**
604 + * Open a file in the read-only file system.
605 + *
606 + * \param name The name of the file.
607 + *
608 + * \param file The file pointer, which must be allocated by caller and
609 + * will be filled in by the function.
610 + */
611 +int fs_open(const char *name, struct fs_file *file);
612 +
613 +#ifdef FS_STATISTICS
614 +#if FS_STATISTICS == 1
615 +u16_t fs_count(char *name);
616 +#endif /* FS_STATISTICS */
617 +#endif /* FS_STATISTICS */
618 +
619 +/**
620 + * Initialize the read-only file system.
621 + */
622 +void fs_init(void);
623 +
624 +#endif /* __FS_H__ */
625 --- /dev/null
626 +++ b/net/uip-0.9/fsdata.c
627 @@ -0,0 +1,199 @@
628 +static const char data_flashing_html[] = {
629 + /* /flashing.html */
630 + 0x2f, 0x66, 0x6c, 0x61, 0x73, 0x68, 0x69, 0x6e, 0x67, 0x2e, 0x68, 0x74, 0x6d, 0x6c, 0,
631 + 0x48, 0x54, 0x54, 0x50, 0x2f, 0x31, 0x2e, 0x30, 0x20, 0x32,
632 + 0x30, 0x30, 0x20, 0x4f, 0x4b, 0xd, 0xa, 0x53, 0x65, 0x72,
633 + 0x76, 0x65, 0x72, 0x3a, 0x20, 0x75, 0x49, 0x50, 0x2f, 0x30,
634 + 0x2e, 0x39, 0x20, 0x28, 0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f,
635 + 0x2f, 0x64, 0x75, 0x6e, 0x6b, 0x65, 0x6c, 0x73, 0x2e, 0x63,
636 + 0x6f, 0x6d, 0x2f, 0x61, 0x64, 0x61, 0x6d, 0x2f, 0x75, 0x69,
637 + 0x70, 0x2f, 0x29, 0xd, 0xa, 0x43, 0x6f, 0x6e, 0x74, 0x65,
638 + 0x6e, 0x74, 0x2d, 0x74, 0x79, 0x70, 0x65, 0x3a, 0x20, 0x74,
639 + 0x65, 0x78, 0x74, 0x2f, 0x68, 0x74, 0x6d, 0x6c, 0xd, 0xa,
640 + 0xd, 0xa, 0x3c, 0x68, 0x74, 0x6d, 0x6c, 0x3e, 0x3c, 0x62,
641 + 0x6f, 0x64, 0x79, 0x20, 0x73, 0x74, 0x79, 0x6c, 0x65, 0x3d,
642 + 0x22, 0x6d, 0x61, 0x72, 0x67, 0x69, 0x6e, 0x3a, 0x20, 0x30,
643 + 0x70, 0x74, 0x20, 0x61, 0x75, 0x74, 0x6f, 0x3b, 0x20, 0x68,
644 + 0x65, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x31, 0x30, 0x30, 0x25,
645 + 0x3b, 0x20, 0x63, 0x6f, 0x6c, 0x6f, 0x72, 0x3a, 0x20, 0x23,
646 + 0x66, 0x66, 0x66, 0x3b, 0x20, 0x62, 0x61, 0x63, 0x6b, 0x67,
647 + 0x72, 0x6f, 0x75, 0x6e, 0x64, 0x2d, 0x63, 0x6f, 0x6c, 0x6f,
648 + 0x72, 0x3a, 0x20, 0x23, 0x66, 0x62, 0x62, 0x30, 0x33, 0x34,
649 + 0x3b, 0x22, 0x3e, 0x3c, 0x63, 0x65, 0x6e, 0x74, 0x65, 0x72,
650 + 0x3e, 0x3c, 0x68, 0x31, 0x3e, 0x55, 0x70, 0x67, 0x72, 0x61,
651 + 0x64, 0x69, 0x6e, 0x67, 0x20, 0x73, 0x79, 0x73, 0x74, 0x65,
652 + 0x6d, 0x20, 0x2e, 0x2e, 0x2e, 0x2e, 0x3c, 0x2f, 0x68, 0x31,
653 + 0x3e, 0x3c, 0x2f, 0x63, 0x65, 0x6e, 0x74, 0x65, 0x72, 0x3e,
654 + 0x3c, 0x2f, 0x62, 0x6f, 0x64, 0x79, 0x3e, 0x3c, 0x2f, 0x68,
655 + 0x74, 0x6d, 0x6c, 0x3e, 0xa, };
656 +
657 +static const char data_fail_html[] = {
658 + /* /fail.html */
659 + 0x2f, 0x66, 0x61, 0x69, 0x6c, 0x2e, 0x68, 0x74, 0x6d, 0x6c, 0,
660 + 0x48, 0x54, 0x54, 0x50, 0x2f, 0x31, 0x2e, 0x30, 0x20, 0x32,
661 + 0x30, 0x30, 0x20, 0x4f, 0x4b, 0xd, 0xa, 0x53, 0x65, 0x72,
662 + 0x76, 0x65, 0x72, 0x3a, 0x20, 0x75, 0x49, 0x50, 0x2f, 0x30,
663 + 0x2e, 0x39, 0x20, 0x28, 0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f,
664 + 0x2f, 0x64, 0x75, 0x6e, 0x6b, 0x65, 0x6c, 0x73, 0x2e, 0x63,
665 + 0x6f, 0x6d, 0x2f, 0x61, 0x64, 0x61, 0x6d, 0x2f, 0x75, 0x69,
666 + 0x70, 0x2f, 0x29, 0xd, 0xa, 0x43, 0x6f, 0x6e, 0x74, 0x65,
667 + 0x6e, 0x74, 0x2d, 0x74, 0x79, 0x70, 0x65, 0x3a, 0x20, 0x74,
668 + 0x65, 0x78, 0x74, 0x2f, 0x68, 0x74, 0x6d, 0x6c, 0xd, 0xa,
669 + 0xd, 0xa, 0x3c, 0x68, 0x74, 0x6d, 0x6c, 0x3e, 0xa, 0x9,
670 + 0x3c, 0x68, 0x65, 0x61, 0x64, 0x3e, 0xa, 0x9, 0x9, 0x3c,
671 + 0x74, 0x69, 0x74, 0x6c, 0x65, 0x3e, 0xa, 0x9, 0x9, 0x9,
672 + 0x4c, 0x61, 0x46, 0x6f, 0x6e, 0x65, 0x72, 0x61, 0x20, 0x46,
673 + 0x61, 0x69, 0x6c, 0x73, 0x61, 0x66, 0x65, 0x20, 0x55, 0x49,
674 + 0xa, 0x9, 0x9, 0x3c, 0x2f, 0x74, 0x69, 0x74, 0x6c, 0x65,
675 + 0x3e, 0xa, 0x9, 0x3c, 0x62, 0x6f, 0x64, 0x79, 0x3e, 0xa,
676 + 0x9, 0x9, 0x3c, 0x68, 0x31, 0x3e, 0x46, 0x6c, 0x61, 0x73,
677 + 0x68, 0x69, 0x6e, 0x67, 0x20, 0x66, 0x61, 0x69, 0x6c, 0x65,
678 + 0x64, 0x3c, 0x2f, 0x68, 0x31, 0x3e, 0xa, 0x9, 0x9, 0x45,
679 + 0x52, 0x52, 0x4f, 0x52, 0x20, 0x2d, 0x20, 0x74, 0x68, 0x65,
680 + 0x20, 0x69, 0x6d, 0x61, 0x67, 0x65, 0x20, 0x79, 0x6f, 0x75,
681 + 0x20, 0x75, 0x70, 0x6c, 0x6f, 0x61, 0x64, 0x65, 0x64, 0x20,
682 + 0x66, 0x61, 0x69, 0x6c, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x20,
683 + 0x70, 0x61, 0x73, 0x73, 0x20, 0x76, 0x65, 0x72, 0x69, 0x66,
684 + 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x20, 0x50,
685 + 0x6c, 0x65, 0x61, 0x73, 0x65, 0x20, 0x6d, 0x61, 0x6b, 0x65,
686 + 0x20, 0x73, 0x75, 0x72, 0x65, 0x20, 0x74, 0x6f, 0x20, 0x75,
687 + 0x73, 0x65, 0x20, 0x61, 0x6e, 0x20, 0x6f, 0x66, 0x66, 0x69,
688 + 0x63, 0x69, 0x61, 0x6c, 0x20, 0x75, 0x70, 0x64, 0x61, 0x74,
689 + 0x65, 0x20, 0x70, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x64,
690 + 0x20, 0x62, 0x79, 0x20, 0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f,
691 + 0x2f, 0x64, 0x6f, 0x77, 0x6e, 0x6c, 0x6f, 0x61, 0x64, 0x2e,
692 + 0x66, 0x6f, 0x6e, 0x6f, 0x73, 0x66, 0x65, 0x72, 0x61, 0x2e,
693 + 0x6f, 0x72, 0x67, 0x2f, 0xa, 0x9, 0x3c, 0x2f, 0x62, 0x6f,
694 + 0x64, 0x79, 0x3e, 0xa, 0x3c, 0x2f, 0x68, 0x74, 0x6d, 0x6c,
695 + 0x3e, 0xa, };
696 +
697 +static const char data_404_html[] = {
698 + /* /404.html */
699 + 0x2f, 0x34, 0x30, 0x34, 0x2e, 0x68, 0x74, 0x6d, 0x6c, 0,
700 + 0x48, 0x54, 0x54, 0x50, 0x2f, 0x31, 0x2e, 0x30, 0x20, 0x34,
701 + 0x30, 0x34, 0x20, 0x46, 0x69, 0x6c, 0x65, 0x20, 0x6e, 0x6f,
702 + 0x74, 0x20, 0x66, 0x6f, 0x75, 0x6e, 0x64, 0xd, 0xa, 0x53,
703 + 0x65, 0x72, 0x76, 0x65, 0x72, 0x3a, 0x20, 0x75, 0x49, 0x50,
704 + 0x2f, 0x30, 0x2e, 0x39, 0x20, 0x28, 0x68, 0x74, 0x74, 0x70,
705 + 0x3a, 0x2f, 0x2f, 0x64, 0x75, 0x6e, 0x6b, 0x65, 0x6c, 0x73,
706 + 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x61, 0x64, 0x61, 0x6d, 0x2f,
707 + 0x75, 0x69, 0x70, 0x2f, 0x29, 0xd, 0xa, 0x43, 0x6f, 0x6e,
708 + 0x74, 0x65, 0x6e, 0x74, 0x2d, 0x74, 0x79, 0x70, 0x65, 0x3a,
709 + 0x20, 0x74, 0x65, 0x78, 0x74, 0x2f, 0x68, 0x74, 0x6d, 0x6c,
710 + 0xd, 0xa, 0xd, 0xa, 0x3c, 0x68, 0x74, 0x6d, 0x6c, 0x3e,
711 + 0x3c, 0x62, 0x6f, 0x64, 0x79, 0x20, 0x62, 0x67, 0x63, 0x6f,
712 + 0x6c, 0x6f, 0x72, 0x3d, 0x22, 0x77, 0x68, 0x69, 0x74, 0x65,
713 + 0x22, 0x3e, 0x3c, 0x63, 0x65, 0x6e, 0x74, 0x65, 0x72, 0x3e,
714 + 0x3c, 0x68, 0x31, 0x3e, 0x34, 0x30, 0x34, 0x20, 0x2d, 0x20,
715 + 0x66, 0x69, 0x6c, 0x65, 0x20, 0x6e, 0x6f, 0x74, 0x20, 0x66,
716 + 0x6f, 0x75, 0x6e, 0x64, 0x3c, 0x2f, 0x68, 0x31, 0x3e, 0x3c,
717 + 0x2f, 0x63, 0x65, 0x6e, 0x74, 0x65, 0x72, 0x3e, 0x3c, 0x2f,
718 + 0x62, 0x6f, 0x64, 0x79, 0x3e, 0x3c, 0x2f, 0x68, 0x74, 0x6d,
719 + 0x6c, 0x3e, };
720 +
721 +static const char data_index_html[] = {
722 + /* /index.html */
723 + 0x2f, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x2e, 0x68, 0x74, 0x6d, 0x6c, 0,
724 + 0x48, 0x54, 0x54, 0x50, 0x2f, 0x31, 0x2e, 0x30, 0x20, 0x32,
725 + 0x30, 0x30, 0x20, 0x4f, 0x4b, 0xd, 0xa, 0x53, 0x65, 0x72,
726 + 0x76, 0x65, 0x72, 0x3a, 0x20, 0x75, 0x49, 0x50, 0x2f, 0x30,
727 + 0x2e, 0x39, 0x20, 0x28, 0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f,
728 + 0x2f, 0x64, 0x75, 0x6e, 0x6b, 0x65, 0x6c, 0x73, 0x2e, 0x63,
729 + 0x6f, 0x6d, 0x2f, 0x61, 0x64, 0x61, 0x6d, 0x2f, 0x75, 0x69,
730 + 0x70, 0x2f, 0x29, 0xd, 0xa, 0x43, 0x6f, 0x6e, 0x74, 0x65,
731 + 0x6e, 0x74, 0x2d, 0x74, 0x79, 0x70, 0x65, 0x3a, 0x20, 0x74,
732 + 0x65, 0x78, 0x74, 0x2f, 0x68, 0x74, 0x6d, 0x6c, 0xd, 0xa,
733 + 0xd, 0xa, 0x3c, 0x68, 0x74, 0x6d, 0x6c, 0x3e, 0xa, 0x9,
734 + 0x3c, 0x68, 0x65, 0x61, 0x64, 0x3e, 0xa, 0x9, 0x9, 0x3c,
735 + 0x74, 0x69, 0x74, 0x6c, 0x65, 0x3e, 0xa, 0x9, 0x9, 0x9,
736 + 0x4c, 0x61, 0x46, 0x6f, 0x6e, 0x65, 0x72, 0x61, 0x20, 0x46,
737 + 0x61, 0x69, 0x6c, 0x73, 0x61, 0x66, 0x65, 0x20, 0x55, 0x49,
738 + 0xa, 0x9, 0x9, 0x3c, 0x2f, 0x74, 0x69, 0x74, 0x6c, 0x65,
739 + 0x3e, 0xa, 0x9, 0x3c, 0x2f, 0x68, 0x65, 0x61, 0x64, 0x3e,
740 + 0xa, 0x9, 0x3c, 0x62, 0x6f, 0x64, 0x79, 0x20, 0x73, 0x74,
741 + 0x79, 0x6c, 0x65, 0x3d, 0x22, 0x6d, 0x61, 0x72, 0x67, 0x69,
742 + 0x6e, 0x3a, 0x20, 0x30, 0x70, 0x74, 0x20, 0x61, 0x75, 0x74,
743 + 0x6f, 0x3b, 0x20, 0x68, 0x65, 0x69, 0x67, 0x68, 0x74, 0x3a,
744 + 0x31, 0x30, 0x30, 0x25, 0x3b, 0x20, 0x63, 0x6f, 0x6c, 0x6f,
745 + 0x72, 0x3a, 0x20, 0x23, 0x30, 0x30, 0x30, 0x3b, 0x20, 0x62,
746 + 0x61, 0x63, 0x6b, 0x67, 0x72, 0x6f, 0x75, 0x6e, 0x64, 0x2d,
747 + 0x63, 0x6f, 0x6c, 0x6f, 0x72, 0x3a, 0x20, 0x23, 0x66, 0x62,
748 + 0x62, 0x30, 0x33, 0x34, 0x3b, 0x22, 0x3e, 0xa, 0x9, 0x9,
749 + 0x3c, 0x68, 0x31, 0x3e, 0x4c, 0x61, 0x46, 0x6f, 0x6e, 0x65,
750 + 0x72, 0x61, 0x20, 0x46, 0x61, 0x69, 0x6c, 0x73, 0x61, 0x66,
751 + 0x65, 0x20, 0x55, 0x49, 0x3c, 0x2f, 0x68, 0x31, 0x3e, 0xa,
752 + 0x9, 0x9, 0x3c, 0x66, 0x6f, 0x72, 0x6d, 0x20, 0x6d, 0x65,
753 + 0x74, 0x68, 0x6f, 0x64, 0x3d, 0x22, 0x70, 0x6f, 0x73, 0x74,
754 + 0x22, 0x20, 0x65, 0x6e, 0x63, 0x74, 0x79, 0x70, 0x65, 0x3d,
755 + 0x22, 0x6d, 0x75, 0x6c, 0x74, 0x69, 0x70, 0x61, 0x72, 0x74,
756 + 0x2f, 0x66, 0x6f, 0x72, 0x6d, 0x2d, 0x64, 0x61, 0x74, 0x61,
757 + 0x22, 0x3e, 0xa, 0x9, 0x9, 0x9, 0x3c, 0x69, 0x6e, 0x70,
758 + 0x75, 0x74, 0x20, 0x74, 0x79, 0x70, 0x65, 0x3d, 0x66, 0x69,
759 + 0x6c, 0x65, 0x20, 0x6e, 0x61, 0x6d, 0x65, 0x3d, 0x66, 0x69,
760 + 0x72, 0x6d, 0x77, 0x61, 0x72, 0x65, 0x3e, 0xa, 0x9, 0x9,
761 + 0x9, 0x3c, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x20, 0x74, 0x79,
762 + 0x70, 0x65, 0x3d, 0x73, 0x75, 0x62, 0x6d, 0x69, 0x74, 0x3e,
763 + 0xa, 0x9, 0x9, 0x3c, 0x2f, 0x66, 0x6f, 0x72, 0x6d, 0x3e,
764 + 0xa, 0x9, 0x3c, 0x2f, 0x62, 0x6f, 0x64, 0x79, 0x3e, 0xa,
765 + 0x3c, 0x2f, 0x68, 0x74, 0x6d, 0x6c, 0x3e, 0xa, };
766 +
767 +static const char data_flash_html[] = {
768 + /* /flash.html */
769 + 0x2f, 0x66, 0x6c, 0x61, 0x73, 0x68, 0x2e, 0x68, 0x74, 0x6d, 0x6c, 0,
770 + 0x48, 0x54, 0x54, 0x50, 0x2f, 0x31, 0x2e, 0x30, 0x20, 0x32,
771 + 0x30, 0x30, 0x20, 0x4f, 0x4b, 0xd, 0xa, 0x53, 0x65, 0x72,
772 + 0x76, 0x65, 0x72, 0x3a, 0x20, 0x75, 0x49, 0x50, 0x2f, 0x30,
773 + 0x2e, 0x39, 0x20, 0x28, 0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f,
774 + 0x2f, 0x64, 0x75, 0x6e, 0x6b, 0x65, 0x6c, 0x73, 0x2e, 0x63,
775 + 0x6f, 0x6d, 0x2f, 0x61, 0x64, 0x61, 0x6d, 0x2f, 0x75, 0x69,
776 + 0x70, 0x2f, 0x29, 0xd, 0xa, 0x43, 0x6f, 0x6e, 0x74, 0x65,
777 + 0x6e, 0x74, 0x2d, 0x74, 0x79, 0x70, 0x65, 0x3a, 0x20, 0x74,
778 + 0x65, 0x78, 0x74, 0x2f, 0x68, 0x74, 0x6d, 0x6c, 0xd, 0xa,
779 + 0xd, 0xa, 0x3c, 0x68, 0x74, 0x6d, 0x6c, 0x3e, 0xa, 0x9,
780 + 0x3c, 0x68, 0x65, 0x61, 0x64, 0x3e, 0xa, 0x9, 0x9, 0x3c,
781 + 0x74, 0x69, 0x74, 0x6c, 0x65, 0x3e, 0xa, 0x9, 0x9, 0x9,
782 + 0x4c, 0x61, 0x46, 0x6f, 0x6e, 0x65, 0x72, 0x61, 0x20, 0x46,
783 + 0x61, 0x69, 0x6c, 0x73, 0x61, 0x66, 0x65, 0x20, 0x55, 0x49,
784 + 0xa, 0x9, 0x9, 0x3c, 0x2f, 0x74, 0x69, 0x74, 0x6c, 0x65,
785 + 0x3e, 0xa, 0x9, 0x3c, 0x2f, 0x68, 0x65, 0x61, 0x64, 0x3e,
786 + 0xa, 0x9, 0x3c, 0x62, 0x6f, 0x64, 0x79, 0x20, 0x73, 0x74,
787 + 0x79, 0x6c, 0x65, 0x3d, 0x22, 0x6d, 0x61, 0x72, 0x67, 0x69,
788 + 0x6e, 0x3a, 0x20, 0x30, 0x70, 0x74, 0x20, 0x61, 0x75, 0x74,
789 + 0x6f, 0x3b, 0x20, 0x68, 0x65, 0x69, 0x67, 0x68, 0x74, 0x3a,
790 + 0x31, 0x30, 0x30, 0x25, 0x3b, 0x20, 0x63, 0x6f, 0x6c, 0x6f,
791 + 0x72, 0x3a, 0x20, 0x23, 0x30, 0x30, 0x30, 0x3b, 0x20, 0x62,
792 + 0x61, 0x63, 0x6b, 0x67, 0x72, 0x6f, 0x75, 0x6e, 0x64, 0x2d,
793 + 0x63, 0x6f, 0x6c, 0x6f, 0x72, 0x3a, 0x20, 0x23, 0x66, 0x62,
794 + 0x62, 0x30, 0x33, 0x34, 0x3b, 0x22, 0x3e, 0xa, 0x9, 0x9,
795 + 0x3c, 0x68, 0x31, 0x3e, 0x46, 0x6c, 0x61, 0x73, 0x68, 0x69,
796 + 0x6e, 0x67, 0x3c, 0x2f, 0x68, 0x31, 0x3e, 0xa, 0x9, 0x9,
797 + 0x54, 0x68, 0x65, 0x20, 0x73, 0x79, 0x73, 0x74, 0x65, 0x6d,
798 + 0x20, 0x69, 0x73, 0x20, 0x6e, 0x6f, 0x77, 0x20, 0x74, 0x72,
799 + 0x79, 0x69, 0x6e, 0x67, 0x20, 0x74, 0x6f, 0x20, 0x66, 0x6c,
800 + 0x61, 0x73, 0x68, 0x2e, 0x20, 0x49, 0x66, 0x20, 0x74, 0x68,
801 + 0x65, 0x72, 0x65, 0x20, 0x69, 0x73, 0x20, 0x61, 0x20, 0x70,
802 + 0x72, 0x6f, 0x62, 0x6c, 0x65, 0x6d, 0x2c, 0x20, 0x74, 0x68,
803 + 0x65, 0x20, 0x6c, 0x65, 0x64, 0x73, 0x20, 0x77, 0x69, 0x6c,
804 + 0x6c, 0x20, 0x73, 0x74, 0x61, 0x72, 0x74, 0x20, 0x74, 0x6f,
805 + 0x20, 0x62, 0x6c, 0x69, 0x6e, 0x6b, 0x2e, 0xa, 0xa, 0x9,
806 + 0x9, 0x41, 0x66, 0x74, 0x65, 0x72, 0x20, 0x61, 0x20, 0x73,
807 + 0x75, 0x63, 0x63, 0x65, 0x73, 0x73, 0x66, 0x75, 0x6c, 0x6c,
808 + 0x20, 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, 0x20, 0x74, 0x68,
809 + 0x65, 0x20, 0x62, 0x6f, 0x78, 0x20, 0x77, 0x69, 0x6c, 0x6c,
810 + 0x20, 0x72, 0x65, 0x62, 0x6f, 0x6f, 0x74, 0xa, 0x9, 0x3c,
811 + 0x2f, 0x62, 0x6f, 0x64, 0x79, 0x3e, 0xa, 0x3c, 0x2f, 0x68,
812 + 0x74, 0x6d, 0x6c, 0x3e, 0xa, };
813 +
814 +const struct fsdata_file file_flashing_html[] = {{NULL, data_flashing_html, data_flashing_html + 15, sizeof(data_flashing_html) - 15}};
815 +
816 +const struct fsdata_file file_fail_html[] = {{file_flashing_html, data_fail_html, data_fail_html + 11, sizeof(data_fail_html) - 11}};
817 +
818 +const struct fsdata_file file_404_html[] = {{file_fail_html, data_404_html, data_404_html + 10, sizeof(data_404_html) - 10}};
819 +
820 +const struct fsdata_file file_index_html[] = {{file_404_html, data_index_html, data_index_html + 12, sizeof(data_index_html) - 12}};
821 +
822 +const struct fsdata_file file_flash_html[] = {{file_index_html, data_flash_html, data_flash_html + 12, sizeof(data_flash_html) - 12}};
823 +
824 +#define FS_ROOT file_flash_html
825 +
826 +#define FS_NUMFILES 5
827 \ No newline at end of file
828 --- /dev/null
829 +++ b/net/uip-0.9/fsdata.h
830 @@ -0,0 +1,64 @@
831 +/*
832 + * Copyright (c) 2001, Swedish Institute of Computer Science.
833 + * All rights reserved.
834 + *
835 + * Redistribution and use in source and binary forms, with or without
836 + * modification, are permitted provided that the following conditions
837 + * are met:
838 + * 1. Redistributions of source code must retain the above copyright
839 + * notice, this list of conditions and the following disclaimer.
840 + * 2. Redistributions in binary form must reproduce the above copyright
841 + * notice, this list of conditions and the following disclaimer in the
842 + * documentation and/or other materials provided with the distribution.
843 + * 3. Neither the name of the Institute nor the names of its contributors
844 + * may be used to endorse or promote products derived from this software
845 + * without specific prior written permission.
846 + *
847 + * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
848 + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
849 + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
850 + * ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
851 + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
852 + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
853 + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
854 + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
855 + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
856 + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
857 + * SUCH DAMAGE.
858 + *
859 + * This file is part of the lwIP TCP/IP stack.
860 + *
861 + * Author: Adam Dunkels <adam@sics.se>
862 + *
863 + * $Id: fsdata.h,v 1.4.2.1 2003/10/04 22:54:06 adam Exp $
864 + */
865 +#ifndef __FSDATA_H__
866 +#define __FSDATA_H__
867 +
868 +#include "uipopt.h"
869 +
870 +struct fsdata_file {
871 + const struct fsdata_file *next;
872 + const char *name;
873 + const char *data;
874 + const int len;
875 +#ifdef FS_STATISTICS
876 +#if FS_STATISTICS == 1
877 + u16_t count;
878 +#endif /* FS_STATISTICS */
879 +#endif /* FS_STATISTICS */
880 +};
881 +
882 +struct fsdata_file_noconst {
883 + struct fsdata_file *next;
884 + char *name;
885 + char *data;
886 + int len;
887 +#ifdef FS_STATISTICS
888 +#if FS_STATISTICS == 1
889 + u16_t count;
890 +#endif /* FS_STATISTICS */
891 +#endif /* FS_STATISTICS */
892 +};
893 +
894 +#endif /* __FSDATA_H__ */
895 --- /dev/null
896 +++ b/net/uip-0.9/httpd.c
897 @@ -0,0 +1,278 @@
898 +#include "uip.h"
899 +#include "httpd.h"
900 +#include "fs.h"
901 +#include "fsdata.h"
902 +#include <asm/addrspace.h>
903 +
904 +#define HTTP_NONE 0
905 +#define HTTP_FILE 1
906 +#define HTTP_FIRMWARE 2
907 +
908 +#define PRINT(x) printf("%s", x)
909 +#define PRINTLN(x) printf("%s\n", x)
910 +
911 +extern unsigned long do_http_tmp_address(void);
912 +
913 +struct httpd_state *hs;
914 +
915 +extern const struct fsdata_file file_index_html;
916 +extern const struct fsdata_file file_404_html;
917 +extern const struct fsdata_file file_flash_html;
918 +extern int httpd_upload_complete;
919 +extern unsigned char *httpd_upload_data;
920 +unsigned char *upload_data;
921 +extern ulong NetBootFileXferSize;
922 +int upload_running = 0;
923 +
924 +#define ISO_G 0x47
925 +#define ISO_E 0x45
926 +#define ISO_T 0x54
927 +#define ISO_P 0x50
928 +#define ISO_O 0x4f
929 +#define ISO_S 0x53
930 +#define ISO_T 0x54
931 +#define ISO_slash 0x2f
932 +#define ISO_c 0x63
933 +#define ISO_g 0x67
934 +#define ISO_i 0x69
935 +#define ISO_space 0x20
936 +#define ISO_nl 0x0a
937 +#define ISO_cr 0x0d
938 +#define ISO_a 0x61
939 +#define ISO_t 0x74
940 +#define ISO_hash 0x23
941 +#define ISO_period 0x2e
942 +
943 +static char eol[3] = { 0x0d, 0x0a, 0x00 };
944 +static char eol2[5] = { 0x0d, 0x0a, 0x0d, 0x0a, 0x00 };
945 +static char boundary[128];
946 +static int boundary_len = 0;
947 +
948 +/* we use this so that we can do without the ctype library */
949 +#define is_digit(c) ((c) >= '0' && (c) <= '9')
950 +static int atoi(const char *s)
951 +{
952 + int i=0;
953 +
954 + while (is_digit(*s))
955 + i = i*10 + *(s++) - '0';
956 + return i;
957 +}
958 +
959 +void
960 +httpd_init(void)
961 +{
962 + fs_init();
963 + uip_listen(HTONS(80));
964 +}
965 +
966 +void
967 +httpd_appcall(void)
968 +{
969 + struct fs_file fsfile;
970 + u8_t i;
971 + switch(uip_conn->lport) {
972 + case HTONS(80):
973 + hs = (struct httpd_state *)(uip_conn->appstate);
974 + if(uip_connected())
975 + {
976 + hs->state = HTTP_NONE;
977 + hs->count = 0;
978 + return;
979 + } else if(uip_poll())
980 + {
981 + if(hs->count++ >= 1000) {
982 + uip_abort();
983 + }
984 + return;
985 + } else if(uip_newdata() && hs->state == HTTP_NONE)
986 + {
987 + if(uip_appdata[0] == ISO_G &&
988 + uip_appdata[1] == ISO_E &&
989 + uip_appdata[2] == ISO_T &&
990 + uip_appdata[3] == ISO_space)
991 + {
992 + hs->state = HTTP_FILE;
993 + }
994 + if(uip_appdata[0] == ISO_P &&
995 + uip_appdata[1] == ISO_O &&
996 + uip_appdata[2] == ISO_S &&
997 + uip_appdata[3] == ISO_T &&
998 + uip_appdata[4] == ISO_space)
999 + {
1000 + hs->state = HTTP_FIRMWARE;
1001 + }
1002 + if(hs->state == HTTP_NONE)
1003 + {
1004 + uip_abort();
1005 + return;
1006 + }
1007 + if(hs->state == HTTP_FILE)
1008 + {
1009 + for(i = 4; i < 40; ++i)
1010 + {
1011 + if(uip_appdata[i] == ISO_space ||
1012 + uip_appdata[i] == ISO_cr ||
1013 + uip_appdata[i] == ISO_nl)
1014 + {
1015 + uip_appdata[i] = 0;
1016 + break;
1017 + }
1018 + }
1019 +
1020 + PRINT("request for file ");
1021 + PRINTLN(&uip_appdata[4]);
1022 + if(uip_appdata[4] == ISO_slash &&
1023 + uip_appdata[5] == 0)
1024 + {
1025 + fs_open(file_index_html.name, &fsfile);
1026 + } else {
1027 + if(!fs_open((const char *)&uip_appdata[4], &fsfile))
1028 + {
1029 + PRINTLN("couldn't open file");
1030 + fs_open(file_index_html.name, &fsfile);
1031 + }
1032 + }
1033 + hs->script = 0;
1034 + hs->state = HTTP_FILE;
1035 + hs->dataptr = fsfile.data;
1036 + hs->count = fsfile.len;
1037 + }
1038 + if(hs->state == HTTP_FIRMWARE)
1039 + {
1040 + unsigned char *start = (unsigned char*)uip_appdata;
1041 + char *clen = strstr(start, "Content-Length:");
1042 + int len = 0;
1043 + unsigned char *next, *end;
1044 + unsigned char *boundary_start;
1045 + int i;
1046 + uip_appdata[uip_len] = '\0';
1047 + if(clen)
1048 + {
1049 + clen += sizeof("Content-Length:");
1050 + next = strstr(clen, eol);
1051 + if(next)
1052 + {
1053 + len = atoi(clen);
1054 + next++;
1055 + printf("expecting %d bytes\n", len);
1056 + upload_data = httpd_upload_data = (unsigned char *)do_http_tmp_address();
1057 + printf("received data will be stored at 0x%08X\n", upload_data);
1058 + if(!upload_data)
1059 + {
1060 + printf("failed to allocate memory\n");
1061 + uip_close();
1062 + return;
1063 + }
1064 + } else {
1065 + uip_close();
1066 + return;
1067 + }
1068 + }
1069 + if(len < 4 * 1024)
1070 + {
1071 + uip_close();
1072 + return;
1073 + }
1074 + boundary_start = strstr(next, "---");
1075 + if(!boundary_start)
1076 + {
1077 + uip_close();
1078 + return;
1079 + }
1080 + end = strstr(boundary_start, eol);
1081 + if(!eol)
1082 + {
1083 + uip_close();
1084 + return;
1085 + }
1086 + boundary_len = end - boundary_start;
1087 + memcpy(boundary, boundary_start, boundary_len);
1088 + boundary[boundary_len] = 0;
1089 + next = strstr(boundary_start, "name=\"firmware\";");
1090 + if(!next)
1091 + {
1092 + uip_close();
1093 + return;
1094 + }
1095 + next = strstr(next, eol2);
1096 + if(!next)
1097 + {
1098 + printf("could not find start of data\n");
1099 + uip_close();
1100 + return;
1101 + }
1102 + next += 4;
1103 + hs->script = 0;
1104 + hs->state = HTTP_FIRMWARE;
1105 + hs->upload = uip_len - (next - start);
1106 + hs->upload_total = len - (int)(next - boundary_start);
1107 + hs->upload_total -= (strlen(boundary) + 6);
1108 + //printf("storing %d bytes at %p\n", (int)hs->upload, upload_data);
1109 + for(i = 0; i < hs->upload; i++)
1110 + upload_data[i] = next[i];
1111 + upload_data += (int)hs->upload;
1112 + printf("%d / %d\n", (int)hs->upload, hs->upload_total);
1113 + uip_slen = 0;
1114 + return;
1115 + }
1116 + }
1117 +
1118 + if(hs->state == HTTP_FIRMWARE)
1119 + {
1120 + if(uip_newdata())
1121 + {
1122 + int i;
1123 + hs->count = 0;
1124 + uip_appdata[uip_len] = '\0';
1125 + hs->upload += uip_len;
1126 + //printf("storing %d bytes at %p\n", uip_len, upload_data);
1127 + printf("%d / %d\n", (int)hs->upload, hs->upload_total);
1128 + for(i = 0; i < uip_len; i++)
1129 + upload_data[i] = uip_appdata[i];
1130 + upload_data += uip_len;
1131 + uip_slen = 0;
1132 + if(hs->upload >= hs->upload_total)
1133 + {
1134 + upload_running = 1;
1135 + NetBootFileXferSize = hs->upload_total;
1136 + fs_open(file_flash_html.name, &fsfile);
1137 + hs->script = 0;
1138 + hs->state = HTTP_FILE;
1139 + hs->dataptr = fsfile.data;
1140 + hs->count = fsfile.len;
1141 + }
1142 + }
1143 + }
1144 + if(hs->state == HTTP_FILE)
1145 + {
1146 + if(uip_acked())
1147 + {
1148 + if(hs->count >= uip_conn->len)
1149 + {
1150 + hs->count -= uip_conn->len;
1151 + hs->dataptr += uip_conn->len;
1152 + } else {
1153 + hs->count = 0;
1154 + }
1155 + if(hs->count == 0)
1156 + {
1157 + if(upload_running)
1158 + {
1159 + int i;
1160 + httpd_upload_complete = 1;
1161 + // for(i = 0; i < hs->upload_total; i++)
1162 + // printf("%c", httpd_upload_data[i]);
1163 + }
1164 + uip_close();
1165 + }
1166 + }
1167 + uip_send(hs->dataptr, hs->count);
1168 + }
1169 + break;
1170 +
1171 + default:
1172 + uip_abort();
1173 + break;
1174 + }
1175 +}
1176 --- /dev/null
1177 +++ b/net/uip-0.9/httpd.h
1178 @@ -0,0 +1,83 @@
1179 +/**
1180 + * \addtogroup httpd
1181 + * @{
1182 + */
1183 +
1184 +/**
1185 + * \file
1186 + * HTTP server header file.
1187 + * \author Adam Dunkels <adam@dunkels.com>
1188 + */
1189 +
1190 +/*
1191 + * Copyright (c) 2001, Adam Dunkels.
1192 + * All rights reserved.
1193 + *
1194 + * Redistribution and use in source and binary forms, with or without
1195 + * modification, are permitted provided that the following conditions
1196 + * are met:
1197 + * 1. Redistributions of source code must retain the above copyright
1198 + * notice, this list of conditions and the following disclaimer.
1199 + * 2. Redistributions in binary form must reproduce the above copyright
1200 + * notice, this list of conditions and the following disclaimer in the
1201 + * documentation and/or other materials provided with the distribution.
1202 + * 3. The name of the author may not be used to endorse or promote
1203 + * products derived from this software without specific prior
1204 + * written permission.
1205 + *
1206 + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS
1207 + * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
1208 + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
1209 + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
1210 + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
1211 + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
1212 + * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
1213 + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
1214 + * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
1215 + * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
1216 + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
1217 + *
1218 + * This file is part of the uIP TCP/IP stack.
1219 + *
1220 + * $Id: httpd.h,v 1.4.2.3 2003/10/06 22:56:44 adam Exp $
1221 + *
1222 + */
1223 +
1224 +#ifndef __HTTPD_H__
1225 +#define __HTTPD_H__
1226 +
1227 +void httpd_init(void);
1228 +void httpd_appcall(void);
1229 +
1230 +/* UIP_APPCALL: the name of the application function. This function
1231 + must return void and take no arguments (i.e., C type "void
1232 + appfunc(void)"). */
1233 +#ifndef UIP_APPCALL
1234 +#define UIP_APPCALL httpd_appcall
1235 +#endif
1236 +
1237 +struct httpd_state {
1238 + u8_t state;
1239 + u16_t count;
1240 + char *dataptr;
1241 + char *script;
1242 + unsigned int upload;
1243 + unsigned int upload_total;
1244 +};
1245 +
1246 +
1247 +/* UIP_APPSTATE_SIZE: The size of the application-specific state
1248 + stored in the uip_conn structure. */
1249 +#ifndef UIP_APPSTATE_SIZE
1250 +#define UIP_APPSTATE_SIZE (sizeof(struct httpd_state))
1251 +#endif
1252 +
1253 +#define FS_STATISTICS 1
1254 +
1255 +extern struct httpd_state *hs;
1256 +
1257 +
1258 +/* we copy the data to RAM+10MB */
1259 +#define TMP_DATA 0x8A100000
1260 +
1261 +#endif /* __HTTPD_H__ */
1262 --- /dev/null
1263 +++ b/net/uip-0.9/main.c
1264 @@ -0,0 +1,88 @@
1265 +/*
1266 + * Copyright (c) 2001-2003, Adam Dunkels.
1267 + * All rights reserved.
1268 + *
1269 + * Redistribution and use in source and binary forms, with or without
1270 + * modification, are permitted provided that the following conditions
1271 + * are met:
1272 + * 1. Redistributions of source code must retain the above copyright
1273 + * notice, this list of conditions and the following disclaimer.
1274 + * 2. Redistributions in binary form must reproduce the above copyright
1275 + * notice, this list of conditions and the following disclaimer in the
1276 + * documentation and/or other materials provided with the distribution.
1277 + * 3. The name of the author may not be used to endorse or promote
1278 + * products derived from this software without specific prior
1279 + * written permission.
1280 + *
1281 + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS
1282 + * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
1283 + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
1284 + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
1285 + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
1286 + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
1287 + * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
1288 + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
1289 + * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
1290 + * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
1291 + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
1292 + *
1293 + * This file is part of the uIP TCP/IP stack.
1294 + *
1295 + * $Id: main.c,v 1.10.2.1 2003/10/04 22:54:17 adam Exp $
1296 + *
1297 + */
1298 +
1299 +
1300 +#include "uip.h"
1301 +#include "uip_arp.h"
1302 +#include "tapdev.h"
1303 +#include "httpd.h"
1304 +
1305 +#define BUF ((struct uip_eth_hdr *)&uip_buf[0])
1306 +
1307 +#ifndef NULL
1308 +#define NULL (void *)0
1309 +#endif /* NULL */
1310 +
1311 +/*-----------------------------------------------------------------------------------*/
1312 +int
1313 +main(void)
1314 +{
1315 + u8_t i, arptimer;
1316 + tapdev_init();
1317 + uip_init();
1318 + httpd_init();
1319 + arptimer = 0;
1320 + while(1) {
1321 + uip_len = tapdev_read();
1322 + if(uip_len == 0) {
1323 + for(i = 0; i < UIP_CONNS; i++) {
1324 + uip_periodic(i);
1325 + if(uip_len > 0) {
1326 + uip_arp_out();
1327 + tapdev_send();
1328 + }
1329 + }
1330 +
1331 + if(++arptimer == 20) {
1332 + uip_arp_timer();
1333 + arptimer = 0;
1334 + }
1335 + } else {
1336 + if(BUF->type == htons(UIP_ETHTYPE_IP)) {
1337 + uip_arp_ipin();
1338 + uip_input();
1339 + if(uip_len > 0) {
1340 + uip_arp_out();
1341 + tapdev_send();
1342 + }
1343 + } else if(BUF->type == htons(UIP_ETHTYPE_ARP)) {
1344 + uip_arp_arpin();
1345 + if(uip_len > 0) {
1346 + tapdev_send();
1347 + }
1348 + }
1349 + }
1350 + }
1351 + return 0;
1352 +}
1353 --- /dev/null
1354 +++ b/net/uip-0.9/tapdev.c
1355 @@ -0,0 +1,192 @@
1356 +/*
1357 + * Copyright (c) 2001, Swedish Institute of Computer Science.
1358 + * All rights reserved.
1359 + *
1360 + * Redistribution and use in source and binary forms, with or without
1361 + * modification, are permitted provided that the following conditions
1362 + * are met:
1363 + *
1364 + * 1. Redistributions of source code must retain the above copyright
1365 + * notice, this list of conditions and the following disclaimer.
1366 + *
1367 + * 2. Redistributions in binary form must reproduce the above copyright
1368 + * notice, this list of conditions and the following disclaimer in the
1369 + * documentation and/or other materials provided with the distribution.
1370 + *
1371 + * 3. Neither the name of the Institute nor the names of its contributors
1372 + * may be used to endorse or promote products derived from this software
1373 + * without specific prior written permission.
1374 + *
1375 + * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
1376 + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
1377 + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
1378 + * ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
1379 + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
1380 + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
1381 + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
1382 + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
1383 + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
1384 + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
1385 + * SUCH DAMAGE.
1386 + *
1387 + * Author: Adam Dunkels <adam@sics.se>
1388 + *
1389 + * $Id: tapdev.c,v 1.7.2.1 2003/10/07 13:23:19 adam Exp $
1390 + */
1391 +
1392 +
1393 +#include <fcntl.h>
1394 +#include <stdlib.h>
1395 +#include <stdio.h>
1396 +#include <unistd.h>
1397 +#include <string.h>
1398 +#include <sys/ioctl.h>
1399 +#include <sys/socket.h>
1400 +#include <sys/types.h>
1401 +#include <sys/time.h>
1402 +#include <sys/uio.h>
1403 +#include <sys/socket.h>
1404 +
1405 +#ifdef linux
1406 +#include <sys/ioctl.h>
1407 +#include <linux/if.h>
1408 +#include <linux/if_tun.h>
1409 +#define DEVTAP "/dev/net/tun"
1410 +#else /* linux */
1411 +#define DEVTAP "/dev/tap0"
1412 +#endif /* linux */
1413 +
1414 +#include "uip.h"
1415 +
1416 +static int fd;
1417 +
1418 +static unsigned long lasttime;
1419 +static struct timezone tz;
1420 +
1421 +/*-----------------------------------------------------------------------------------*/
1422 +void
1423 +tapdev_init(void)
1424 +{
1425 + char buf[1024];
1426 +
1427 + fd = open(DEVTAP, O_RDWR);
1428 + if(fd == -1) {
1429 + perror("tapdev: tapdev_init: open");
1430 + exit(1);
1431 + }
1432 +
1433 +#ifdef linux
1434 + {
1435 + struct ifreq ifr;
1436 + memset(&ifr, 0, sizeof(ifr));
1437 + ifr.ifr_flags = IFF_TAP|IFF_NO_PI;
1438 + if (ioctl(fd, TUNSETIFF, (void *) &ifr) < 0) {
1439 + perror(buf);
1440 + exit(1);
1441 + }
1442 + }
1443 +#endif /* Linux */
1444 +
1445 + snprintf(buf, sizeof(buf), "ifconfig tap0 inet %d.%d.%d.%d",
1446 + UIP_DRIPADDR0, UIP_DRIPADDR1, UIP_DRIPADDR2, UIP_DRIPADDR3);
1447 + system(buf);
1448 +
1449 + lasttime = 0;
1450 +}
1451 +
1452 +void dump_mem(int type, int len)
1453 +{
1454 +#if DUMP == 1
1455 + int i;
1456 + for(i = 0; i < len; i++)
1457 + printf("%c", uip_buf[i]);
1458 + if(type)
1459 + {
1460 + printf("\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01");
1461 + printf("\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01\01");
1462 + } else {
1463 + printf("\02\02\02\02\02\02\02\02\02\02\02\02\02\02\02\02\02\02\02\02\02\02\02\02\02\02\02\02\02\02\02\02");
1464 + printf("\02\02\02\02\02\02\02\02\02\02\02\02\02\02\02\02\02\02\02\02\02\02\02\02\02\02\02\02\02\02\02\02");
1465 + }
1466 + fflush(stdout);
1467 +#endif
1468 +}
1469 +
1470 +/*-----------------------------------------------------------------------------------*/
1471 +unsigned int
1472 +tapdev_read(void)
1473 +{
1474 + fd_set fdset;
1475 + struct timeval tv, now;
1476 + int ret;
1477 +
1478 + if(lasttime >= 500000) {
1479 + lasttime = 0;
1480 + return 0;
1481 + }
1482 +
1483 + tv.tv_sec = 0;
1484 + tv.tv_usec = 500000 - lasttime;
1485 +
1486 +
1487 + FD_ZERO(&fdset);
1488 + FD_SET(fd, &fdset);
1489 +
1490 + gettimeofday(&now, &tz);
1491 + ret = select(fd + 1, &fdset, NULL, NULL, &tv);
1492 + if(ret == 0) {
1493 + lasttime = 0;
1494 + return 0;
1495 + }
1496 + ret = read(fd, uip_buf, UIP_BUFSIZE);
1497 + if(ret == -1) {
1498 + perror("tap_dev: tapdev_read: read");
1499 + }
1500 + gettimeofday(&tv, &tz);
1501 + lasttime += (tv.tv_sec - now.tv_sec) * 1000000 + (tv.tv_usec - now.tv_usec);
1502 + dump_mem(0, ret);
1503 + return ret;
1504 +}
1505 +/*-----------------------------------------------------------------------------------*/
1506 +void
1507 +tapdev_send(void)
1508 +{
1509 + int ret;
1510 + struct iovec iov[2];
1511 +
1512 +#ifdef linux
1513 + {
1514 + char tmpbuf[UIP_BUFSIZE];
1515 + int i;
1516 +
1517 + for(i = 0; i < 40 + UIP_LLH_LEN; i++) {
1518 + tmpbuf[i] = uip_buf[i];
1519 + }
1520 +
1521 + for(; i < uip_len; i++) {
1522 + tmpbuf[i] = uip_appdata[i - 40 - UIP_LLH_LEN];
1523 + }
1524 +
1525 + ret = write(fd, tmpbuf, uip_len);
1526 + }
1527 +#else
1528 +
1529 + if(uip_len < 40 + UIP_LLH_LEN) {
1530 + ret = write(fd, uip_buf, uip_len + UIP_LLH_LEN);
1531 + } else {
1532 + iov[0].iov_base = uip_buf;
1533 + iov[0].iov_len = 40 + UIP_LLH_LEN;
1534 + iov[1].iov_base = (char *)uip_appdata;
1535 + iov[1].iov_len = uip_len - (40 + UIP_LLH_LEN);
1536 +
1537 + ret = writev(fd, iov, 2);
1538 + }
1539 +#endif
1540 + dump_mem(1, ret);
1541 +
1542 + if(ret == -1) {
1543 + perror("tap_dev: tapdev_send: writev");
1544 + exit(1);
1545 + }
1546 +}
1547 +/*-----------------------------------------------------------------------------------*/
1548 --- /dev/null
1549 +++ b/net/uip-0.9/tapdev.h
1550 @@ -0,0 +1,42 @@
1551 +/*
1552 + * Copyright (c) 2001, Adam Dunkels.
1553 + * All rights reserved.
1554 + *
1555 + * Redistribution and use in source and binary forms, with or without
1556 + * modification, are permitted provided that the following conditions
1557 + * are met:
1558 + * 1. Redistributions of source code must retain the above copyright
1559 + * notice, this list of conditions and the following disclaimer.
1560 + * 2. Redistributions in binary form must reproduce the above copyright
1561 + * notice, this list of conditions and the following disclaimer in the
1562 + * documentation and/or other materials provided with the distribution.
1563 + * 3. The name of the author may not be used to endorse or promote
1564 + * products derived from this software without specific prior
1565 + * written permission.
1566 + *
1567 + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS
1568 + * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
1569 + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
1570 + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
1571 + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
1572 + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
1573 + * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
1574 + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
1575 + * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
1576 + * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
1577 + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
1578 + *
1579 + * This file is part of the uIP TCP/IP stack.
1580 + *
1581 + * $Id: tapdev.h,v 1.1.2.1 2003/10/04 22:54:17 adam Exp $
1582 + *
1583 + */
1584 +
1585 +#ifndef __TAPDEV_H__
1586 +#define __TAPDEV_H__
1587 +
1588 +void tapdev_init(void);
1589 +unsigned int tapdev_read(void);
1590 +void tapdev_send(void);
1591 +
1592 +#endif /* __TAPDEV_H__ */
1593 --- /dev/null
1594 +++ b/net/uip-0.9/uip.c
1595 @@ -0,0 +1,1503 @@
1596 +/**
1597 + * \addtogroup uip
1598 + * @{
1599 + */
1600 +
1601 +/**
1602 + * \file
1603 + * The uIP TCP/IP stack code.
1604 + * \author Adam Dunkels <adam@dunkels.com>
1605 + */
1606 +
1607 +/*
1608 + * Copyright (c) 2001-2003, Adam Dunkels.
1609 + * All rights reserved.
1610 + *
1611 + * Redistribution and use in source and binary forms, with or without
1612 + * modification, are permitted provided that the following conditions
1613 + * are met:
1614 + * 1. Redistributions of source code must retain the above copyright
1615 + * notice, this list of conditions and the following disclaimer.
1616 + * 2. Redistributions in binary form must reproduce the above copyright
1617 + * notice, this list of conditions and the following disclaimer in the
1618 + * documentation and/or other materials provided with the distribution.
1619 + * 3. The name of the author may not be used to endorse or promote
1620 + * products derived from this software without specific prior
1621 + * written permission.
1622 + *
1623 + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS
1624 + * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
1625 + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
1626 + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
1627 + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
1628 + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
1629 + * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
1630 + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
1631 + * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
1632 + * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
1633 + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
1634 + *
1635 + * This file is part of the uIP TCP/IP stack.
1636 + *
1637 + * $Id: uip.c,v 1.62.2.10 2003/10/07 13:23:01 adam Exp $
1638 + *
1639 + */
1640 +
1641 +/*
1642 +This is a small implementation of the IP and TCP protocols (as well as
1643 +some basic ICMP stuff). The implementation couples the IP, TCP and the
1644 +application layers very tightly. To keep the size of the compiled code
1645 +down, this code also features heavy usage of the goto statement.
1646 +
1647 +The principle is that we have a small buffer, called the uip_buf, in
1648 +which the device driver puts an incoming packet. The TCP/IP stack
1649 +parses the headers in the packet, and calls upon the application. If
1650 +the remote host has sent data to the application, this data is present
1651 +in the uip_buf and the application read the data from there. It is up
1652 +to the application to put this data into a byte stream if needed. The
1653 +application will not be fed with data that is out of sequence.
1654 +
1655 +If the application whishes to send data to the peer, it should put its
1656 +data into the uip_buf, 40 bytes from the start of the buffer. The
1657 +TCP/IP stack will calculate the checksums, and fill in the necessary
1658 +header fields and finally send the packet back to the peer.
1659 +*/
1660 +
1661 +#include "uip.h"
1662 +#include "uipopt.h"
1663 +#include "uip_arch.h"
1664 +
1665 +/*-----------------------------------------------------------------------------------*/
1666 +/* Variable definitions. */
1667 +
1668 +
1669 +/* 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 */
1670 +#if UIP_FIXEDADDR > 0
1671 +const unsigned short int uip_hostaddr[2] =
1672 + {HTONS((UIP_IPADDR0 << 8) | UIP_IPADDR1),
1673 + HTONS((UIP_IPADDR2 << 8) | UIP_IPADDR3)};
1674 +const unsigned short int uip_arp_draddr[2] =
1675 + {HTONS((UIP_DRIPADDR0 << 8) | UIP_DRIPADDR1),
1676 + HTONS((UIP_DRIPADDR2 << 8) | UIP_DRIPADDR3)};
1677 +const unsigned short int uip_arp_netmask[2] =
1678 + {HTONS((UIP_NETMASK0 << 8) | UIP_NETMASK1),
1679 + HTONS((UIP_NETMASK2 << 8) | UIP_NETMASK3)};
1680 +#else
1681 +unsigned short int uip_hostaddr[2];
1682 +unsigned short int uip_arp_draddr[2], uip_arp_netmask[2];
1683 +#endif /* UIP_FIXEDADDR */
1684 +
1685 +u8_t uip_buf[UIP_BUFSIZE+2]; /* The packet buffer that contains
1686 + incoming packets. */
1687 +volatile u8_t *uip_appdata; /* The uip_appdata pointer points to
1688 + application data. */
1689 +volatile u8_t *uip_sappdata; /* The uip_appdata pointer points to the
1690 + application data which is to be sent. */
1691 +#if UIP_URGDATA > 0
1692 +volatile u8_t *uip_urgdata; /* The uip_urgdata pointer points to
1693 + urgent data (out-of-band data), if
1694 + present. */
1695 +volatile u8_t uip_urglen, uip_surglen;
1696 +#endif /* UIP_URGDATA > 0 */
1697 +
1698 +volatile unsigned short int uip_len, uip_slen;
1699 + /* The uip_len is either 8 or 16 bits,
1700 + depending on the maximum packet
1701 + size. */
1702 +
1703 +volatile u8_t uip_flags; /* The uip_flags variable is used for
1704 + communication between the TCP/IP stack
1705 + and the application program. */
1706 +struct uip_conn *uip_conn; /* uip_conn always points to the current
1707 + connection. */
1708 +
1709 +struct uip_conn uip_conns[UIP_CONNS];
1710 + /* The uip_conns array holds all TCP
1711 + connections. */
1712 +unsigned short int uip_listenports[UIP_LISTENPORTS];
1713 + /* The uip_listenports list all currently
1714 + listning ports. */
1715 +#if UIP_UDP
1716 +struct uip_udp_conn *uip_udp_conn;
1717 +struct uip_udp_conn uip_udp_conns[UIP_UDP_CONNS];
1718 +#endif /* UIP_UDP */
1719 +
1720 +
1721 +static unsigned short int ipid; /* Ths ipid variable is an increasing
1722 + number that is used for the IP ID
1723 + field. */
1724 +
1725 +static u8_t iss[4]; /* The iss variable is used for the TCP
1726 + initial sequence number. */
1727 +
1728 +#if UIP_ACTIVE_OPEN
1729 +static unsigned short int lastport; /* Keeps track of the last port used for
1730 + a new connection. */
1731 +#endif /* UIP_ACTIVE_OPEN */
1732 +
1733 +/* Temporary variables. */
1734 +volatile u8_t uip_acc32[4];
1735 +static u8_t c, opt;
1736 +static unsigned short int tmp16;
1737 +
1738 +/* Structures and definitions. */
1739 +#define TCP_FIN 0x01
1740 +#define TCP_SYN 0x02
1741 +#define TCP_RST 0x04
1742 +#define TCP_PSH 0x08
1743 +#define TCP_ACK 0x10
1744 +#define TCP_URG 0x20
1745 +#define TCP_CTL 0x3f
1746 +
1747 +#define ICMP_ECHO_REPLY 0
1748 +#define ICMP_ECHO 8
1749 +
1750 +/* Macros. */
1751 +#define BUF ((uip_tcpip_hdr *)&uip_buf[UIP_LLH_LEN])
1752 +#define FBUF ((uip_tcpip_hdr *)&uip_reassbuf[0])
1753 +#define ICMPBUF ((uip_icmpip_hdr *)&uip_buf[UIP_LLH_LEN])
1754 +#define UDPBUF ((uip_udpip_hdr *)&uip_buf[UIP_LLH_LEN])
1755 +
1756 +#if UIP_STATISTICS == 1
1757 +struct uip_stats uip_stat;
1758 +#define UIP_STAT(s) s
1759 +#else
1760 +#define UIP_STAT(s)
1761 +#endif /* UIP_STATISTICS == 1 */
1762 +
1763 +#if UIP_LOGGING == 1
1764 +extern void puts(const char *s);
1765 +#define UIP_LOG(m) puts(m)
1766 +#else
1767 +#define UIP_LOG(m)
1768 +#endif /* UIP_LOGGING == 1 */
1769 +
1770 +/*-----------------------------------------------------------------------------------*/
1771 +void
1772 +uip_init(void)
1773 +{
1774 + for(c = 0; c < UIP_LISTENPORTS; ++c) {
1775 + uip_listenports[c] = 0;
1776 + }
1777 + for(c = 0; c < UIP_CONNS; ++c) {
1778 + uip_conns[c].tcpstateflags = CLOSED;
1779 + }
1780 +#if UIP_ACTIVE_OPEN
1781 + lastport = 1024;
1782 +#endif /* UIP_ACTIVE_OPEN */
1783 +
1784 +#if UIP_UDP
1785 + for(c = 0; c < UIP_UDP_CONNS; ++c) {
1786 + uip_udp_conns[c].lport = 0;
1787 + }
1788 +#endif /* UIP_UDP */
1789 +
1790 +
1791 + /* IPv4 initialization. */
1792 +#if UIP_FIXEDADDR == 0
1793 + uip_hostaddr[0] = uip_hostaddr[1] = 0;
1794 +#endif /* UIP_FIXEDADDR */
1795 +
1796 +}
1797 +/*-----------------------------------------------------------------------------------*/
1798 +#if UIP_ACTIVE_OPEN
1799 +struct uip_conn *
1800 +uip_connect(unsigned short int *ripaddr, unsigned short int rport)
1801 +{
1802 + register struct uip_conn *conn, *cconn;
1803 +
1804 + /* Find an unused local port. */
1805 + again:
1806 + ++lastport;
1807 +
1808 + if(lastport >= 32000) {
1809 + lastport = 4096;
1810 + }
1811 +
1812 + /* Check if this port is already in use, and if so try to find
1813 + another one. */
1814 + for(c = 0; c < UIP_CONNS; ++c) {
1815 + conn = &uip_conns[c];
1816 + if(conn->tcpstateflags != CLOSED &&
1817 + conn->lport == htons(lastport)) {
1818 + goto again;
1819 + }
1820 + }
1821 +
1822 +
1823 + conn = 0;
1824 + for(c = 0; c < UIP_CONNS; ++c) {
1825 + cconn = &uip_conns[c];
1826 + if(cconn->tcpstateflags == CLOSED) {
1827 + conn = cconn;
1828 + break;
1829 + }
1830 + if(cconn->tcpstateflags == TIME_WAIT) {
1831 + if(conn == 0 ||
1832 + cconn->timer > uip_conn->timer) {
1833 + conn = cconn;
1834 + }
1835 + }
1836 + }
1837 +
1838 + if(conn == 0) {
1839 + return 0;
1840 + }
1841 +
1842 + conn->tcpstateflags = SYN_SENT;
1843 +
1844 + conn->snd_nxt[0] = iss[0];
1845 + conn->snd_nxt[1] = iss[1];
1846 + conn->snd_nxt[2] = iss[2];
1847 + conn->snd_nxt[3] = iss[3];
1848 +
1849 + conn->initialmss = conn->mss = UIP_TCP_MSS;
1850 +
1851 + conn->len = 1; /* TCP length of the SYN is one. */
1852 + conn->nrtx = 0;
1853 + conn->timer = 1; /* Send the SYN next time around. */
1854 + conn->rto = UIP_RTO;
1855 + conn->sa = 0;
1856 + conn->sv = 16;
1857 + conn->lport = htons(lastport);
1858 + conn->rport = rport;
1859 + conn->ripaddr[0] = ripaddr[0];
1860 + conn->ripaddr[1] = ripaddr[1];
1861 +
1862 + return conn;
1863 +}
1864 +#endif /* UIP_ACTIVE_OPEN */
1865 +/*-----------------------------------------------------------------------------------*/
1866 +#if UIP_UDP
1867 +struct uip_udp_conn *
1868 +uip_udp_new(unsigned short int *ripaddr, unsigned short int rport)
1869 +{
1870 + register struct uip_udp_conn *conn;
1871 +
1872 + /* Find an unused local port. */
1873 + again:
1874 + ++lastport;
1875 +
1876 + if(lastport >= 32000) {
1877 + lastport = 4096;
1878 + }
1879 +
1880 + for(c = 0; c < UIP_UDP_CONNS; ++c) {
1881 + if(uip_udp_conns[c].lport == lastport) {
1882 + goto again;
1883 + }
1884 + }
1885 +
1886 +
1887 + conn = 0;
1888 + for(c = 0; c < UIP_UDP_CONNS; ++c) {
1889 + if(uip_udp_conns[c].lport == 0) {
1890 + conn = &uip_udp_conns[c];
1891 + break;
1892 + }
1893 + }
1894 +
1895 + if(conn == 0) {
1896 + return 0;
1897 + }
1898 +
1899 + conn->lport = HTONS(lastport);
1900 + conn->rport = HTONS(rport);
1901 + conn->ripaddr[0] = ripaddr[0];
1902 + conn->ripaddr[1] = ripaddr[1];
1903 +
1904 + return conn;
1905 +}
1906 +#endif /* UIP_UDP */
1907 +/*-----------------------------------------------------------------------------------*/
1908 +void
1909 +uip_unlisten(unsigned short int port)
1910 +{
1911 + for(c = 0; c < UIP_LISTENPORTS; ++c) {
1912 + if(uip_listenports[c] == port) {
1913 + uip_listenports[c] = 0;
1914 + return;
1915 + }
1916 + }
1917 +}
1918 +/*-----------------------------------------------------------------------------------*/
1919 +void
1920 +uip_listen(unsigned short int port)
1921 +{
1922 + for(c = 0; c < UIP_LISTENPORTS; ++c) {
1923 + if(uip_listenports[c] == 0) {
1924 + uip_listenports[c] = port;
1925 + return;
1926 + }
1927 + }
1928 +}
1929 +/*-----------------------------------------------------------------------------------*/
1930 +/* XXX: IP fragment reassembly: not well-tested. */
1931 +
1932 +#if UIP_REASSEMBLY
1933 +#define UIP_REASS_BUFSIZE (UIP_BUFSIZE - UIP_LLH_LEN)
1934 +static u8_t uip_reassbuf[UIP_REASS_BUFSIZE];
1935 +static u8_t uip_reassbitmap[UIP_REASS_BUFSIZE / (8 * 8)];
1936 +static const u8_t bitmap_bits[8] = {0xff, 0x7f, 0x3f, 0x1f,
1937 + 0x0f, 0x07, 0x03, 0x01};
1938 +static unsigned short int uip_reasslen;
1939 +static u8_t uip_reassflags;
1940 +#define UIP_REASS_FLAG_LASTFRAG 0x01
1941 +static u8_t uip_reasstmr;
1942 +
1943 +#define IP_HLEN 20
1944 +#define IP_MF 0x20
1945 +
1946 +static u8_t
1947 +uip_reass(void)
1948 +{
1949 + unsigned short int offset, len;
1950 + unsigned short int i;
1951 +
1952 + /* If ip_reasstmr is zero, no packet is present in the buffer, so we
1953 + write the IP header of the fragment into the reassembly
1954 + buffer. The timer is updated with the maximum age. */
1955 + if(uip_reasstmr == 0) {
1956 + memcpy(uip_reassbuf, &BUF->vhl, IP_HLEN);
1957 + uip_reasstmr = UIP_REASS_MAXAGE;
1958 + uip_reassflags = 0;
1959 + /* Clear the bitmap. */
1960 + memset(uip_reassbitmap, sizeof(uip_reassbitmap), 0);
1961 + }
1962 +
1963 + /* Check if the incoming fragment matches the one currently present
1964 + in the reasembly buffer. If so, we proceed with copying the
1965 + fragment into the buffer. */
1966 + if(BUF->srcipaddr[0] == FBUF->srcipaddr[0] &&
1967 + BUF->srcipaddr[1] == FBUF->srcipaddr[1] &&
1968 + BUF->destipaddr[0] == FBUF->destipaddr[0] &&
1969 + BUF->destipaddr[1] == FBUF->destipaddr[1] &&
1970 + BUF->ipid[0] == FBUF->ipid[0] &&
1971 + BUF->ipid[1] == FBUF->ipid[1]) {
1972 +
1973 + len = (BUF->len[0] << 8) + BUF->len[1] - (BUF->vhl & 0x0f) * 4;
1974 + offset = (((BUF->ipoffset[0] & 0x3f) << 8) + BUF->ipoffset[1]) * 8;
1975 +
1976 + /* If the offset or the offset + fragment length overflows the
1977 + reassembly buffer, we discard the entire packet. */
1978 + if(offset > UIP_REASS_BUFSIZE ||
1979 + offset + len > UIP_REASS_BUFSIZE) {
1980 + uip_reasstmr = 0;
1981 + goto nullreturn;
1982 + }
1983 +
1984 + /* Copy the fragment into the reassembly buffer, at the right
1985 + offset. */
1986 + memcpy(&uip_reassbuf[IP_HLEN + offset],
1987 + (char *)BUF + (int)((BUF->vhl & 0x0f) * 4),
1988 + len);
1989 +
1990 + /* Update the bitmap. */
1991 + if(offset / (8 * 8) == (offset + len) / (8 * 8)) {
1992 + /* If the two endpoints are in the same byte, we only update
1993 + that byte. */
1994 +
1995 + uip_reassbitmap[offset / (8 * 8)] |=
1996 + bitmap_bits[(offset / 8 ) & 7] &
1997 + ~bitmap_bits[((offset + len) / 8 ) & 7];
1998 + } else {
1999 + /* If the two endpoints are in different bytes, we update the
2000 + bytes in the endpoints and fill the stuff inbetween with
2001 + 0xff. */
2002 + uip_reassbitmap[offset / (8 * 8)] |=
2003 + bitmap_bits[(offset / 8 ) & 7];
2004 + for(i = 1 + offset / (8 * 8); i < (offset + len) / (8 * 8); ++i) {
2005 + uip_reassbitmap[i] = 0xff;
2006 + }
2007 + uip_reassbitmap[(offset + len) / (8 * 8)] |=
2008 + ~bitmap_bits[((offset + len) / 8 ) & 7];
2009 + }
2010 +
2011 + /* If this fragment has the More Fragments flag set to zero, we
2012 + know that this is the last fragment, so we can calculate the
2013 + size of the entire packet. We also set the
2014 + IP_REASS_FLAG_LASTFRAG flag to indicate that we have received
2015 + the final fragment. */
2016 +
2017 + if((BUF->ipoffset[0] & IP_MF) == 0) {
2018 + uip_reassflags |= UIP_REASS_FLAG_LASTFRAG;
2019 + uip_reasslen = offset + len;
2020 + }
2021 +
2022 + /* Finally, we check if we have a full packet in the buffer. We do
2023 + this by checking if we have the last fragment and if all bits
2024 + in the bitmap are set. */
2025 + if(uip_reassflags & UIP_REASS_FLAG_LASTFRAG) {
2026 + /* Check all bytes up to and including all but the last byte in
2027 + the bitmap. */
2028 + for(i = 0; i < uip_reasslen / (8 * 8) - 1; ++i) {
2029 + if(uip_reassbitmap[i] != 0xff) {
2030 + goto nullreturn;
2031 + }
2032 + }
2033 + /* Check the last byte in the bitmap. It should contain just the
2034 + right amount of bits. */
2035 + if(uip_reassbitmap[uip_reasslen / (8 * 8)] !=
2036 + (u8_t)~bitmap_bits[uip_reasslen / 8 & 7]) {
2037 + goto nullreturn;
2038 + }
2039 +
2040 + /* If we have come this far, we have a full packet in the
2041 + buffer, so we allocate a pbuf and copy the packet into it. We
2042 + also reset the timer. */
2043 + uip_reasstmr = 0;
2044 + memcpy(BUF, FBUF, uip_reasslen);
2045 +
2046 + /* Pretend to be a "normal" (i.e., not fragmented) IP packet
2047 + from now on. */
2048 + BUF->ipoffset[0] = BUF->ipoffset[1] = 0;
2049 + BUF->len[0] = uip_reasslen >> 8;
2050 + BUF->len[1] = uip_reasslen & 0xff;
2051 + BUF->ipchksum = 0;
2052 + BUF->ipchksum = ~(uip_ipchksum());
2053 +
2054 + return uip_reasslen;
2055 + }
2056 + }
2057 +
2058 + nullreturn:
2059 + return 0;
2060 +}
2061 +#endif /* UIP_REASSEMBL */
2062 +/*-----------------------------------------------------------------------------------*/
2063 +static void
2064 +uip_add_rcv_nxt(unsigned short int n)
2065 +{
2066 + uip_add32(uip_conn->rcv_nxt, n);
2067 + uip_conn->rcv_nxt[0] = uip_acc32[0];
2068 + uip_conn->rcv_nxt[1] = uip_acc32[1];
2069 + uip_conn->rcv_nxt[2] = uip_acc32[2];
2070 + uip_conn->rcv_nxt[3] = uip_acc32[3];
2071 +}
2072 +/*-----------------------------------------------------------------------------------*/
2073 +void
2074 +uip_process(u8_t flag)
2075 +{
2076 + register struct uip_conn *uip_connr = uip_conn;
2077 +
2078 + uip_appdata = &uip_buf[40 + UIP_LLH_LEN];
2079 +
2080 +
2081 + /* Check if we were invoked because of the perodic timer fireing. */
2082 + if(flag == UIP_TIMER) {
2083 +#if UIP_REASSEMBLY
2084 + if(uip_reasstmr != 0) {
2085 + --uip_reasstmr;
2086 + }
2087 +#endif /* UIP_REASSEMBLY */
2088 + /* Increase the initial sequence number. */
2089 + if(++iss[3] == 0) {
2090 + if(++iss[2] == 0) {
2091 + if(++iss[1] == 0) {
2092 + ++iss[0];
2093 + }
2094 + }
2095 + }
2096 + uip_len = 0;
2097 + if(uip_connr->tcpstateflags == TIME_WAIT ||
2098 + uip_connr->tcpstateflags == FIN_WAIT_2) {
2099 + ++(uip_connr->timer);
2100 + if(uip_connr->timer == UIP_TIME_WAIT_TIMEOUT) {
2101 + uip_connr->tcpstateflags = CLOSED;
2102 + }
2103 + } else if(uip_connr->tcpstateflags != CLOSED) {
2104 + /* If the connection has outstanding data, we increase the
2105 + connection's timer and see if it has reached the RTO value
2106 + in which case we retransmit. */
2107 + if(uip_outstanding(uip_connr)) {
2108 + if(uip_connr->timer-- == 0) {
2109 + if(uip_connr->nrtx == UIP_MAXRTX ||
2110 + ((uip_connr->tcpstateflags == SYN_SENT ||
2111 + uip_connr->tcpstateflags == SYN_RCVD) &&
2112 + uip_connr->nrtx == UIP_MAXSYNRTX)) {
2113 + uip_connr->tcpstateflags = CLOSED;
2114 +
2115 + /* We call UIP_APPCALL() with uip_flags set to
2116 + UIP_TIMEDOUT to inform the application that the
2117 + connection has timed out. */
2118 + uip_flags = UIP_TIMEDOUT;
2119 + UIP_APPCALL();
2120 +
2121 + /* We also send a reset packet to the remote host. */
2122 + BUF->flags = TCP_RST | TCP_ACK;
2123 + goto tcp_send_nodata;
2124 + }
2125 +
2126 + /* Exponential backoff. */
2127 + uip_connr->timer = UIP_RTO << (uip_connr->nrtx > 4?
2128 + 4:
2129 + uip_connr->nrtx);
2130 + ++(uip_connr->nrtx);
2131 +
2132 + /* Ok, so we need to retransmit. We do this differently
2133 + depending on which state we are in. In ESTABLISHED, we
2134 + call upon the application so that it may prepare the
2135 + data for the retransmit. In SYN_RCVD, we resend the
2136 + SYNACK that we sent earlier and in LAST_ACK we have to
2137 + retransmit our FINACK. */
2138 + UIP_STAT(++uip_stat.tcp.rexmit);
2139 + switch(uip_connr->tcpstateflags & TS_MASK) {
2140 + case SYN_RCVD:
2141 + /* In the SYN_RCVD state, we should retransmit our
2142 + SYNACK. */
2143 + goto tcp_send_synack;
2144 +
2145 +#if UIP_ACTIVE_OPEN
2146 + case SYN_SENT:
2147 + /* In the SYN_SENT state, we retransmit out SYN. */
2148 + BUF->flags = 0;
2149 + goto tcp_send_syn;
2150 +#endif /* UIP_ACTIVE_OPEN */
2151 +
2152 + case ESTABLISHED:
2153 + /* In the ESTABLISHED state, we call upon the application
2154 + to do the actual retransmit after which we jump into
2155 + the code for sending out the packet (the apprexmit
2156 + label). */
2157 + uip_len = 0;
2158 + uip_slen = 0;
2159 + uip_flags = UIP_REXMIT;
2160 + UIP_APPCALL();
2161 + goto apprexmit;
2162 +
2163 + case FIN_WAIT_1:
2164 + case CLOSING:
2165 + case LAST_ACK:
2166 + /* In all these states we should retransmit a FINACK. */
2167 + goto tcp_send_finack;
2168 +
2169 + }
2170 + }
2171 + } else if((uip_connr->tcpstateflags & TS_MASK) == ESTABLISHED) {
2172 + /* If there was no need for a retransmission, we poll the
2173 + application for new data. */
2174 + uip_len = 0;
2175 + uip_slen = 0;
2176 + uip_flags = UIP_POLL;
2177 + UIP_APPCALL();
2178 + goto appsend;
2179 + }
2180 + }
2181 + goto drop;
2182 + }
2183 +#if UIP_UDP
2184 + if(flag == UIP_UDP_TIMER) {
2185 + if(uip_udp_conn->lport != 0) {
2186 + uip_appdata = &uip_buf[UIP_LLH_LEN + 28];
2187 + uip_len = uip_slen = 0;
2188 + uip_flags = UIP_POLL;
2189 + UIP_UDP_APPCALL();
2190 + goto udp_send;
2191 + } else {
2192 + goto drop;
2193 + }
2194 + }
2195 +#endif
2196 +
2197 + /* This is where the input processing starts. */
2198 + UIP_STAT(++uip_stat.ip.recv);
2199 +
2200 +
2201 + /* Start of IPv4 input header processing code. */
2202 +
2203 + /* Check validity of the IP header. */
2204 + if(BUF->vhl != 0x45) { /* IP version and header length. */
2205 + UIP_STAT(++uip_stat.ip.drop);
2206 + UIP_STAT(++uip_stat.ip.vhlerr);
2207 + UIP_LOG("ip: invalid version or header length.");
2208 + goto drop;
2209 + }
2210 +
2211 + /* Check the size of the packet. If the size reported to us in
2212 + uip_len doesn't match the size reported in the IP header, there
2213 + has been a transmission error and we drop the packet. */
2214 +
2215 + if(BUF->len[0] != (uip_len >> 8)) { /* IP length, high byte. */
2216 + uip_len = (uip_len & 0xff) | (BUF->len[0] << 8);
2217 + }
2218 + if(BUF->len[1] != (uip_len & 0xff)) { /* IP length, low byte. */
2219 + uip_len = (uip_len & 0xff00) | BUF->len[1];
2220 + }
2221 +
2222 + /* Check the fragment flag. */
2223 + if((BUF->ipoffset[0] & 0x3f) != 0 ||
2224 + BUF->ipoffset[1] != 0) {
2225 +#if UIP_REASSEMBLY
2226 + uip_len = uip_reass();
2227 + if(uip_len == 0) {
2228 + goto drop;
2229 + }
2230 +#else
2231 + UIP_STAT(++uip_stat.ip.drop);
2232 + UIP_STAT(++uip_stat.ip.fragerr);
2233 + UIP_LOG("ip: fragment dropped.");
2234 + goto drop;
2235 +#endif /* UIP_REASSEMBLY */
2236 + }
2237 +
2238 + /* If we are configured to use ping IP address configuration and
2239 + hasn't been assigned an IP address yet, we accept all ICMP
2240 + packets. */
2241 +#if UIP_PINGADDRCONF
2242 + if((uip_hostaddr[0] | uip_hostaddr[1]) == 0) {
2243 + if(BUF->proto == UIP_PROTO_ICMP) {
2244 + UIP_LOG("ip: possible ping config packet received.");
2245 + goto icmp_input;
2246 + } else {
2247 + UIP_LOG("ip: packet dropped since no address assigned.");
2248 + goto drop;
2249 + }
2250 + }
2251 +#endif /* UIP_PINGADDRCONF */
2252 +
2253 + /* Check if the packet is destined for our IP address. */
2254 + if(BUF->destipaddr[0] != uip_hostaddr[0]) {
2255 + UIP_STAT(++uip_stat.ip.drop);
2256 + UIP_LOG("ip: packet not for us.");
2257 + goto drop;
2258 + }
2259 + if(BUF->destipaddr[1] != uip_hostaddr[1]) {
2260 + UIP_STAT(++uip_stat.ip.drop);
2261 + UIP_LOG("ip: packet not for us.");
2262 + goto drop;
2263 + }
2264 +
2265 + if(uip_ipchksum() != 0xffff) { /* Compute and check the IP header
2266 + checksum. */
2267 + UIP_STAT(++uip_stat.ip.drop);
2268 + UIP_STAT(++uip_stat.ip.chkerr);
2269 + UIP_LOG("ip: bad checksum.");
2270 + goto drop;
2271 + }
2272 +
2273 + if(BUF->proto == UIP_PROTO_TCP) /* Check for TCP packet. If so, jump
2274 + to the tcp_input label. */
2275 + goto tcp_input;
2276 +
2277 +#if UIP_UDP
2278 + if(BUF->proto == UIP_PROTO_UDP)
2279 + goto udp_input;
2280 +#endif /* UIP_UDP */
2281 +
2282 + if(BUF->proto != UIP_PROTO_ICMP) { /* We only allow ICMP packets from
2283 + here. */
2284 + UIP_STAT(++uip_stat.ip.drop);
2285 + UIP_STAT(++uip_stat.ip.protoerr);
2286 + UIP_LOG("ip: neither tcp nor icmp.");
2287 + goto drop;
2288 + }
2289 +
2290 + //icmp_input:
2291 + UIP_STAT(++uip_stat.icmp.recv);
2292 +
2293 + /* ICMP echo (i.e., ping) processing. This is simple, we only change
2294 + the ICMP type from ECHO to ECHO_REPLY and adjust the ICMP
2295 + checksum before we return the packet. */
2296 + if(ICMPBUF->type != ICMP_ECHO) {
2297 + UIP_STAT(++uip_stat.icmp.drop);
2298 + UIP_STAT(++uip_stat.icmp.typeerr);
2299 + UIP_LOG("icmp: not icmp echo.");
2300 + goto drop;
2301 + }
2302 +
2303 + /* If we are configured to use ping IP address assignment, we use
2304 + the destination IP address of this ping packet and assign it to
2305 + ourself. */
2306 +#if UIP_PINGADDRCONF
2307 + if((uip_hostaddr[0] | uip_hostaddr[1]) == 0) {
2308 + uip_hostaddr[0] = BUF->destipaddr[0];
2309 + uip_hostaddr[1] = BUF->destipaddr[1];
2310 + }
2311 +#endif /* UIP_PINGADDRCONF */
2312 +
2313 + ICMPBUF->type = ICMP_ECHO_REPLY;
2314 +
2315 + if(ICMPBUF->icmpchksum >= HTONS(0xffff - (ICMP_ECHO << 8))) {
2316 + ICMPBUF->icmpchksum += HTONS(ICMP_ECHO << 8) + 1;
2317 + } else {
2318 + ICMPBUF->icmpchksum += HTONS(ICMP_ECHO << 8);
2319 + }
2320 +
2321 + /* Swap IP addresses. */
2322 + tmp16 = BUF->destipaddr[0];
2323 + BUF->destipaddr[0] = BUF->srcipaddr[0];
2324 + BUF->srcipaddr[0] = tmp16;
2325 + tmp16 = BUF->destipaddr[1];
2326 + BUF->destipaddr[1] = BUF->srcipaddr[1];
2327 + BUF->srcipaddr[1] = tmp16;
2328 +
2329 + UIP_STAT(++uip_stat.icmp.sent);
2330 + goto send;
2331 +
2332 + /* End of IPv4 input header processing code. */
2333 +
2334 +
2335 +#if UIP_UDP
2336 + /* UDP input processing. */
2337 + udp_input:
2338 + /* UDP processing is really just a hack. We don't do anything to the
2339 + UDP/IP headers, but let the UDP application do all the hard
2340 + work. If the application sets uip_slen, it has a packet to
2341 + send. */
2342 +#if UIP_UDP_CHECKSUMS
2343 + if(uip_udpchksum() != 0xffff) {
2344 + UIP_STAT(++uip_stat.udp.drop);
2345 + UIP_STAT(++uip_stat.udp.chkerr);
2346 + UIP_LOG("udp: bad checksum.");
2347 + goto drop;
2348 + }
2349 +#endif /* UIP_UDP_CHECKSUMS */
2350 +
2351 + /* Demultiplex this UDP packet between the UDP "connections". */
2352 + for(uip_udp_conn = &uip_udp_conns[0];
2353 + uip_udp_conn < &uip_udp_conns[UIP_UDP_CONNS];
2354 + ++uip_udp_conn) {
2355 + if(uip_udp_conn->lport != 0 &&
2356 + UDPBUF->destport == uip_udp_conn->lport &&
2357 + (uip_udp_conn->rport == 0 ||
2358 + UDPBUF->srcport == uip_udp_conn->rport) &&
2359 + BUF->srcipaddr[0] == uip_udp_conn->ripaddr[0] &&
2360 + BUF->srcipaddr[1] == uip_udp_conn->ripaddr[1]) {
2361 + goto udp_found;
2362 + }
2363 + }
2364 + goto drop;
2365 +
2366 + udp_found:
2367 + uip_len = uip_len - 28;
2368 + uip_appdata = &uip_buf[UIP_LLH_LEN + 28];
2369 + uip_flags = UIP_NEWDATA;
2370 + uip_slen = 0;
2371 + UIP_UDP_APPCALL();
2372 + udp_send:
2373 + if(uip_slen == 0) {
2374 + goto drop;
2375 + }
2376 + uip_len = uip_slen + 28;
2377 +
2378 + BUF->len[0] = (uip_len >> 8);
2379 + BUF->len[1] = (uip_len & 0xff);
2380 +
2381 + BUF->proto = UIP_PROTO_UDP;
2382 +
2383 + UDPBUF->udplen = HTONS(uip_slen + 8);
2384 + UDPBUF->udpchksum = 0;
2385 +#if UIP_UDP_CHECKSUMS
2386 + /* Calculate UDP checksum. */
2387 + UDPBUF->udpchksum = ~(uip_udpchksum());
2388 + if(UDPBUF->udpchksum == 0) {
2389 + UDPBUF->udpchksum = 0xffff;
2390 + }
2391 +#endif /* UIP_UDP_CHECKSUMS */
2392 +
2393 + BUF->srcport = uip_udp_conn->lport;
2394 + BUF->destport = uip_udp_conn->rport;
2395 +
2396 + BUF->srcipaddr[0] = uip_hostaddr[0];
2397 + BUF->srcipaddr[1] = uip_hostaddr[1];
2398 + BUF->destipaddr[0] = uip_udp_conn->ripaddr[0];
2399 + BUF->destipaddr[1] = uip_udp_conn->ripaddr[1];
2400 +
2401 + uip_appdata = &uip_buf[UIP_LLH_LEN + 40];
2402 + goto ip_send_nolen;
2403 +#endif /* UIP_UDP */
2404 +
2405 + /* TCP input processing. */
2406 + tcp_input:
2407 + UIP_STAT(++uip_stat.tcp.recv);
2408 +
2409 + /* Start of TCP input header processing code. */
2410 +
2411 + if(uip_tcpchksum() != 0xffff) { /* Compute and check the TCP
2412 + checksum. */
2413 + UIP_STAT(++uip_stat.tcp.drop);
2414 + UIP_STAT(++uip_stat.tcp.chkerr);
2415 + UIP_LOG("tcp: bad checksum.");
2416 + goto drop;
2417 + }
2418 +
2419 + /* Demultiplex this segment. */
2420 + /* First check any active connections. */
2421 + for(uip_connr = &uip_conns[0]; uip_connr < &uip_conns[UIP_CONNS]; ++uip_connr) {
2422 + if(uip_connr->tcpstateflags != CLOSED &&
2423 + BUF->destport == uip_connr->lport &&
2424 + BUF->srcport == uip_connr->rport &&
2425 + BUF->srcipaddr[0] == uip_connr->ripaddr[0] &&
2426 + BUF->srcipaddr[1] == uip_connr->ripaddr[1]) {
2427 + goto found;
2428 + }
2429 + }
2430 +
2431 + /* If we didn't find and active connection that expected the packet,
2432 + either this packet is an old duplicate, or this is a SYN packet
2433 + destined for a connection in LISTEN. If the SYN flag isn't set,
2434 + it is an old packet and we send a RST. */
2435 + if((BUF->flags & TCP_CTL) != TCP_SYN)
2436 + goto reset;
2437 +
2438 + tmp16 = BUF->destport;
2439 + /* Next, check listening connections. */
2440 + for(c = 0; c < UIP_LISTENPORTS; ++c) {
2441 + if(tmp16 == uip_listenports[c])
2442 + goto found_listen;
2443 + }
2444 +
2445 + /* No matching connection found, so we send a RST packet. */
2446 + UIP_STAT(++uip_stat.tcp.synrst);
2447 + reset:
2448 +
2449 + /* We do not send resets in response to resets. */
2450 + if(BUF->flags & TCP_RST)
2451 + goto drop;
2452 +
2453 + UIP_STAT(++uip_stat.tcp.rst);
2454 +
2455 + BUF->flags = TCP_RST | TCP_ACK;
2456 + uip_len = 40;
2457 + BUF->tcpoffset = 5 << 4;
2458 +
2459 + /* Flip the seqno and ackno fields in the TCP header. */
2460 + c = BUF->seqno[3];
2461 + BUF->seqno[3] = BUF->ackno[3];
2462 + BUF->ackno[3] = c;
2463 +
2464 + c = BUF->seqno[2];
2465 + BUF->seqno[2] = BUF->ackno[2];
2466 + BUF->ackno[2] = c;
2467 +
2468 + c = BUF->seqno[1];
2469 + BUF->seqno[1] = BUF->ackno[1];
2470 + BUF->ackno[1] = c;
2471 +
2472 + c = BUF->seqno[0];
2473 + BUF->seqno[0] = BUF->ackno[0];
2474 + BUF->ackno[0] = c;
2475 +
2476 + /* We also have to increase the sequence number we are
2477 + acknowledging. If the least significant byte overflowed, we need
2478 + to propagate the carry to the other bytes as well. */
2479 + if(++BUF->ackno[3] == 0) {
2480 + if(++BUF->ackno[2] == 0) {
2481 + if(++BUF->ackno[1] == 0) {
2482 + ++BUF->ackno[0];
2483 + }
2484 + }
2485 + }
2486 +
2487 + /* Swap port numbers. */
2488 + tmp16 = BUF->srcport;
2489 + BUF->srcport = BUF->destport;
2490 + BUF->destport = tmp16;
2491 +
2492 + /* Swap IP addresses. */
2493 + tmp16 = BUF->destipaddr[0];
2494 + BUF->destipaddr[0] = BUF->srcipaddr[0];
2495 + BUF->srcipaddr[0] = tmp16;
2496 + tmp16 = BUF->destipaddr[1];
2497 + BUF->destipaddr[1] = BUF->srcipaddr[1];
2498 + BUF->srcipaddr[1] = tmp16;
2499 +
2500 +
2501 + /* And send out the RST packet! */
2502 + goto tcp_send_noconn;
2503 +
2504 + /* This label will be jumped to if we matched the incoming packet
2505 + with a connection in LISTEN. In that case, we should create a new
2506 + connection and send a SYNACK in return. */
2507 + found_listen:
2508 + /* First we check if there are any connections avaliable. Unused
2509 + connections are kept in the same table as used connections, but
2510 + unused ones have the tcpstate set to CLOSED. Also, connections in
2511 + TIME_WAIT are kept track of and we'll use the oldest one if no
2512 + CLOSED connections are found. Thanks to Eddie C. Dost for a very
2513 + nice algorithm for the TIME_WAIT search. */
2514 + uip_connr = 0;
2515 + for(c = 0; c < UIP_CONNS; ++c) {
2516 + if(uip_conns[c].tcpstateflags == CLOSED) {
2517 + uip_connr = &uip_conns[c];
2518 + break;
2519 + }
2520 + if(uip_conns[c].tcpstateflags == TIME_WAIT) {
2521 + if(uip_connr == 0 ||
2522 + uip_conns[c].timer > uip_connr->timer) {
2523 + uip_connr = &uip_conns[c];
2524 + }
2525 + }
2526 + }
2527 +
2528 + if(uip_connr == 0) {
2529 + /* All connections are used already, we drop packet and hope that
2530 + the remote end will retransmit the packet at a time when we
2531 + have more spare connections. */
2532 + UIP_STAT(++uip_stat.tcp.syndrop);
2533 + UIP_LOG("tcp: found no unused connections.");
2534 + goto drop;
2535 + }
2536 + uip_conn = uip_connr;
2537 +
2538 + /* Fill in the necessary fields for the new connection. */
2539 + uip_connr->rto = uip_connr->timer = UIP_RTO;
2540 + uip_connr->sa = 0;
2541 + uip_connr->sv = 4;
2542 + uip_connr->nrtx = 0;
2543 + uip_connr->lport = BUF->destport;
2544 + uip_connr->rport = BUF->srcport;
2545 + uip_connr->ripaddr[0] = BUF->srcipaddr[0];
2546 + uip_connr->ripaddr[1] = BUF->srcipaddr[1];
2547 + uip_connr->tcpstateflags = SYN_RCVD;
2548 +
2549 + uip_connr->snd_nxt[0] = iss[0];
2550 + uip_connr->snd_nxt[1] = iss[1];
2551 + uip_connr->snd_nxt[2] = iss[2];
2552 + uip_connr->snd_nxt[3] = iss[3];
2553 + uip_connr->len = 1;
2554 +
2555 + /* rcv_nxt should be the seqno from the incoming packet + 1. */
2556 + uip_connr->rcv_nxt[3] = BUF->seqno[3];
2557 + uip_connr->rcv_nxt[2] = BUF->seqno[2];
2558 + uip_connr->rcv_nxt[1] = BUF->seqno[1];
2559 + uip_connr->rcv_nxt[0] = BUF->seqno[0];
2560 + uip_add_rcv_nxt(1);
2561 +
2562 + /* Parse the TCP MSS option, if present. */
2563 + if((BUF->tcpoffset & 0xf0) > 0x50) {
2564 + for(c = 0; c < ((BUF->tcpoffset >> 4) - 5) << 2 ;) {
2565 + opt = uip_buf[UIP_TCPIP_HLEN + UIP_LLH_LEN + c];
2566 + if(opt == 0x00) {
2567 + /* End of options. */
2568 + break;
2569 + } else if(opt == 0x01) {
2570 + ++c;
2571 + /* NOP option. */
2572 + } else if(opt == 0x02 &&
2573 + uip_buf[UIP_TCPIP_HLEN + UIP_LLH_LEN + 1 + c] == 0x04) {
2574 + /* An MSS option with the right option length. */
2575 + tmp16 = ((unsigned short int)uip_buf[UIP_TCPIP_HLEN + UIP_LLH_LEN + 2 + c] << 8) |
2576 + (unsigned short int)uip_buf[40 + UIP_LLH_LEN + 3 + c];
2577 + uip_connr->initialmss = uip_connr->mss =
2578 + tmp16 > UIP_TCP_MSS? UIP_TCP_MSS: tmp16;
2579 +
2580 + /* And we are done processing options. */
2581 + break;
2582 + } else {
2583 + /* All other options have a length field, so that we easily
2584 + can skip past them. */
2585 + if(uip_buf[UIP_TCPIP_HLEN + UIP_LLH_LEN + 1 + c] == 0) {
2586 + /* If the length field is zero, the options are malformed
2587 + and we don't process them further. */
2588 + break;
2589 + }
2590 + c += uip_buf[UIP_TCPIP_HLEN + UIP_LLH_LEN + 1 + c];
2591 + }
2592 + }
2593 + }
2594 +
2595 + /* Our response will be a SYNACK. */
2596 +#if UIP_ACTIVE_OPEN
2597 + tcp_send_synack:
2598 + BUF->flags = TCP_ACK;
2599 +
2600 + tcp_send_syn:
2601 + BUF->flags |= TCP_SYN;
2602 +#else /* UIP_ACTIVE_OPEN */
2603 + tcp_send_synack:
2604 + BUF->flags = TCP_SYN | TCP_ACK;
2605 +#endif /* UIP_ACTIVE_OPEN */
2606 +
2607 + /* We send out the TCP Maximum Segment Size option with our
2608 + SYNACK. */
2609 + BUF->optdata[0] = 2;
2610 + BUF->optdata[1] = 4;
2611 + BUF->optdata[2] = (UIP_TCP_MSS) / 256;
2612 + BUF->optdata[3] = (UIP_TCP_MSS) & 255;
2613 + uip_len = 44;
2614 + BUF->tcpoffset = 6 << 4;
2615 + goto tcp_send;
2616 +
2617 + /* This label will be jumped to if we found an active connection. */
2618 + found:
2619 + uip_conn = uip_connr;
2620 + uip_flags = 0;
2621 +
2622 + /* We do a very naive form of TCP reset processing; we just accept
2623 + any RST and kill our connection. We should in fact check if the
2624 + sequence number of this reset is wihtin our advertised window
2625 + before we accept the reset. */
2626 + if(BUF->flags & TCP_RST) {
2627 + uip_connr->tcpstateflags = CLOSED;
2628 + UIP_LOG("tcp: got reset, aborting connection.");
2629 + uip_flags = UIP_ABORT;
2630 + UIP_APPCALL();
2631 + goto drop;
2632 + }
2633 + /* Calculated the length of the data, if the application has sent
2634 + any data to us. */
2635 + c = (BUF->tcpoffset >> 4) << 2;
2636 + /* uip_len will contain the length of the actual TCP data. This is
2637 + calculated by subtracing the length of the TCP header (in
2638 + c) and the length of the IP header (20 bytes). */
2639 + uip_len = uip_len - c - 20;
2640 +
2641 + /* First, check if the sequence number of the incoming packet is
2642 + what we're expecting next. If not, we send out an ACK with the
2643 + correct numbers in. */
2644 + if(uip_len > 0 &&
2645 + (BUF->seqno[0] != uip_connr->rcv_nxt[0] ||
2646 + BUF->seqno[1] != uip_connr->rcv_nxt[1] ||
2647 + BUF->seqno[2] != uip_connr->rcv_nxt[2] ||
2648 + BUF->seqno[3] != uip_connr->rcv_nxt[3])) {
2649 + goto tcp_send_ack;
2650 + }
2651 +
2652 + /* Next, check if the incoming segment acknowledges any outstanding
2653 + data. If so, we update the sequence number, reset the length of
2654 + the outstanding data, calculate RTT estimations, and reset the
2655 + retransmission timer. */
2656 + if((BUF->flags & TCP_ACK) && uip_outstanding(uip_connr)) {
2657 + uip_add32(uip_connr->snd_nxt, uip_connr->len);
2658 + if(BUF->ackno[0] == uip_acc32[0] &&
2659 + BUF->ackno[1] == uip_acc32[1] &&
2660 + BUF->ackno[2] == uip_acc32[2] &&
2661 + BUF->ackno[3] == uip_acc32[3]) {
2662 + /* Update sequence number. */
2663 + uip_connr->snd_nxt[0] = uip_acc32[0];
2664 + uip_connr->snd_nxt[1] = uip_acc32[1];
2665 + uip_connr->snd_nxt[2] = uip_acc32[2];
2666 + uip_connr->snd_nxt[3] = uip_acc32[3];
2667 +
2668 +
2669 + /* Do RTT estimation, unless we have done retransmissions. */
2670 + if(uip_connr->nrtx == 0) {
2671 + signed char m;
2672 + m = uip_connr->rto - uip_connr->timer;
2673 + /* This is taken directly from VJs original code in his paper */
2674 + m = m - (uip_connr->sa >> 3);
2675 + uip_connr->sa += m;
2676 + if(m < 0) {
2677 + m = -m;
2678 + }
2679 + m = m - (uip_connr->sv >> 2);
2680 + uip_connr->sv += m;
2681 + uip_connr->rto = (uip_connr->sa >> 3) + uip_connr->sv;
2682 +
2683 + }
2684 + /* Set the acknowledged flag. */
2685 + uip_flags = UIP_ACKDATA;
2686 + /* Reset the retransmission timer. */
2687 + uip_connr->timer = uip_connr->rto;
2688 + }
2689 +
2690 + }
2691 +
2692 + /* Do different things depending on in what state the connection is. */
2693 + switch(uip_connr->tcpstateflags & TS_MASK) {
2694 + /* CLOSED and LISTEN are not handled here. CLOSE_WAIT is not
2695 + implemented, since we force the application to close when the
2696 + peer sends a FIN (hence the application goes directly from
2697 + ESTABLISHED to LAST_ACK). */
2698 + case SYN_RCVD:
2699 + /* In SYN_RCVD we have sent out a SYNACK in response to a SYN, and
2700 + we are waiting for an ACK that acknowledges the data we sent
2701 + out the last time. Therefore, we want to have the UIP_ACKDATA
2702 + flag set. If so, we enter the ESTABLISHED state. */
2703 + if(uip_flags & UIP_ACKDATA) {
2704 + uip_connr->tcpstateflags = ESTABLISHED;
2705 + uip_flags = UIP_CONNECTED;
2706 + uip_connr->len = 0;
2707 + if(uip_len > 0) {
2708 + uip_flags |= UIP_NEWDATA;
2709 + uip_add_rcv_nxt(uip_len);
2710 + }
2711 + uip_slen = 0;
2712 + UIP_APPCALL();
2713 + goto appsend;
2714 + }
2715 + goto drop;
2716 +#if UIP_ACTIVE_OPEN
2717 + case SYN_SENT:
2718 + /* In SYN_SENT, we wait for a SYNACK that is sent in response to
2719 + our SYN. The rcv_nxt is set to sequence number in the SYNACK
2720 + plus one, and we send an ACK. We move into the ESTABLISHED
2721 + state. */
2722 + if((uip_flags & UIP_ACKDATA) &&
2723 + BUF->flags == (TCP_SYN | TCP_ACK)) {
2724 +
2725 + /* Parse the TCP MSS option, if present. */
2726 + if((BUF->tcpoffset & 0xf0) > 0x50) {
2727 + for(c = 0; c < ((BUF->tcpoffset >> 4) - 5) << 2 ;) {
2728 + opt = uip_buf[40 + UIP_LLH_LEN + c];
2729 + if(opt == 0x00) {
2730 + /* End of options. */
2731 + break;
2732 + } else if(opt == 0x01) {
2733 + ++c;
2734 + /* NOP option. */
2735 + } else if(opt == 0x02 &&
2736 + uip_buf[UIP_TCPIP_HLEN + UIP_LLH_LEN + 1 + c] == 0x04) {
2737 + /* An MSS option with the right option length. */
2738 + tmp16 = (uip_buf[UIP_TCPIP_HLEN + UIP_LLH_LEN + 2 + c] << 8) |
2739 + uip_buf[UIP_TCPIP_HLEN + UIP_LLH_LEN + 3 + c];
2740 + uip_connr->initialmss =
2741 + uip_connr->mss = tmp16 > UIP_TCP_MSS? UIP_TCP_MSS: tmp16;
2742 +
2743 + /* And we are done processing options. */
2744 + break;
2745 + } else {
2746 + /* All other options have a length field, so that we easily
2747 + can skip past them. */
2748 + if(uip_buf[UIP_TCPIP_HLEN + UIP_LLH_LEN + 1 + c] == 0) {
2749 + /* If the length field is zero, the options are malformed
2750 + and we don't process them further. */
2751 + break;
2752 + }
2753 + c += uip_buf[UIP_TCPIP_HLEN + UIP_LLH_LEN + 1 + c];
2754 + }
2755 + }
2756 + }
2757 + uip_connr->tcpstateflags = ESTABLISHED;
2758 + uip_connr->rcv_nxt[0] = BUF->seqno[0];
2759 + uip_connr->rcv_nxt[1] = BUF->seqno[1];
2760 + uip_connr->rcv_nxt[2] = BUF->seqno[2];
2761 + uip_connr->rcv_nxt[3] = BUF->seqno[3];
2762 + uip_add_rcv_nxt(1);
2763 + uip_flags = UIP_CONNECTED | UIP_NEWDATA;
2764 + uip_connr->len = 0;
2765 + uip_len = 0;
2766 + uip_slen = 0;
2767 + UIP_APPCALL();
2768 + goto appsend;
2769 + }
2770 + goto reset;
2771 +#endif /* UIP_ACTIVE_OPEN */
2772 +
2773 + case ESTABLISHED:
2774 + /* In the ESTABLISHED state, we call upon the application to feed
2775 + data into the uip_buf. If the UIP_ACKDATA flag is set, the
2776 + application should put new data into the buffer, otherwise we are
2777 + retransmitting an old segment, and the application should put that
2778 + data into the buffer.
2779 +
2780 + If the incoming packet is a FIN, we should close the connection on
2781 + this side as well, and we send out a FIN and enter the LAST_ACK
2782 + state. We require that there is no outstanding data; otherwise the
2783 + sequence numbers will be screwed up. */
2784 +
2785 + if(BUF->flags & TCP_FIN) {
2786 + if(uip_outstanding(uip_connr)) {
2787 + goto drop;
2788 + }
2789 + uip_add_rcv_nxt(1 + uip_len);
2790 + uip_flags = UIP_CLOSE;
2791 + if(uip_len > 0) {
2792 + uip_flags |= UIP_NEWDATA;
2793 + }
2794 + UIP_APPCALL();
2795 + uip_connr->len = 1;
2796 + uip_connr->tcpstateflags = LAST_ACK;
2797 + uip_connr->nrtx = 0;
2798 + tcp_send_finack:
2799 + BUF->flags = TCP_FIN | TCP_ACK;
2800 + goto tcp_send_nodata;
2801 + }
2802 +
2803 + /* Check the URG flag. If this is set, the segment carries urgent
2804 + data that we must pass to the application. */
2805 + if(BUF->flags & TCP_URG) {
2806 +#if UIP_URGDATA > 0
2807 + uip_urglen = (BUF->urgp[0] << 8) | BUF->urgp[1];
2808 + if(uip_urglen > uip_len) {
2809 + /* There is more urgent data in the next segment to come. */
2810 + uip_urglen = uip_len;
2811 + }
2812 + uip_add_rcv_nxt(uip_urglen);
2813 + uip_len -= uip_urglen;
2814 + uip_urgdata = uip_appdata;
2815 + uip_appdata += uip_urglen;
2816 + } else {
2817 + uip_urglen = 0;
2818 +#endif /* UIP_URGDATA > 0 */
2819 + uip_appdata += (BUF->urgp[0] << 8) | BUF->urgp[1];
2820 + uip_len -= (BUF->urgp[0] << 8) | BUF->urgp[1];
2821 + }
2822 +
2823 +
2824 + /* If uip_len > 0 we have TCP data in the packet, and we flag this
2825 + by setting the UIP_NEWDATA flag and update the sequence number
2826 + we acknowledge. If the application has stopped the dataflow
2827 + using uip_stop(), we must not accept any data packets from the
2828 + remote host. */
2829 + if(uip_len > 0 && !(uip_connr->tcpstateflags & UIP_STOPPED)) {
2830 + uip_flags |= UIP_NEWDATA;
2831 + uip_add_rcv_nxt(uip_len);
2832 + }
2833 +
2834 + /* Check if the available buffer space advertised by the other end
2835 + is smaller than the initial MSS for this connection. If so, we
2836 + set the current MSS to the window size to ensure that the
2837 + application does not send more data than the other end can
2838 + handle.
2839 +
2840 + If the remote host advertises a zero window, we set the MSS to
2841 + the initial MSS so that the application will send an entire MSS
2842 + of data. This data will not be acknowledged by the receiver,
2843 + and the application will retransmit it. This is called the
2844 + "persistent timer" and uses the retransmission mechanim.
2845 + */
2846 + tmp16 = ((unsigned short int)BUF->wnd[0] << 8) + (unsigned short int)BUF->wnd[1];
2847 + if(tmp16 > uip_connr->initialmss ||
2848 + tmp16 == 0) {
2849 + tmp16 = uip_connr->initialmss;
2850 + }
2851 + uip_connr->mss = tmp16;
2852 +
2853 + /* If this packet constitutes an ACK for outstanding data (flagged
2854 + by the UIP_ACKDATA flag, we should call the application since it
2855 + might want to send more data. If the incoming packet had data
2856 + from the peer (as flagged by the UIP_NEWDATA flag), the
2857 + application must also be notified.
2858 +
2859 + When the application is called, the global variable uip_len
2860 + contains the length of the incoming data. The application can
2861 + access the incoming data through the global pointer
2862 + uip_appdata, which usually points 40 bytes into the uip_buf
2863 + array.
2864 +
2865 + If the application wishes to send any data, this data should be
2866 + put into the uip_appdata and the length of the data should be
2867 + put into uip_len. If the application don't have any data to
2868 + send, uip_len must be set to 0. */
2869 + if(uip_flags & (UIP_NEWDATA | UIP_ACKDATA)) {
2870 + uip_slen = 0;
2871 + UIP_APPCALL();
2872 +
2873 + appsend:
2874 +
2875 + if(uip_flags & UIP_ABORT) {
2876 + uip_slen = 0;
2877 + uip_connr->tcpstateflags = CLOSED;
2878 + BUF->flags = TCP_RST | TCP_ACK;
2879 + goto tcp_send_nodata;
2880 + }
2881 +
2882 + if(uip_flags & UIP_CLOSE) {
2883 + uip_slen = 0;
2884 + uip_connr->len = 1;
2885 + uip_connr->tcpstateflags = FIN_WAIT_1;
2886 + uip_connr->nrtx = 0;
2887 + BUF->flags = TCP_FIN | TCP_ACK;
2888 + goto tcp_send_nodata;
2889 + }
2890 +
2891 + /* If uip_slen > 0, the application has data to be sent. */
2892 + if(uip_slen > 0) {
2893 +
2894 + /* If the connection has acknowledged data, the contents of
2895 + the ->len variable should be discarded. */
2896 + if((uip_flags & UIP_ACKDATA) != 0) {
2897 + uip_connr->len = 0;
2898 + }
2899 +
2900 + /* If the ->len variable is non-zero the connection has
2901 + already data in transit and cannot send anymore right
2902 + now. */
2903 + if(uip_connr->len == 0) {
2904 +
2905 + /* The application cannot send more than what is allowed by
2906 + the mss (the minumum of the MSS and the available
2907 + window). */
2908 + if(uip_slen > uip_connr->mss) {
2909 + uip_slen = uip_connr->mss;
2910 + }
2911 +
2912 + /* Remember how much data we send out now so that we know
2913 + when everything has been acknowledged. */
2914 + uip_connr->len = uip_slen;
2915 + } else {
2916 +
2917 + /* If the application already had unacknowledged data, we
2918 + make sure that the application does not send (i.e.,
2919 + retransmit) out more than it previously sent out. */
2920 + uip_slen = uip_connr->len;
2921 + }
2922 + } else {
2923 + uip_connr->len = 0;
2924 + }
2925 + uip_connr->nrtx = 0;
2926 + apprexmit:
2927 + uip_appdata = uip_sappdata;
2928 +
2929 + /* If the application has data to be sent, or if the incoming
2930 + packet had new data in it, we must send out a packet. */
2931 + if(uip_slen > 0 && uip_connr->len > 0) {
2932 + /* Add the length of the IP and TCP headers. */
2933 + uip_len = uip_connr->len + UIP_TCPIP_HLEN;
2934 + /* We always set the ACK flag in response packets. */
2935 + BUF->flags = TCP_ACK | TCP_PSH;
2936 + /* Send the packet. */
2937 + goto tcp_send_noopts;
2938 + }
2939 + /* If there is no data to send, just send out a pure ACK if
2940 + there is newdata. */
2941 + if(uip_flags & UIP_NEWDATA) {
2942 + uip_len = UIP_TCPIP_HLEN;
2943 + BUF->flags = TCP_ACK;
2944 + goto tcp_send_noopts;
2945 + }
2946 + }
2947 + goto drop;
2948 + case LAST_ACK:
2949 + /* We can close this connection if the peer has acknowledged our
2950 + FIN. This is indicated by the UIP_ACKDATA flag. */
2951 + if(uip_flags & UIP_ACKDATA) {
2952 + uip_connr->tcpstateflags = CLOSED;
2953 + uip_flags = UIP_CLOSE;
2954 + UIP_APPCALL();
2955 + }
2956 + break;
2957 +
2958 + case FIN_WAIT_1:
2959 + /* The application has closed the connection, but the remote host
2960 + hasn't closed its end yet. Thus we do nothing but wait for a
2961 + FIN from the other side. */
2962 + if(uip_len > 0) {
2963 + uip_add_rcv_nxt(uip_len);
2964 + }
2965 + if(BUF->flags & TCP_FIN) {
2966 + if(uip_flags & UIP_ACKDATA) {
2967 + uip_connr->tcpstateflags = TIME_WAIT;
2968 + uip_connr->timer = 0;
2969 + uip_connr->len = 0;
2970 + } else {
2971 + uip_connr->tcpstateflags = CLOSING;
2972 + }
2973 + uip_add_rcv_nxt(1);
2974 + uip_flags = UIP_CLOSE;
2975 + UIP_APPCALL();
2976 + goto tcp_send_ack;
2977 + } else if(uip_flags & UIP_ACKDATA) {
2978 + uip_connr->tcpstateflags = FIN_WAIT_2;
2979 + uip_connr->len = 0;
2980 + goto drop;
2981 + }
2982 + if(uip_len > 0) {
2983 + goto tcp_send_ack;
2984 + }
2985 + goto drop;
2986 +
2987 + case FIN_WAIT_2:
2988 + if(uip_len > 0) {
2989 + uip_add_rcv_nxt(uip_len);
2990 + }
2991 + if(BUF->flags & TCP_FIN) {
2992 + uip_connr->tcpstateflags = TIME_WAIT;
2993 + uip_connr->timer = 0;
2994 + uip_add_rcv_nxt(1);
2995 + uip_flags = UIP_CLOSE;
2996 + UIP_APPCALL();
2997 + goto tcp_send_ack;
2998 + }
2999 + if(uip_len > 0) {
3000 + goto tcp_send_ack;
3001 + }
3002 + goto drop;
3003 +
3004 + case TIME_WAIT:
3005 + goto tcp_send_ack;
3006 +
3007 + case CLOSING:
3008 + if(uip_flags & UIP_ACKDATA) {
3009 + uip_connr->tcpstateflags = TIME_WAIT;
3010 + uip_connr->timer = 0;
3011 + }
3012 + }
3013 + goto drop;
3014 +
3015 +
3016 + /* We jump here when we are ready to send the packet, and just want
3017 + to set the appropriate TCP sequence numbers in the TCP header. */
3018 + tcp_send_ack:
3019 + BUF->flags = TCP_ACK;
3020 + tcp_send_nodata:
3021 + uip_len = 40;
3022 + tcp_send_noopts:
3023 + BUF->tcpoffset = 5 << 4;
3024 + tcp_send:
3025 + /* We're done with the input processing. We are now ready to send a
3026 + reply. Our job is to fill in all the fields of the TCP and IP
3027 + headers before calculating the checksum and finally send the
3028 + packet. */
3029 + BUF->ackno[0] = uip_connr->rcv_nxt[0];
3030 + BUF->ackno[1] = uip_connr->rcv_nxt[1];
3031 + BUF->ackno[2] = uip_connr->rcv_nxt[2];
3032 + BUF->ackno[3] = uip_connr->rcv_nxt[3];
3033 +
3034 + BUF->seqno[0] = uip_connr->snd_nxt[0];
3035 + BUF->seqno[1] = uip_connr->snd_nxt[1];
3036 + BUF->seqno[2] = uip_connr->snd_nxt[2];
3037 + BUF->seqno[3] = uip_connr->snd_nxt[3];
3038 +
3039 + BUF->proto = UIP_PROTO_TCP;
3040 +
3041 + BUF->srcport = uip_connr->lport;
3042 + BUF->destport = uip_connr->rport;
3043 +
3044 + BUF->srcipaddr[0] = uip_hostaddr[0];
3045 + BUF->srcipaddr[1] = uip_hostaddr[1];
3046 + BUF->destipaddr[0] = uip_connr->ripaddr[0];
3047 + BUF->destipaddr[1] = uip_connr->ripaddr[1];
3048 +
3049 +
3050 + if(uip_connr->tcpstateflags & UIP_STOPPED) {
3051 + /* If the connection has issued uip_stop(), we advertise a zero
3052 + window so that the remote host will stop sending data. */
3053 + BUF->wnd[0] = BUF->wnd[1] = 0;
3054 + } else {
3055 + BUF->wnd[0] = ((UIP_RECEIVE_WINDOW) >> 8);
3056 + BUF->wnd[1] = ((UIP_RECEIVE_WINDOW) & 0xff);
3057 + }
3058 +
3059 + tcp_send_noconn:
3060 +
3061 + BUF->len[0] = (uip_len >> 8);
3062 + BUF->len[1] = (uip_len & 0xff);
3063 +
3064 + /* Calculate TCP checksum. */
3065 + BUF->tcpchksum = 0;
3066 + BUF->tcpchksum = ~(uip_tcpchksum());
3067 +
3068 + //ip_send_nolen:
3069 +
3070 + BUF->vhl = 0x45;
3071 + BUF->tos = 0;
3072 + BUF->ipoffset[0] = BUF->ipoffset[1] = 0;
3073 + BUF->ttl = UIP_TTL;
3074 + ++ipid;
3075 + BUF->ipid[0] = ipid >> 8;
3076 + BUF->ipid[1] = ipid & 0xff;
3077 +
3078 + /* Calculate IP checksum. */
3079 + BUF->ipchksum = 0;
3080 + BUF->ipchksum = ~(uip_ipchksum());
3081 +
3082 + UIP_STAT(++uip_stat.tcp.sent);
3083 + send:
3084 + UIP_STAT(++uip_stat.ip.sent);
3085 + /* Return and let the caller do the actual transmission. */
3086 + return;
3087 + drop:
3088 + uip_len = 0;
3089 + return;
3090 +}
3091 +/*-----------------------------------------------------------------------------------*/
3092 +/*unsigned short int
3093 +htons(unsigned short int val)
3094 +{
3095 + return HTONS(val);
3096 +}*/
3097 +/*-----------------------------------------------------------------------------------*/
3098 +/** @} */
3099 --- /dev/null
3100 +++ b/net/uip-0.9/uip.h
3101 @@ -0,0 +1,1066 @@
3102 +/**
3103 + * \addtogroup uip
3104 + * @{
3105 + */
3106 +
3107 +/**
3108 + * \file
3109 + * Header file for the uIP TCP/IP stack.
3110 + * \author Adam Dunkels <adam@dunkels.com>
3111 + *
3112 + * The uIP TCP/IP stack header file contains definitions for a number
3113 + * of C macros that are used by uIP programs as well as internal uIP
3114 + * structures, TCP/IP header structures and function declarations.
3115 + *
3116 + */
3117 +
3118 +
3119 +/*
3120 + * Copyright (c) 2001-2003, Adam Dunkels.
3121 + * All rights reserved.
3122 + *
3123 + * Redistribution and use in source and binary forms, with or without
3124 + * modification, are permitted provided that the following conditions
3125 + * are met:
3126 + * 1. Redistributions of source code must retain the above copyright
3127 + * notice, this list of conditions and the following disclaimer.
3128 + * 2. Redistributions in binary form must reproduce the above copyright
3129 + * notice, this list of conditions and the following disclaimer in the
3130 + * documentation and/or other materials provided with the distribution.
3131 + * 3. The name of the author may not be used to endorse or promote
3132 + * products derived from this software without specific prior
3133 + * written permission.
3134 + *
3135 + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS
3136 + * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
3137 + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
3138 + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
3139 + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
3140 + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
3141 + * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
3142 + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
3143 + * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
3144 + * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
3145 + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
3146 + *
3147 + * This file is part of the uIP TCP/IP stack.
3148 + *
3149 + * $Id: uip.h,v 1.36.2.7 2003/10/07 13:47:51 adam Exp $
3150 + *
3151 + */
3152 +
3153 +#ifndef __UIP_H__
3154 +#define __UIP_H__
3155 +#include <linux/types.h>
3156 +#include <linux/string.h>
3157 +#include <linux/ctype.h>
3158 +#include <malloc.h>
3159 +#include <common.h>
3160 +
3161 +
3162 +#include "uipopt.h"
3163 +
3164 +/*-----------------------------------------------------------------------------------*/
3165 +/* First, the functions that should be called from the
3166 + * system. Initialization, the periodic timer and incoming packets are
3167 + * handled by the following three functions.
3168 + */
3169 +
3170 +/**
3171 + * \defgroup uipconffunc uIP configuration functions
3172 + * @{
3173 + *
3174 + * The uIP configuration functions are used for setting run-time
3175 + * parameters in uIP such as IP addresses.
3176 + */
3177 +
3178 +/**
3179 + * Set the IP address of this host.
3180 + *
3181 + * The IP address is represented as a 4-byte array where the first
3182 + * octet of the IP address is put in the first member of the 4-byte
3183 + * array.
3184 + *
3185 + * \param addr A pointer to a 4-byte representation of the IP address.
3186 + *
3187 + * \hideinitializer
3188 + */
3189 +#define uip_sethostaddr(addr) do { uip_hostaddr[0] = addr[0]; \
3190 + uip_hostaddr[1] = addr[1]; } while(0)
3191 +
3192 +/**
3193 + * Get the IP address of this host.
3194 + *
3195 + * The IP address is represented as a 4-byte array where the first
3196 + * octet of the IP address is put in the first member of the 4-byte
3197 + * array.
3198 + *
3199 + * \param addr A pointer to a 4-byte array that will be filled in with
3200 + * the currently configured IP address.
3201 + *
3202 + * \hideinitializer
3203 + */
3204 +#define uip_gethostaddr(addr) do { addr[0] = uip_hostaddr[0]; \
3205 + addr[1] = uip_hostaddr[1]; } while(0)
3206 +
3207 +/** @} */
3208 +
3209 +/**
3210 + * \defgroup uipinit uIP initialization functions
3211 + * @{
3212 + *
3213 + * The uIP initialization functions are used for booting uIP.
3214 + */
3215 +
3216 +/**
3217 + * uIP initialization function.
3218 + *
3219 + * This function should be called at boot up to initilize the uIP
3220 + * TCP/IP stack.
3221 + */
3222 +void uip_init(void);
3223 +
3224 +/** @} */
3225 +
3226 +/**
3227 + * \defgroup uipdevfunc uIP device driver functions
3228 + * @{
3229 + *
3230 + * These functions are used by a network device driver for interacting
3231 + * with uIP.
3232 + */
3233 +
3234 +/**
3235 + * Process an incoming packet.
3236 + *
3237 + * This function should be called when the device driver has received
3238 + * a packet from the network. The packet from the device driver must
3239 + * be present in the uip_buf buffer, and the length of the packet
3240 + * should be placed in the uip_len variable.
3241 + *
3242 + * When the function returns, there may be an outbound packet placed
3243 + * in the uip_buf packet buffer. If so, the uip_len variable is set to
3244 + * the length of the packet. If no packet is to be sent out, the
3245 + * uip_len variable is set to 0.
3246 + *
3247 + * The usual way of calling the function is presented by the source
3248 + * code below.
3249 + \code
3250 + uip_len = devicedriver_poll();
3251 + if(uip_len > 0) {
3252 + uip_input();
3253 + if(uip_len > 0) {
3254 + devicedriver_send();
3255 + }
3256 + }
3257 + \endcode
3258 + *
3259 + * \note If you are writing a uIP device driver that needs ARP
3260 + * (Address Resolution Protocol), e.g., when running uIP over
3261 + * Ethernet, you will need to call the uIP ARP code before calling
3262 + * this function:
3263 + \code
3264 + #define BUF ((struct uip_eth_hdr *)&uip_buf[0])
3265 + uip_len = ethernet_devicedrver_poll();
3266 + if(uip_len > 0) {
3267 + if(BUF->type == HTONS(UIP_ETHTYPE_IP)) {
3268 + uip_arp_ipin();
3269 + uip_input();
3270 + if(uip_len > 0) {
3271 + uip_arp_out();
3272 + ethernet_devicedriver_send();
3273 + }
3274 + } else if(BUF->type == HTONS(UIP_ETHTYPE_ARP)) {
3275 + uip_arp_arpin();
3276 + if(uip_len > 0) {
3277 + ethernet_devicedriver_send();
3278 + }
3279 + }
3280 + \endcode
3281 + *
3282 + * \hideinitializer
3283 + */
3284 +#define uip_input() uip_process(UIP_DATA)
3285 +
3286 +/**
3287 + * Periodic processing for a connection identified by its number.
3288 + *
3289 + * This function does the necessary periodic processing (timers,
3290 + * polling) for a uIP TCP conneciton, and should be called when the
3291 + * periodic uIP timer goes off. It should be called for every
3292 + * connection, regardless of whether they are open of closed.
3293 + *
3294 + * When the function returns, it may have an outbound packet waiting
3295 + * for service in the uIP packet buffer, and if so the uip_len
3296 + * variable is set to a value larger than zero. The device driver
3297 + * should be called to send out the packet.
3298 + *
3299 + * The ususal way of calling the function is through a for() loop like
3300 + * this:
3301 + \code
3302 + for(i = 0; i < UIP_CONNS; ++i) {
3303 + uip_periodic(i);
3304 + if(uip_len > 0) {
3305 + devicedriver_send();
3306 + }
3307 + }
3308 + \endcode
3309 + *
3310 + * \note If you are writing a uIP device driver that needs ARP
3311 + * (Address Resolution Protocol), e.g., when running uIP over
3312 + * Ethernet, you will need to call the uip_arp_out() function before
3313 + * calling the device driver:
3314 + \code
3315 + for(i = 0; i < UIP_CONNS; ++i) {
3316 + uip_periodic(i);
3317 + if(uip_len > 0) {
3318 + uip_arp_out();
3319 + ethernet_devicedriver_send();
3320 + }
3321 + }
3322 + \endcode
3323 + *
3324 + * \param conn The number of the connection which is to be periodically polled.
3325 + *
3326 + * \hideinitializer
3327 + */
3328 +#define uip_periodic(conn) do { uip_conn = &uip_conns[conn]; \
3329 + uip_process(UIP_TIMER); } while (0)
3330 +
3331 +/**
3332 + * Periodic processing for a connection identified by a pointer to its structure.
3333 + *
3334 + * Same as uip_periodic() but takes a pointer to the actual uip_conn
3335 + * struct instead of an integer as its argument. This function can be
3336 + * used to force periodic processing of a specific connection.
3337 + *
3338 + * \param conn A pointer to the uip_conn struct for the connection to
3339 + * be processed.
3340 + *
3341 + * \hideinitializer
3342 + */
3343 +#define uip_periodic_conn(conn) do { uip_conn = conn; \
3344 + uip_process(UIP_TIMER); } while (0)
3345 +
3346 +#if UIP_UDP
3347 +/**
3348 + * Periodic processing for a UDP connection identified by its number.
3349 + *
3350 + * This function is essentially the same as uip_prerioic(), but for
3351 + * UDP connections. It is called in a similar fashion as the
3352 + * uip_periodic() function:
3353 + \code
3354 + for(i = 0; i < UIP_UDP_CONNS; i++) {
3355 + uip_udp_periodic(i);
3356 + if(uip_len > 0) {
3357 + devicedriver_send();
3358 + }
3359 + }
3360 + \endcode
3361 + *
3362 + * \note As for the uip_periodic() function, special care has to be
3363 + * taken when using uIP together with ARP and Ethernet:
3364 + \code
3365 + for(i = 0; i < UIP_UDP_CONNS; i++) {
3366 + uip_udp_periodic(i);
3367 + if(uip_len > 0) {
3368 + uip_arp_out();
3369 + ethernet_devicedriver_send();
3370 + }
3371 + }
3372 + \endcode
3373 + *
3374 + * \param conn The number of the UDP connection to be processed.
3375 + *
3376 + * \hideinitializer
3377 + */
3378 +#define uip_udp_periodic(conn) do { uip_udp_conn = &uip_udp_conns[conn]; \
3379 + uip_process(UIP_UDP_TIMER); } while (0)
3380 +
3381 +/**
3382 + * Periodic processing for a UDP connection identified by a pointer to
3383 + * its structure.
3384 + *
3385 + * Same as uip_udp_periodic() but takes a pointer to the actual
3386 + * uip_conn struct instead of an integer as its argument. This
3387 + * function can be used to force periodic processing of a specific
3388 + * connection.
3389 + *
3390 + * \param conn A pointer to the uip_udp_conn struct for the connection
3391 + * to be processed.
3392 + *
3393 + * \hideinitializer
3394 + */
3395 +#define uip_udp_periodic_conn(conn) do { uip_udp_conn = conn; \
3396 + uip_process(UIP_UDP_TIMER); } while (0)
3397 +
3398 +
3399 +#endif /* UIP_UDP */
3400 +
3401 +/**
3402 + * The uIP packet buffer.
3403 + *
3404 + * The uip_buf array is used to hold incoming and outgoing
3405 + * packets. The device driver should place incoming data into this
3406 + * buffer. When sending data, the device driver should read the link
3407 + * level headers and the TCP/IP headers from this buffer. The size of
3408 + * the link level headers is configured by the UIP_LLH_LEN define.
3409 + *
3410 + * \note The application data need not be placed in this buffer, so
3411 + * the device driver must read it from the place pointed to by the
3412 + * uip_appdata pointer as illustrated by the following example:
3413 + \code
3414 + void
3415 + devicedriver_send(void)
3416 + {
3417 + hwsend(&uip_buf[0], UIP_LLH_LEN);
3418 + hwsend(&uip_buf[UIP_LLH_LEN], 40);
3419 + hwsend(uip_appdata, uip_len - 40 - UIP_LLH_LEN);
3420 + }
3421 + \endcode
3422 + */
3423 +extern u8_t uip_buf[UIP_BUFSIZE+2];
3424 +
3425 +/** @} */
3426 +
3427 +/*-----------------------------------------------------------------------------------*/
3428 +/* Functions that are used by the uIP application program. Opening and
3429 + * closing connections, sending and receiving data, etc. is all
3430 + * handled by the functions below.
3431 +*/
3432 +/**
3433 + * \defgroup uipappfunc uIP application functions
3434 + * @{
3435 + *
3436 + * Functions used by an application running of top of uIP.
3437 + */
3438 +
3439 +/**
3440 + * Start listening to the specified port.
3441 + *
3442 + * \note Since this function expects the port number in network byte
3443 + * order, a conversion using HTONS() or htons() is necessary.
3444 + *
3445 + \code
3446 + uip_listen(HTONS(80));
3447 + \endcode
3448 + *
3449 + * \param port A 16-bit port number in network byte order.
3450 + */
3451 +void uip_listen(u16_t port);
3452 +
3453 +/**
3454 + * Stop listening to the specified port.
3455 + *
3456 + * \note Since this function expects the port number in network byte
3457 + * order, a conversion using HTONS() or htons() is necessary.
3458 + *
3459 + \code
3460 + uip_unlisten(HTONS(80));
3461 + \endcode
3462 + *
3463 + * \param port A 16-bit port number in network byte order.
3464 + */
3465 +void uip_unlisten(u16_t port);
3466 +
3467 +/**
3468 + * Connect to a remote host using TCP.
3469 + *
3470 + * This function is used to start a new connection to the specified
3471 + * port on the specied host. It allocates a new connection identifier,
3472 + * sets the connection to the SYN_SENT state and sets the
3473 + * retransmission timer to 0. This will cause a TCP SYN segment to be
3474 + * sent out the next time this connection is periodically processed,
3475 + * which usually is done within 0.5 seconds after the call to
3476 + * uip_connect().
3477 + *
3478 + * \note This function is avaliable only if support for active open
3479 + * has been configured by defining UIP_ACTIVE_OPEN to 1 in uipopt.h.
3480 + *
3481 + * \note Since this function requires the port number to be in network
3482 + * byte order, a convertion using HTONS() or htons() is necessary.
3483 + *
3484 + \code
3485 + u16_t ipaddr[2];
3486 +
3487 + uip_ipaddr(ipaddr, 192,168,1,2);
3488 + uip_connect(ipaddr, HTONS(80));
3489 + \endcode
3490 + *
3491 + * \param ripaddr A pointer to a 4-byte array representing the IP
3492 + * address of the remote hot.
3493 + *
3494 + * \param port A 16-bit port number in network byte order.
3495 + *
3496 + * \return A pointer to the uIP connection identifier for the new connection,
3497 + * or NULL if no connection could be allocated.
3498 + *
3499 + */
3500 +struct uip_conn *uip_connect(u16_t *ripaddr, u16_t port);
3501 +
3502 +
3503 +
3504 +/**
3505 + * \internal
3506 + *
3507 + * Check if a connection has outstanding (i.e., unacknowledged) data.
3508 + *
3509 + * \param conn A pointer to the uip_conn structure for the connection.
3510 + *
3511 + * \hideinitializer
3512 + */
3513 +#define uip_outstanding(conn) ((conn)->len)
3514 +
3515 +/**
3516 + * Send data on the current connection.
3517 + *
3518 + * This function is used to send out a single segment of TCP
3519 + * data. Only applications that have been invoked by uIP for event
3520 + * processing can send data.
3521 + *
3522 + * The amount of data that actually is sent out after a call to this
3523 + * funcion is determined by the maximum amount of data TCP allows. uIP
3524 + * will automatically crop the data so that only the appropriate
3525 + * amount of data is sent. The function uip_mss() can be used to query
3526 + * uIP for the amount of data that actually will be sent.
3527 + *
3528 + * \note This function does not guarantee that the sent data will
3529 + * arrive at the destination. If the data is lost in the network, the
3530 + * application will be invoked with the uip_rexmit() event being
3531 + * set. The application will then have to resend the data using this
3532 + * function.
3533 + *
3534 + * \param data A pointer to the data which is to be sent.
3535 + *
3536 + * \param len The maximum amount of data bytes to be sent.
3537 + *
3538 + * \hideinitializer
3539 + */
3540 +#define uip_send(data, len) do { uip_sappdata = (data); uip_slen = (len);} while(0)
3541 +
3542 +/**
3543 + * The length of any incoming data that is currently avaliable (if avaliable)
3544 + * in the uip_appdata buffer.
3545 + *
3546 + * The test function uip_data() must first be used to check if there
3547 + * is any data available at all.
3548 + *
3549 + * \hideinitializer
3550 + */
3551 +#define uip_datalen() uip_len
3552 +
3553 +/**
3554 + * The length of any out-of-band data (urgent data) that has arrived
3555 + * on the connection.
3556 + *
3557 + * \note The configuration parameter UIP_URGDATA must be set for this
3558 + * function to be enabled.
3559 + *
3560 + * \hideinitializer
3561 + */
3562 +#define uip_urgdatalen() uip_urglen
3563 +
3564 +/**
3565 + * Close the current connection.
3566 + *
3567 + * This function will close the current connection in a nice way.
3568 + *
3569 + * \hideinitializer
3570 + */
3571 +#define uip_close() (uip_flags = UIP_CLOSE)
3572 +
3573 +/**
3574 + * Abort the current connection.
3575 + *
3576 + * This function will abort (reset) the current connection, and is
3577 + * usually used when an error has occured that prevents using the
3578 + * uip_close() function.
3579 + *
3580 + * \hideinitializer
3581 + */
3582 +#define uip_abort() (uip_flags = UIP_ABORT)
3583 +
3584 +/**
3585 + * Tell the sending host to stop sending data.
3586 + *
3587 + * This function will close our receiver's window so that we stop
3588 + * receiving data for the current connection.
3589 + *
3590 + * \hideinitializer
3591 + */
3592 +#define uip_stop() (uip_conn->tcpstateflags |= UIP_STOPPED)
3593 +
3594 +/**
3595 + * Find out if the current connection has been previously stopped with
3596 + * uip_stop().
3597 + *
3598 + * \hideinitializer
3599 + */
3600 +#define uip_stopped(conn) ((conn)->tcpstateflags & UIP_STOPPED)
3601 +
3602 +/**
3603 + * Restart the current connection, if is has previously been stopped
3604 + * with uip_stop().
3605 + *
3606 + * This function will open the receiver's window again so that we
3607 + * start receiving data for the current connection.
3608 + *
3609 + * \hideinitializer
3610 + */
3611 +#define uip_restart() do { uip_flags |= UIP_NEWDATA; \
3612 + uip_conn->tcpstateflags &= ~UIP_STOPPED; \
3613 + } while(0)
3614 +
3615 +
3616 +/* uIP tests that can be made to determine in what state the current
3617 + connection is, and what the application function should do. */
3618 +
3619 +/**
3620 + * Is new incoming data available?
3621 + *
3622 + * Will reduce to non-zero if there is new data for the application
3623 + * present at the uip_appdata pointer. The size of the data is
3624 + * avaliable through the uip_len variable.
3625 + *
3626 + * \hideinitializer
3627 + */
3628 +#define uip_newdata() (uip_flags & UIP_NEWDATA)
3629 +
3630 +/**
3631 + * Has previously sent data been acknowledged?
3632 + *
3633 + * Will reduce to non-zero if the previously sent data has been
3634 + * acknowledged by the remote host. This means that the application
3635 + * can send new data.
3636 + *
3637 + * \hideinitializer
3638 + */
3639 +#define uip_acked() (uip_flags & UIP_ACKDATA)
3640 +
3641 +/**
3642 + * Has the connection just been connected?
3643 + *
3644 + * Reduces to non-zero if the current connection has been connected to
3645 + * a remote host. This will happen both if the connection has been
3646 + * actively opened (with uip_connect()) or passively opened (with
3647 + * uip_listen()).
3648 + *
3649 + * \hideinitializer
3650 + */
3651 +#define uip_connected() (uip_flags & UIP_CONNECTED)
3652 +
3653 +/**
3654 + * Has the connection been closed by the other end?
3655 + *
3656 + * Is non-zero if the connection has been closed by the remote
3657 + * host. The application may then do the necessary clean-ups.
3658 + *
3659 + * \hideinitializer
3660 + */
3661 +#define uip_closed() (uip_flags & UIP_CLOSE)
3662 +
3663 +/**
3664 + * Has the connection been aborted by the other end?
3665 + *
3666 + * Non-zero if the current connection has been aborted (reset) by the
3667 + * remote host.
3668 + *
3669 + * \hideinitializer
3670 + */
3671 +#define uip_aborted() (uip_flags & UIP_ABORT)
3672 +
3673 +/**
3674 + * Has the connection timed out?
3675 + *
3676 + * Non-zero if the current connection has been aborted due to too many
3677 + * retransmissions.
3678 + *
3679 + * \hideinitializer
3680 + */
3681 +#define uip_timedout() (uip_flags & UIP_TIMEDOUT)
3682 +
3683 +/**
3684 + * Do we need to retransmit previously data?
3685 + *
3686 + * Reduces to non-zero if the previously sent data has been lost in
3687 + * the network, and the application should retransmit it. The
3688 + * application should send the exact same data as it did the last
3689 + * time, using the uip_send() function.
3690 + *
3691 + * \hideinitializer
3692 + */
3693 +#define uip_rexmit() (uip_flags & UIP_REXMIT)
3694 +
3695 +/**
3696 + * Is the connection being polled by uIP?
3697 + *
3698 + * Is non-zero if the reason the application is invoked is that the
3699 + * current connection has been idle for a while and should be
3700 + * polled.
3701 + *
3702 + * The polling event can be used for sending data without having to
3703 + * wait for the remote host to send data.
3704 + *
3705 + * \hideinitializer
3706 + */
3707 +#define uip_poll() (uip_flags & UIP_POLL)
3708 +
3709 +/**
3710 + * Get the initial maxium segment size (MSS) of the current
3711 + * connection.
3712 + *
3713 + * \hideinitializer
3714 + */
3715 +#define uip_initialmss() (uip_conn->initialmss)
3716 +
3717 +/**
3718 + * Get the current maxium segment size that can be sent on the current
3719 + * connection.
3720 + *
3721 + * The current maxiumum segment size that can be sent on the
3722 + * connection is computed from the receiver's window and the MSS of
3723 + * the connection (which also is available by calling
3724 + * uip_initialmss()).
3725 + *
3726 + * \hideinitializer
3727 + */
3728 +#define uip_mss() (uip_conn->mss)
3729 +
3730 +/**
3731 + * Set up a new UDP connection.
3732 + *
3733 + * \param ripaddr A pointer to a 4-byte structure representing the IP
3734 + * address of the remote host.
3735 + *
3736 + * \param rport The remote port number in network byte order.
3737 + *
3738 + * \return The uip_udp_conn structure for the new connection or NULL
3739 + * if no connection could be allocated.
3740 + */
3741 +struct uip_udp_conn *uip_udp_new(u16_t *ripaddr, u16_t rport);
3742 +
3743 +/**
3744 + * Removed a UDP connection.
3745 + *
3746 + * \param conn A pointer to the uip_udp_conn structure for the connection.
3747 + *
3748 + * \hideinitializer
3749 + */
3750 +#define uip_udp_remove(conn) (conn)->lport = 0
3751 +
3752 +/**
3753 + * Send a UDP datagram of length len on the current connection.
3754 + *
3755 + * This function can only be called in response to a UDP event (poll
3756 + * or newdata). The data must be present in the uip_buf buffer, at the
3757 + * place pointed to by the uip_appdata pointer.
3758 + *
3759 + * \param len The length of the data in the uip_buf buffer.
3760 + *
3761 + * \hideinitializer
3762 + */
3763 +#define uip_udp_send(len) uip_slen = (len)
3764 +
3765 +/** @} */
3766 +
3767 +/* uIP convenience and converting functions. */
3768 +
3769 +/**
3770 + * \defgroup uipconvfunc uIP conversion functions
3771 + * @{
3772 + *
3773 + * These functions can be used for converting between different data
3774 + * formats used by uIP.
3775 + */
3776 +
3777 +/**
3778 + * Pack an IP address into a 4-byte array which is used by uIP to
3779 + * represent IP addresses.
3780 + *
3781 + * Example:
3782 + \code
3783 + u16_t ipaddr[2];
3784 +
3785 + uip_ipaddr(&ipaddr, 192,168,1,2);
3786 + \endcode
3787 + *
3788 + * \param addr A pointer to a 4-byte array that will be filled in with
3789 + * the IP addres.
3790 + * \param addr0 The first octet of the IP address.
3791 + * \param addr1 The second octet of the IP address.
3792 + * \param addr2 The third octet of the IP address.
3793 + * \param addr3 The forth octet of the IP address.
3794 + *
3795 + * \hideinitializer
3796 + */
3797 +#define uip_ipaddr(addr, addr0,addr1,addr2,addr3) do { \
3798 + (addr)[0] = HTONS(((addr0) << 8) | (addr1)); \
3799 + (addr)[1] = HTONS(((addr2) << 8) | (addr3)); \
3800 + } while(0)
3801 +
3802 +/**
3803 + * Convert 16-bit quantity from host byte order to network byte order.
3804 + *
3805 + * This macro is primarily used for converting constants from host
3806 + * byte order to network byte order. For converting variables to
3807 + * network byte order, use the htons() function instead.
3808 + *
3809 + * \hideinitializer
3810 + */
3811 +#ifndef HTONS
3812 +# if BYTE_ORDER == BIG_ENDIAN
3813 +# define HTONS(n) (n)
3814 +# else /* BYTE_ORDER == BIG_ENDIAN */
3815 +# define HTONS(n) ((((u16_t)((n) & 0xff)) << 8) | (((n) & 0xff00) >> 8))
3816 +# endif /* BYTE_ORDER == BIG_ENDIAN */
3817 +#endif /* HTONS */
3818 +
3819 +/**
3820 + * Convert 16-bit quantity from host byte order to network byte order.
3821 + *
3822 + * This function is primarily used for converting variables from host
3823 + * byte order to network byte order. For converting constants to
3824 + * network byte order, use the HTONS() macro instead.
3825 + */
3826 +#ifndef htons
3827 +u16_t htons(u16_t val);
3828 +#endif /* htons */
3829 +
3830 +/** @} */
3831 +
3832 +/**
3833 + * Pointer to the application data in the packet buffer.
3834 + *
3835 + * This pointer points to the application data when the application is
3836 + * called. If the application wishes to send data, the application may
3837 + * use this space to write the data into before calling uip_send().
3838 + */
3839 +extern volatile u8_t *uip_appdata;
3840 +extern volatile u8_t *uip_sappdata;
3841 +
3842 +#if UIP_URGDATA > 0
3843 +/* u8_t *uip_urgdata:
3844 + *
3845 + * This pointer points to any urgent data that has been received. Only
3846 + * present if compiled with support for urgent data (UIP_URGDATA).
3847 + */
3848 +extern volatile u8_t *uip_urgdata;
3849 +#endif /* UIP_URGDATA > 0 */
3850 +
3851 +
3852 +/* u[8|16]_t uip_len:
3853 + *
3854 + * When the application is called, uip_len contains the length of any
3855 + * new data that has been received from the remote host. The
3856 + * application should set this variable to the size of any data that
3857 + * the application wishes to send. When the network device driver
3858 + * output function is called, uip_len should contain the length of the
3859 + * outgoing packet.
3860 + */
3861 +extern volatile u16_t uip_len, uip_slen;
3862 +
3863 +#if UIP_URGDATA > 0
3864 +extern volatile u8_t uip_urglen, uip_surglen;
3865 +#endif /* UIP_URGDATA > 0 */
3866 +
3867 +
3868 +/**
3869 + * Representation of a uIP TCP connection.
3870 + *
3871 + * The uip_conn structure is used for identifying a connection. All
3872 + * but one field in the structure are to be considered read-only by an
3873 + * application. The only exception is the appstate field whos purpose
3874 + * is to let the application store application-specific state (e.g.,
3875 + * file pointers) for the connection. The size of this field is
3876 + * configured in the "uipopt.h" header file.
3877 + */
3878 +struct uip_conn {
3879 + u16_t ripaddr[2]; /**< The IP address of the remote host. */
3880 +
3881 + u16_t lport; /**< The local TCP port, in network byte order. */
3882 + u16_t rport; /**< The local remote TCP port, in network byte
3883 + order. */
3884 +
3885 + u8_t rcv_nxt[4]; /**< The sequence number that we expect to
3886 + receive next. */
3887 + u8_t snd_nxt[4]; /**< The sequence number that was last sent by
3888 + us. */
3889 + u16_t len; /**< Length of the data that was previously sent. */
3890 + u16_t mss; /**< Current maximum segment size for the
3891 + connection. */
3892 + u16_t initialmss; /**< Initial maximum segment size for the
3893 + connection. */
3894 + u8_t sa; /**< Retransmission time-out calculation state
3895 + variable. */
3896 + u8_t sv; /**< Retransmission time-out calculation state
3897 + variable. */
3898 + u8_t rto; /**< Retransmission time-out. */
3899 + u8_t tcpstateflags; /**< TCP state and flags. */
3900 + u8_t timer; /**< The retransmission timer. */
3901 + u8_t nrtx; /**< The number of retransmissions for the last
3902 + segment sent. */
3903 +
3904 + /** The application state. */
3905 + u8_t appstate[UIP_APPSTATE_SIZE];
3906 +};
3907 +
3908 +
3909 +/* Pointer to the current connection. */
3910 +extern struct uip_conn *uip_conn;
3911 +/* The array containing all uIP connections. */
3912 +extern struct uip_conn uip_conns[UIP_CONNS];
3913 +/**
3914 + * \addtogroup uiparch
3915 + * @{
3916 + */
3917 +
3918 +/**
3919 + * 4-byte array used for the 32-bit sequence number calculations.
3920 + */
3921 +extern volatile u8_t uip_acc32[4];
3922 +
3923 +/** @} */
3924 +
3925 +
3926 +#if UIP_UDP
3927 +/**
3928 + * Representation of a uIP UDP connection.
3929 + */
3930 +struct uip_udp_conn {
3931 + u16_t ripaddr[2]; /**< The IP address of the remote peer. */
3932 + u16_t lport; /**< The local port number in network byte order. */
3933 + u16_t rport; /**< The remote port number in network byte order. */
3934 +};
3935 +
3936 +extern struct uip_udp_conn *uip_udp_conn;
3937 +extern struct uip_udp_conn uip_udp_conns[UIP_UDP_CONNS];
3938 +#endif /* UIP_UDP */
3939 +
3940 +/**
3941 + * The structure holding the TCP/IP statistics that are gathered if
3942 + * UIP_STATISTICS is set to 1.
3943 + *
3944 + */
3945 +struct uip_stats {
3946 + struct {
3947 + uip_stats_t drop; /**< Number of dropped packets at the IP
3948 + layer. */
3949 + uip_stats_t recv; /**< Number of received packets at the IP
3950 + layer. */
3951 + uip_stats_t sent; /**< Number of sent packets at the IP
3952 + layer. */
3953 + uip_stats_t vhlerr; /**< Number of packets dropped due to wrong
3954 + IP version or header length. */
3955 + uip_stats_t hblenerr; /**< Number of packets dropped due to wrong
3956 + IP length, high byte. */
3957 + uip_stats_t lblenerr; /**< Number of packets dropped due to wrong
3958 + IP length, low byte. */
3959 + uip_stats_t fragerr; /**< Number of packets dropped since they
3960 + were IP fragments. */
3961 + uip_stats_t chkerr; /**< Number of packets dropped due to IP
3962 + checksum errors. */
3963 + uip_stats_t protoerr; /**< Number of packets dropped since they
3964 + were neither ICMP, UDP nor TCP. */
3965 + } ip; /**< IP statistics. */
3966 + struct {
3967 + uip_stats_t drop; /**< Number of dropped ICMP packets. */
3968 + uip_stats_t recv; /**< Number of received ICMP packets. */
3969 + uip_stats_t sent; /**< Number of sent ICMP packets. */
3970 + uip_stats_t typeerr; /**< Number of ICMP packets with a wrong
3971 + type. */
3972 + } icmp; /**< ICMP statistics. */
3973 + struct {
3974 + uip_stats_t drop; /**< Number of dropped TCP segments. */
3975 + uip_stats_t recv; /**< Number of recived TCP segments. */
3976 + uip_stats_t sent; /**< Number of sent TCP segments. */
3977 + uip_stats_t chkerr; /**< Number of TCP segments with a bad
3978 + checksum. */
3979 + uip_stats_t ackerr; /**< Number of TCP segments with a bad ACK
3980 + number. */
3981 + uip_stats_t rst; /**< Number of recevied TCP RST (reset) segments. */
3982 + uip_stats_t rexmit; /**< Number of retransmitted TCP segments. */
3983 + uip_stats_t syndrop; /**< Number of dropped SYNs due to too few
3984 + connections was avaliable. */
3985 + uip_stats_t synrst; /**< Number of SYNs for closed ports,
3986 + triggering a RST. */
3987 + } tcp; /**< TCP statistics. */
3988 +};
3989 +
3990 +/**
3991 + * The uIP TCP/IP statistics.
3992 + *
3993 + * This is the variable in which the uIP TCP/IP statistics are gathered.
3994 + */
3995 +extern struct uip_stats uip_stat;
3996 +
3997 +
3998 +/*-----------------------------------------------------------------------------------*/
3999 +/* All the stuff below this point is internal to uIP and should not be
4000 + * used directly by an application or by a device driver.
4001 + */
4002 +/*-----------------------------------------------------------------------------------*/
4003 +/* u8_t uip_flags:
4004 + *
4005 + * When the application is called, uip_flags will contain the flags
4006 + * that are defined in this file. Please read below for more
4007 + * infomation.
4008 + */
4009 +extern volatile u8_t uip_flags;
4010 +
4011 +/* The following flags may be set in the global variable uip_flags
4012 + before calling the application callback. The UIP_ACKDATA and
4013 + UIP_NEWDATA flags may both be set at the same time, whereas the
4014 + others are mutualy exclusive. Note that these flags should *NOT* be
4015 + accessed directly, but through the uIP functions/macros. */
4016 +
4017 +#define UIP_ACKDATA 1 /* Signifies that the outstanding data was
4018 + acked and the application should send
4019 + out new data instead of retransmitting
4020 + the last data. */
4021 +#define UIP_NEWDATA 2 /* Flags the fact that the peer has sent
4022 + us new data. */
4023 +#define UIP_REXMIT 4 /* Tells the application to retransmit the
4024 + data that was last sent. */
4025 +#define UIP_POLL 8 /* Used for polling the application, to
4026 + check if the application has data that
4027 + it wants to send. */
4028 +#define UIP_CLOSE 16 /* The remote host has closed the
4029 + connection, thus the connection has
4030 + gone away. Or the application signals
4031 + that it wants to close the
4032 + connection. */
4033 +#define UIP_ABORT 32 /* The remote host has aborted the
4034 + connection, thus the connection has
4035 + gone away. Or the application signals
4036 + that it wants to abort the
4037 + connection. */
4038 +#define UIP_CONNECTED 64 /* We have got a connection from a remote
4039 + host and have set up a new connection
4040 + for it, or an active connection has
4041 + been successfully established. */
4042 +
4043 +#define UIP_TIMEDOUT 128 /* The connection has been aborted due to
4044 + too many retransmissions. */
4045 +
4046 +
4047 +/* uip_process(flag):
4048 + *
4049 + * The actual uIP function which does all the work.
4050 + */
4051 +void uip_process(u8_t flag);
4052 +
4053 +/* The following flags are passed as an argument to the uip_process()
4054 + function. They are used to distinguish between the two cases where
4055 + uip_process() is called. It can be called either because we have
4056 + incoming data that should be processed, or because the periodic
4057 + timer has fired. */
4058 +
4059 +#define UIP_DATA 1 /* Tells uIP that there is incoming data in
4060 + the uip_buf buffer. The length of the
4061 + data is stored in the global variable
4062 + uip_len. */
4063 +#define UIP_TIMER 2 /* Tells uIP that the periodic timer has
4064 + fired. */
4065 +#if UIP_UDP
4066 +#define UIP_UDP_TIMER 3
4067 +#endif /* UIP_UDP */
4068 +
4069 +/* The TCP states used in the uip_conn->tcpstateflags. */
4070 +#define CLOSED 0
4071 +#define SYN_RCVD 1
4072 +#define SYN_SENT 2
4073 +#define ESTABLISHED 3
4074 +#define FIN_WAIT_1 4
4075 +#define FIN_WAIT_2 5
4076 +#define CLOSING 6
4077 +#define TIME_WAIT 7
4078 +#define LAST_ACK 8
4079 +#define TS_MASK 15
4080 +
4081 +#define UIP_STOPPED 16
4082 +
4083 +#define UIP_TCPIP_HLEN 40
4084 +
4085 +/* The TCP and IP headers. */
4086 +typedef struct {
4087 + /* IP header. */
4088 + u8_t vhl,
4089 + tos,
4090 + len[2],
4091 + ipid[2],
4092 + ipoffset[2],
4093 + ttl,
4094 + proto;
4095 + u16_t ipchksum;
4096 + u16_t srcipaddr[2],
4097 + destipaddr[2];
4098 +
4099 + /* TCP header. */
4100 + u16_t srcport,
4101 + destport;
4102 + u8_t seqno[4],
4103 + ackno[4],
4104 + tcpoffset,
4105 + flags,
4106 + wnd[2];
4107 + u16_t tcpchksum;
4108 + u8_t urgp[2];
4109 + u8_t optdata[4];
4110 +} uip_tcpip_hdr;
4111 +
4112 +/* The ICMP and IP headers. */
4113 +typedef struct {
4114 + /* IP header. */
4115 + u8_t vhl,
4116 + tos,
4117 + len[2],
4118 + ipid[2],
4119 + ipoffset[2],
4120 + ttl,
4121 + proto;
4122 + u16_t ipchksum;
4123 + u16_t srcipaddr[2],
4124 + destipaddr[2];
4125 + /* ICMP (echo) header. */
4126 + u8_t type, icode;
4127 + u16_t icmpchksum;
4128 + u16_t id, seqno;
4129 +} uip_icmpip_hdr;
4130 +
4131 +
4132 +/* The UDP and IP headers. */
4133 +typedef struct {
4134 + /* IP header. */
4135 + u8_t vhl,
4136 + tos,
4137 + len[2],
4138 + ipid[2],
4139 + ipoffset[2],
4140 + ttl,
4141 + proto;
4142 + u16_t ipchksum;
4143 + u16_t srcipaddr[2],
4144 + destipaddr[2];
4145 +
4146 + /* UDP header. */
4147 + u16_t srcport,
4148 + destport;
4149 + u16_t udplen;
4150 + u16_t udpchksum;
4151 +} uip_udpip_hdr;
4152 +
4153 +#define UIP_PROTO_ICMP 1
4154 +#define UIP_PROTO_TCP 6
4155 +#define UIP_PROTO_UDP 17
4156 +
4157 +#if UIP_FIXEDADDR
4158 +extern const u16_t uip_hostaddr[2];
4159 +#else /* UIP_FIXEDADDR */
4160 +extern u16_t uip_hostaddr[2];
4161 +#endif /* UIP_FIXEDADDR */
4162 +
4163 +#endif /* __UIP_H__ */
4164 +
4165 +
4166 +/** @} */
4167 +
4168 --- /dev/null
4169 +++ b/net/uip-0.9/uip_arch.c
4170 @@ -0,0 +1,145 @@
4171 +/*
4172 + * Copyright (c) 2001, Adam Dunkels.
4173 + * All rights reserved.
4174 + *
4175 + * Redistribution and use in source and binary forms, with or without
4176 + * modification, are permitted provided that the following conditions
4177 + * are met:
4178 + * 1. Redistributions of source code must retain the above copyright
4179 + * notice, this list of conditions and the following disclaimer.
4180 + * 2. Redistributions in binary form must reproduce the above copyright
4181 + * notice, this list of conditions and the following disclaimer in the
4182 + * documentation and/or other materials provided with the distribution.
4183 + * 3. The name of the author may not be used to endorse or promote
4184 + * products derived from this software without specific prior
4185 + * written permission.
4186 + *
4187 + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS
4188 + * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
4189 + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
4190 + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
4191 + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
4192 + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
4193 + * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
4194 + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
4195 + * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
4196 + * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
4197 + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
4198 + *
4199 + * This file is part of the uIP TCP/IP stack.
4200 + *
4201 + * $Id: uip_arch.c,v 1.2.2.1 2003/10/04 22:54:17 adam Exp $
4202 + *
4203 + */
4204 +
4205 +
4206 +#include "uip.h"
4207 +#include "uip_arch.h"
4208 +
4209 +#define BUF ((uip_tcpip_hdr *)&uip_buf[UIP_LLH_LEN])
4210 +#define IP_PROTO_TCP 6
4211 +
4212 +/*-----------------------------------------------------------------------------------*/
4213 +void
4214 +uip_add32(u8_t *op32, u16_t op16)
4215 +{
4216 +
4217 + uip_acc32[3] = op32[3] + (op16 & 0xff);
4218 + uip_acc32[2] = op32[2] + (op16 >> 8);
4219 + uip_acc32[1] = op32[1];
4220 + uip_acc32[0] = op32[0];
4221 +
4222 + if(uip_acc32[2] < (op16 >> 8)) {
4223 + ++uip_acc32[1];
4224 + if(uip_acc32[1] == 0) {
4225 + ++uip_acc32[0];
4226 + }
4227 + }
4228 +
4229 +
4230 + if(uip_acc32[3] < (op16 & 0xff)) {
4231 + ++uip_acc32[2];
4232 + if(uip_acc32[2] == 0) {
4233 + ++uip_acc32[1];
4234 + if(uip_acc32[1] == 0) {
4235 + ++uip_acc32[0];
4236 + }
4237 + }
4238 + }
4239 +}
4240 +/*-----------------------------------------------------------------------------------*/
4241 +u16_t
4242 +uip_chksum(u16_t *sdata, u16_t len)
4243 +{
4244 + u16_t acc;
4245 +
4246 + for(acc = 0; len > 1; len -= 2) {
4247 + acc += *sdata;
4248 + if(acc < *sdata) {
4249 + /* Overflow, so we add the carry to acc (i.e., increase by
4250 + one). */
4251 + ++acc;
4252 + }
4253 + ++sdata;
4254 + }
4255 +
4256 + /* add up any odd byte */
4257 + if(len == 1) {
4258 + acc += htons(((u16_t)(*(u8_t *)sdata)) << 8);
4259 + if(acc < htons(((u16_t)(*(u8_t *)sdata)) << 8)) {
4260 + ++acc;
4261 + }
4262 + }
4263 +
4264 + return acc;
4265 +}
4266 +/*-----------------------------------------------------------------------------------*/
4267 +u16_t
4268 +uip_ipchksum(void)
4269 +{
4270 + return uip_chksum((u16_t *)&uip_buf[UIP_LLH_LEN], 20);
4271 +}
4272 +/*-----------------------------------------------------------------------------------*/
4273 +u16_t
4274 +uip_tcpchksum(void)
4275 +{
4276 + u16_t hsum, sum;
4277 +
4278 +
4279 + /* Compute the checksum of the TCP header. */
4280 + hsum = uip_chksum((u16_t *)&uip_buf[20 + UIP_LLH_LEN], 20);
4281 +
4282 + /* Compute the checksum of the data in the TCP packet and add it to
4283 + the TCP header checksum. */
4284 + sum = uip_chksum((u16_t *)uip_appdata,
4285 + (u16_t)(((((u16_t)(BUF->len[0]) << 8) + BUF->len[1]) - 40)));
4286 +
4287 + if((sum += hsum) < hsum) {
4288 + ++sum;
4289 + }
4290 +
4291 + if((sum += BUF->srcipaddr[0]) < BUF->srcipaddr[0]) {
4292 + ++sum;
4293 + }
4294 + if((sum += BUF->srcipaddr[1]) < BUF->srcipaddr[1]) {
4295 + ++sum;
4296 + }
4297 + if((sum += BUF->destipaddr[0]) < BUF->destipaddr[0]) {
4298 + ++sum;
4299 + }
4300 + if((sum += BUF->destipaddr[1]) < BUF->destipaddr[1]) {
4301 + ++sum;
4302 + }
4303 + if((sum += (u16_t)htons((u16_t)IP_PROTO_TCP)) < (u16_t)htons((u16_t)IP_PROTO_TCP)) {
4304 + ++sum;
4305 + }
4306 +
4307 + hsum = (u16_t)htons((((u16_t)(BUF->len[0]) << 8) + BUF->len[1]) - 20);
4308 +
4309 + if((sum += hsum) < hsum) {
4310 + ++sum;
4311 + }
4312 +
4313 + return sum;
4314 +}
4315 +/*-----------------------------------------------------------------------------------*/
4316 --- /dev/null
4317 +++ b/net/uip-0.9/uip_arch.h
4318 @@ -0,0 +1,130 @@
4319 +/**
4320 + * \defgroup uiparch Architecture specific uIP functions
4321 + * @{
4322 + *
4323 + * The functions in the architecture specific module implement the IP
4324 + * check sum and 32-bit additions.
4325 + *
4326 + * The IP checksum calculation is the most computationally expensive
4327 + * operation in the TCP/IP stack and it therefore pays off to
4328 + * implement this in efficient assembler. The purpose of the uip-arch
4329 + * module is to let the checksum functions to be implemented in
4330 + * architecture specific assembler.
4331 + *
4332 + */
4333 +
4334 +/**
4335 + * \file
4336 + * Declarations of architecture specific functions.
4337 + * \author Adam Dunkels <adam@dunkels.com>
4338 + */
4339 +
4340 +/*
4341 + * Copyright (c) 2001, Adam Dunkels.
4342 + * All rights reserved.
4343 + *
4344 + * Redistribution and use in source and binary forms, with or without
4345 + * modification, are permitted provided that the following conditions
4346 + * are met:
4347 + * 1. Redistributions of source code must retain the above copyright
4348 + * notice, this list of conditions and the following disclaimer.
4349 + * 2. Redistributions in binary form must reproduce the above copyright
4350 + * notice, this list of conditions and the following disclaimer in the
4351 + * documentation and/or other materials provided with the distribution.
4352 + * 3. The name of the author may not be used to endorse or promote
4353 + * products derived from this software without specific prior
4354 + * written permission.
4355 + *
4356 + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS
4357 + * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
4358 + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
4359 + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
4360 + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
4361 + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
4362 + * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
4363 + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
4364 + * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
4365 + * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
4366 + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
4367 + *
4368 + * This file is part of the uIP TCP/IP stack.
4369 + *
4370 + * $Id: uip_arch.h,v 1.1.2.2 2003/10/06 15:10:22 adam Exp $
4371 + *
4372 + */
4373 +
4374 +#ifndef __UIP_ARCH_H__
4375 +#define __UIP_ARCH_H__
4376 +
4377 +#include "uip.h"
4378 +
4379 +/**
4380 + * Carry out a 32-bit addition.
4381 + *
4382 + * Because not all architectures for which uIP is intended has native
4383 + * 32-bit arithmetic, uIP uses an external C function for doing the
4384 + * required 32-bit additions in the TCP protocol processing. This
4385 + * function should add the two arguments and place the result in the
4386 + * global variable uip_acc32.
4387 + *
4388 + * \note The 32-bit integer pointed to by the op32 parameter and the
4389 + * result in the uip_acc32 variable are in network byte order (big
4390 + * endian).
4391 + *
4392 + * \param op32 A pointer to a 4-byte array representing a 32-bit
4393 + * integer in network byte order (big endian).
4394 + *
4395 + * \param op16 A 16-bit integer in host byte order.
4396 + */
4397 +void uip_add32(u8_t *op32, u16_t op16);
4398 +
4399 +/**
4400 + * Calculate the Internet checksum over a buffer.
4401 + *
4402 + * The Internet checksum is the one's complement of the one's
4403 + * complement sum of all 16-bit words in the buffer.
4404 + *
4405 + * See RFC1071.
4406 + *
4407 + * \note This function is not called in the current version of uIP,
4408 + * but future versions might make use of it.
4409 + *
4410 + * \param buf A pointer to the buffer over which the checksum is to be
4411 + * computed.
4412 + *
4413 + * \param len The length of the buffer over which the checksum is to
4414 + * be computed.
4415 + *
4416 + * \return The Internet checksum of the buffer.
4417 + */
4418 +u16_t uip_chksum(u16_t *buf, u16_t len);
4419 +
4420 +/**
4421 + * Calculate the IP header checksum of the packet header in uip_buf.
4422 + *
4423 + * The IP header checksum is the Internet checksum of the 20 bytes of
4424 + * the IP header.
4425 + *
4426 + * \return The IP header checksum of the IP header in the uip_buf
4427 + * buffer.
4428 + */
4429 +u16_t uip_ipchksum(void);
4430 +
4431 +/**
4432 + * Calculate the TCP checksum of the packet in uip_buf and uip_appdata.
4433 + *
4434 + * The TCP checksum is the Internet checksum of data contents of the
4435 + * TCP segment, and a pseudo-header as defined in RFC793.
4436 + *
4437 + * \note The uip_appdata pointer that points to the packet data may
4438 + * point anywhere in memory, so it is not possible to simply calculate
4439 + * the Internet checksum of the contents of the uip_buf buffer.
4440 + *
4441 + * \return The TCP checksum of the TCP segment in uip_buf and pointed
4442 + * to by uip_appdata.
4443 + */
4444 +u16_t uip_tcpchksum(void);
4445 +
4446 +/** @} */
4447 +
4448 +#endif /* __UIP_ARCH_H__ */
4449 --- /dev/null
4450 +++ b/net/uip-0.9/uip_arp.c
4451 @@ -0,0 +1,421 @@
4452 +/**
4453 + * \addtogroup uip
4454 + * @{
4455 + */
4456 +
4457 +/**
4458 + * \defgroup uiparp uIP Address Resolution Protocol
4459 + * @{
4460 + *
4461 + * The Address Resolution Protocol ARP is used for mapping between IP
4462 + * addresses and link level addresses such as the Ethernet MAC
4463 + * addresses. ARP uses broadcast queries to ask for the link level
4464 + * address of a known IP address and the host which is configured with
4465 + * the IP address for which the query was meant, will respond with its
4466 + * link level address.
4467 + *
4468 + * \note This ARP implementation only supports Ethernet.
4469 + */
4470 +
4471 +/**
4472 + * \file
4473 + * Implementation of the ARP Address Resolution Protocol.
4474 + * \author Adam Dunkels <adam@dunkels.com>
4475 + *
4476 + */
4477 +
4478 +/*
4479 + * Copyright (c) 2001-2003, Adam Dunkels.
4480 + * All rights reserved.
4481 + *
4482 + * Redistribution and use in source and binary forms, with or without
4483 + * modification, are permitted provided that the following conditions
4484 + * are met:
4485 + * 1. Redistributions of source code must retain the above copyright
4486 + * notice, this list of conditions and the following disclaimer.
4487 + * 2. Redistributions in binary form must reproduce the above copyright
4488 + * notice, this list of conditions and the following disclaimer in the
4489 + * documentation and/or other materials provided with the distribution.
4490 + * 3. The name of the author may not be used to endorse or promote
4491 + * products derived from this software without specific prior
4492 + * written permission.
4493 + *
4494 + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS
4495 + * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
4496 + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
4497 + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
4498 + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
4499 + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
4500 + * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
4501 + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
4502 + * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
4503 + * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
4504 + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
4505 + *
4506 + * This file is part of the uIP TCP/IP stack.
4507 + *
4508 + * $Id: uip_arp.c,v 1.7.2.3 2003/10/06 22:42:30 adam Exp $
4509 + *
4510 + */
4511 +
4512 +
4513 +#include "uip_arp.h"
4514 +
4515 +struct arp_hdr {
4516 + struct uip_eth_hdr ethhdr;
4517 + u16_t hwtype;
4518 + u16_t protocol;
4519 + u8_t hwlen;
4520 + u8_t protolen;
4521 + u16_t opcode;
4522 + struct uip_eth_addr shwaddr;
4523 + u16_t sipaddr[2];
4524 + struct uip_eth_addr dhwaddr;
4525 + u16_t dipaddr[2];
4526 +};
4527 +
4528 +struct ethip_hdr {
4529 + struct uip_eth_hdr ethhdr;
4530 + /* IP header. */
4531 + u8_t vhl,
4532 + tos,
4533 + len[2],
4534 + ipid[2],
4535 + ipoffset[2],
4536 + ttl,
4537 + proto;
4538 + u16_t ipchksum;
4539 + u16_t srcipaddr[2],
4540 + destipaddr[2];
4541 +};
4542 +
4543 +#define ARP_REQUEST 1
4544 +#define ARP_REPLY 2
4545 +
4546 +#define ARP_HWTYPE_ETH 1
4547 +
4548 +struct arp_entry {
4549 + u16_t ipaddr[2];
4550 + struct uip_eth_addr ethaddr;
4551 + u8_t time;
4552 +};
4553 +
4554 +struct uip_eth_addr uip_ethaddr = {{UIP_ETHADDR0,
4555 + UIP_ETHADDR1,
4556 + UIP_ETHADDR2,
4557 + UIP_ETHADDR3,
4558 + UIP_ETHADDR4,
4559 + UIP_ETHADDR5}};
4560 +
4561 +static struct arp_entry arp_table[UIP_ARPTAB_SIZE];
4562 +static u16_t ipaddr[2];
4563 +static u8_t i, c;
4564 +
4565 +static u8_t arptime;
4566 +static u8_t tmpage;
4567 +
4568 +#define BUF ((struct arp_hdr *)&uip_buf[0])
4569 +#define IPBUF ((struct ethip_hdr *)&uip_buf[0])
4570 +/*-----------------------------------------------------------------------------------*/
4571 +/**
4572 + * Initialize the ARP module.
4573 + *
4574 + */
4575 +/*-----------------------------------------------------------------------------------*/
4576 +void
4577 +uip_arp_init(void)
4578 +{
4579 + for(i = 0; i < UIP_ARPTAB_SIZE; ++i) {
4580 + memset(arp_table[i].ipaddr, 0, 4);
4581 + }
4582 +}
4583 +/*-----------------------------------------------------------------------------------*/
4584 +/**
4585 + * Periodic ARP processing function.
4586 + *
4587 + * This function performs periodic timer processing in the ARP module
4588 + * and should be called at regular intervals. The recommended interval
4589 + * is 10 seconds between the calls.
4590 + *
4591 + */
4592 +/*-----------------------------------------------------------------------------------*/
4593 +void
4594 +uip_arp_timer(void)
4595 +{
4596 + struct arp_entry *tabptr;
4597 +
4598 + ++arptime;
4599 + for(i = 0; i < UIP_ARPTAB_SIZE; ++i) {
4600 + tabptr = &arp_table[i];
4601 + if((tabptr->ipaddr[0] | tabptr->ipaddr[1]) != 0 &&
4602 + arptime - tabptr->time >= UIP_ARP_MAXAGE) {
4603 + memset(tabptr->ipaddr, 0, 4);
4604 + }
4605 + }
4606 +
4607 +}
4608 +/*-----------------------------------------------------------------------------------*/
4609 +static void
4610 +uip_arp_update(u16_t *ipaddr, struct uip_eth_addr *ethaddr)
4611 +{
4612 + register struct arp_entry *tabptr = 0;
4613 + /* Walk through the ARP mapping table and try to find an entry to
4614 + update. If none is found, the IP -> MAC address mapping is
4615 + inserted in the ARP table. */
4616 + for(i = 0; i < UIP_ARPTAB_SIZE; ++i) {
4617 +
4618 + tabptr = &arp_table[i];
4619 + /* Only check those entries that are actually in use. */
4620 + if(tabptr->ipaddr[0] != 0 &&
4621 + tabptr->ipaddr[1] != 0) {
4622 +
4623 + /* Check if the source IP address of the incoming packet matches
4624 + the IP address in this ARP table entry. */
4625 + if(ipaddr[0] == tabptr->ipaddr[0] &&
4626 + ipaddr[1] == tabptr->ipaddr[1]) {
4627 +
4628 + /* An old entry found, update this and return. */
4629 + memcpy(tabptr->ethaddr.addr, ethaddr->addr, 6);
4630 + tabptr->time = arptime;
4631 +
4632 + return;
4633 + }
4634 + }
4635 + }
4636 +
4637 + /* If we get here, no existing ARP table entry was found, so we
4638 + create one. */
4639 +
4640 + /* First, we try to find an unused entry in the ARP table. */
4641 + for(i = 0; i < UIP_ARPTAB_SIZE; ++i) {
4642 + tabptr = &arp_table[i];
4643 + if(tabptr->ipaddr[0] == 0 &&
4644 + tabptr->ipaddr[1] == 0) {
4645 + break;
4646 + }
4647 + }
4648 +
4649 + /* If no unused entry is found, we try to find the oldest entry and
4650 + throw it away. */
4651 + if(i == UIP_ARPTAB_SIZE) {
4652 + tmpage = 0;
4653 + c = 0;
4654 + for(i = 0; i < UIP_ARPTAB_SIZE; ++i) {
4655 + tabptr = &arp_table[i];
4656 + if(arptime - tabptr->time > tmpage) {
4657 + tmpage = arptime - tabptr->time;
4658 + c = i;
4659 + }
4660 + }
4661 + i = c;
4662 + }
4663 +
4664 + /* Now, i is the ARP table entry which we will fill with the new
4665 + information. */
4666 + memcpy(tabptr->ipaddr, ipaddr, 4);
4667 + memcpy(tabptr->ethaddr.addr, ethaddr->addr, 6);
4668 + tabptr->time = arptime;
4669 +}
4670 +/*-----------------------------------------------------------------------------------*/
4671 +/**
4672 + * ARP processing for incoming IP packets
4673 + *
4674 + * This function should be called by the device driver when an IP
4675 + * packet has been received. The function will check if the address is
4676 + * in the ARP cache, and if so the ARP cache entry will be
4677 + * refreshed. If no ARP cache entry was found, a new one is created.
4678 + *
4679 + * This function expects an IP packet with a prepended Ethernet header
4680 + * in the uip_buf[] buffer, and the length of the packet in the global
4681 + * variable uip_len.
4682 + */
4683 +/*-----------------------------------------------------------------------------------*/
4684 +void
4685 +uip_arp_ipin(void)
4686 +{
4687 + uip_len -= sizeof(struct uip_eth_hdr);
4688 +
4689 + /* Only insert/update an entry if the source IP address of the
4690 + incoming IP packet comes from a host on the local network. */
4691 + if((IPBUF->srcipaddr[0] & uip_arp_netmask[0]) !=
4692 + (uip_hostaddr[0] & uip_arp_netmask[0])) {
4693 + return;
4694 + }
4695 + if((IPBUF->srcipaddr[1] & uip_arp_netmask[1]) !=
4696 + (uip_hostaddr[1] & uip_arp_netmask[1])) {
4697 + return;
4698 + }
4699 + uip_arp_update(IPBUF->srcipaddr, &(IPBUF->ethhdr.src));
4700 +
4701 + return;
4702 +}
4703 +/*-----------------------------------------------------------------------------------*/
4704 +/**
4705 + * ARP processing for incoming ARP packets.
4706 + *
4707 + * This function should be called by the device driver when an ARP
4708 + * packet has been received. The function will act differently
4709 + * depending on the ARP packet type: if it is a reply for a request
4710 + * that we previously sent out, the ARP cache will be filled in with
4711 + * the values from the ARP reply. If the incoming ARP packet is an ARP
4712 + * request for our IP address, an ARP reply packet is created and put
4713 + * into the uip_buf[] buffer.
4714 + *
4715 + * When the function returns, the value of the global variable uip_len
4716 + * indicates whether the device driver should send out a packet or
4717 + * not. If uip_len is zero, no packet should be sent. If uip_len is
4718 + * non-zero, it contains the length of the outbound packet that is
4719 + * present in the uip_buf[] buffer.
4720 + *
4721 + * This function expects an ARP packet with a prepended Ethernet
4722 + * header in the uip_buf[] buffer, and the length of the packet in the
4723 + * global variable uip_len.
4724 + */
4725 +/*-----------------------------------------------------------------------------------*/
4726 +void
4727 +uip_arp_arpin(void)
4728 +{
4729 +
4730 + if(uip_len < sizeof(struct arp_hdr)) {
4731 + uip_len = 0;
4732 + return;
4733 + }
4734 +
4735 + uip_len = 0;
4736 +
4737 + switch(BUF->opcode) {
4738 + case HTONS(ARP_REQUEST):
4739 + /* ARP request. If it asked for our address, we send out a
4740 + reply. */
4741 + if(BUF->dipaddr[0] == uip_hostaddr[0] &&
4742 + BUF->dipaddr[1] == uip_hostaddr[1]) {
4743 + /* The reply opcode is 2. */
4744 + BUF->opcode = HTONS(2);
4745 +
4746 + memcpy(BUF->dhwaddr.addr, BUF->shwaddr.addr, 6);
4747 + memcpy(BUF->shwaddr.addr, uip_ethaddr.addr, 6);
4748 + memcpy(BUF->ethhdr.src.addr, uip_ethaddr.addr, 6);
4749 + memcpy(BUF->ethhdr.dest.addr, BUF->dhwaddr.addr, 6);
4750 +
4751 + BUF->dipaddr[0] = BUF->sipaddr[0];
4752 + BUF->dipaddr[1] = BUF->sipaddr[1];
4753 + BUF->sipaddr[0] = uip_hostaddr[0];
4754 + BUF->sipaddr[1] = uip_hostaddr[1];
4755 +
4756 + BUF->ethhdr.type = HTONS(UIP_ETHTYPE_ARP);
4757 + uip_len = sizeof(struct arp_hdr);
4758 + }
4759 + break;
4760 + case HTONS(ARP_REPLY):
4761 + /* ARP reply. We insert or update the ARP table if it was meant
4762 + for us. */
4763 + if(BUF->dipaddr[0] == uip_hostaddr[0] &&
4764 + BUF->dipaddr[1] == uip_hostaddr[1]) {
4765 +
4766 + uip_arp_update(BUF->sipaddr, &BUF->shwaddr);
4767 + }
4768 + break;
4769 + }
4770 +
4771 + return;
4772 +}
4773 +/*-----------------------------------------------------------------------------------*/
4774 +/**
4775 + * Prepend Ethernet header to an outbound IP packet and see if we need
4776 + * to send out an ARP request.
4777 + *
4778 + * This function should be called before sending out an IP packet. The
4779 + * function checks the destination IP address of the IP packet to see
4780 + * what Ethernet MAC address that should be used as a destination MAC
4781 + * address on the Ethernet.
4782 + *
4783 + * If the destination IP address is in the local network (determined
4784 + * by logical ANDing of netmask and our IP address), the function
4785 + * checks the ARP cache to see if an entry for the destination IP
4786 + * address is found. If so, an Ethernet header is prepended and the
4787 + * function returns. If no ARP cache entry is found for the
4788 + * destination IP address, the packet in the uip_buf[] is replaced by
4789 + * an ARP request packet for the IP address. The IP packet is dropped
4790 + * and it is assumed that they higher level protocols (e.g., TCP)
4791 + * eventually will retransmit the dropped packet.
4792 + *
4793 + * If the destination IP address is not on the local network, the IP
4794 + * address of the default router is used instead.
4795 + *
4796 + * When the function returns, a packet is present in the uip_buf[]
4797 + * buffer, and the length of the packet is in the global variable
4798 + * uip_len.
4799 + */
4800 +/*-----------------------------------------------------------------------------------*/
4801 +void
4802 +uip_arp_out(void)
4803 +{
4804 + struct arp_entry *tabptr = 0;
4805 + /* Find the destination IP address in the ARP table and construct
4806 + the Ethernet header. If the destination IP addres isn't on the
4807 + local network, we use the default router's IP address instead.
4808 +
4809 + If not ARP table entry is found, we overwrite the original IP
4810 + packet with an ARP request for the IP address. */
4811 +
4812 + /* Check if the destination address is on the local network. */
4813 + if((IPBUF->destipaddr[0] & uip_arp_netmask[0]) !=
4814 + (uip_hostaddr[0] & uip_arp_netmask[0]) ||
4815 + (IPBUF->destipaddr[1] & uip_arp_netmask[1]) !=
4816 + (uip_hostaddr[1] & uip_arp_netmask[1])) {
4817 + /* Destination address was not on the local network, so we need to
4818 + use the default router's IP address instead of the destination
4819 + address when determining the MAC address. */
4820 + ipaddr[0] = uip_arp_draddr[0];
4821 + ipaddr[1] = uip_arp_draddr[1];
4822 + } else {
4823 + /* Else, we use the destination IP address. */
4824 + ipaddr[0] = IPBUF->destipaddr[0];
4825 + ipaddr[1] = IPBUF->destipaddr[1];
4826 + }
4827 +
4828 + for(i = 0; i < UIP_ARPTAB_SIZE; ++i) {
4829 + tabptr = &arp_table[i];
4830 + if(ipaddr[0] == tabptr->ipaddr[0] &&
4831 + ipaddr[1] == tabptr->ipaddr[1])
4832 + break;
4833 + }
4834 +
4835 + if(i == UIP_ARPTAB_SIZE) {
4836 + /* The destination address was not in our ARP table, so we
4837 + overwrite the IP packet with an ARP request. */
4838 +
4839 + memset(BUF->ethhdr.dest.addr, 0xff, 6);
4840 + memset(BUF->dhwaddr.addr, 0x00, 6);
4841 + memcpy(BUF->ethhdr.src.addr, uip_ethaddr.addr, 6);
4842 + memcpy(BUF->shwaddr.addr, uip_ethaddr.addr, 6);
4843 +
4844 + BUF->dipaddr[0] = ipaddr[0];
4845 + BUF->dipaddr[1] = ipaddr[1];
4846 + BUF->sipaddr[0] = uip_hostaddr[0];
4847 + BUF->sipaddr[1] = uip_hostaddr[1];
4848 + BUF->opcode = HTONS(ARP_REQUEST); /* ARP request. */
4849 + BUF->hwtype = HTONS(ARP_HWTYPE_ETH);
4850 + BUF->protocol = HTONS(UIP_ETHTYPE_IP);
4851 + BUF->hwlen = 6;
4852 + BUF->protolen = 4;
4853 + BUF->ethhdr.type = HTONS(UIP_ETHTYPE_ARP);
4854 +
4855 + uip_appdata = &uip_buf[40 + UIP_LLH_LEN];
4856 +
4857 + uip_len = sizeof(struct arp_hdr);
4858 + return;
4859 + }
4860 +
4861 + /* Build an ethernet header. */
4862 + memcpy(IPBUF->ethhdr.dest.addr, tabptr->ethaddr.addr, 6);
4863 + memcpy(IPBUF->ethhdr.src.addr, uip_ethaddr.addr, 6);
4864 +
4865 + IPBUF->ethhdr.type = HTONS(UIP_ETHTYPE_IP);
4866 +
4867 + uip_len += sizeof(struct uip_eth_hdr);
4868 +}
4869 +/*-----------------------------------------------------------------------------------*/
4870 +
4871 +/** @} */
4872 +/** @} */
4873 --- /dev/null
4874 +++ b/net/uip-0.9/uip_arp.h
4875 @@ -0,0 +1,201 @@
4876 +/**
4877 + * \addtogroup uip
4878 + * @{
4879 + */
4880 +
4881 +/**
4882 + * \addtogroup uiparp
4883 + * @{
4884 + */
4885 +
4886 +/**
4887 + * \file
4888 + * Macros and definitions for the ARP module.
4889 + * \author Adam Dunkels <adam@dunkels.com>
4890 + */
4891 +
4892 +
4893 +/*
4894 + * Copyright (c) 2001-2003, Adam Dunkels.
4895 + * All rights reserved.
4896 + *
4897 + * Redistribution and use in source and binary forms, with or without
4898 + * modification, are permitted provided that the following conditions
4899 + * are met:
4900 + * 1. Redistributions of source code must retain the above copyright
4901 + * notice, this list of conditions and the following disclaimer.
4902 + * 2. Redistributions in binary form must reproduce the above copyright
4903 + * notice, this list of conditions and the following disclaimer in the
4904 + * documentation and/or other materials provided with the distribution.
4905 + * 3. The name of the author may not be used to endorse or promote
4906 + * products derived from this software without specific prior
4907 + * written permission.
4908 + *
4909 + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS
4910 + * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
4911 + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
4912 + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
4913 + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
4914 + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
4915 + * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
4916 + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
4917 + * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
4918 + * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
4919 + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
4920 + *
4921 + * This file is part of the uIP TCP/IP stack.
4922 + *
4923 + * $Id: uip_arp.h,v 1.3.2.2 2003/10/06 15:10:22 adam Exp $
4924 + *
4925 + */
4926 +
4927 +#ifndef __UIP_ARP_H__
4928 +#define __UIP_ARP_H__
4929 +
4930 +#include "uip.h"
4931 +
4932 +
4933 +/**
4934 + * Representation of a 48-bit Ethernet address.
4935 + */
4936 +struct uip_eth_addr {
4937 + u8_t addr[6];
4938 +};
4939 +
4940 +extern struct uip_eth_addr uip_ethaddr;
4941 +
4942 +/**
4943 + * The Ethernet header.
4944 + */
4945 +struct uip_eth_hdr {
4946 + struct uip_eth_addr dest;
4947 + struct uip_eth_addr src;
4948 + u16_t type;
4949 +};
4950 +
4951 +#define UIP_ETHTYPE_ARP 0x0806
4952 +#define UIP_ETHTYPE_IP 0x0800
4953 +#define UIP_ETHTYPE_IP6 0x86dd
4954 +
4955 +
4956 +/* The uip_arp_init() function must be called before any of the other
4957 + ARP functions. */
4958 +void uip_arp_init(void);
4959 +
4960 +/* The uip_arp_ipin() function should be called whenever an IP packet
4961 + arrives from the Ethernet. This function refreshes the ARP table or
4962 + inserts a new mapping if none exists. The function assumes that an
4963 + IP packet with an Ethernet header is present in the uip_buf buffer
4964 + and that the length of the packet is in the uip_len variable. */
4965 +void uip_arp_ipin(void);
4966 +
4967 +/* The uip_arp_arpin() should be called when an ARP packet is received
4968 + by the Ethernet driver. This function also assumes that the
4969 + Ethernet frame is present in the uip_buf buffer. When the
4970 + uip_arp_arpin() function returns, the contents of the uip_buf
4971 + buffer should be sent out on the Ethernet if the uip_len variable
4972 + is > 0. */
4973 +void uip_arp_arpin(void);
4974 +
4975 +/* The uip_arp_out() function should be called when an IP packet
4976 + should be sent out on the Ethernet. This function creates an
4977 + Ethernet header before the IP header in the uip_buf buffer. The
4978 + Ethernet header will have the correct Ethernet MAC destination
4979 + address filled in if an ARP table entry for the destination IP
4980 + address (or the IP address of the default router) is present. If no
4981 + such table entry is found, the IP packet is overwritten with an ARP
4982 + request and we rely on TCP to retransmit the packet that was
4983 + overwritten. In any case, the uip_len variable holds the length of
4984 + the Ethernet frame that should be transmitted. */
4985 +void uip_arp_out(void);
4986 +
4987 +/* The uip_arp_timer() function should be called every ten seconds. It
4988 + is responsible for flushing old entries in the ARP table. */
4989 +void uip_arp_timer(void);
4990 +
4991 +/** @} */
4992 +
4993 +/**
4994 + * \addtogroup uipconffunc
4995 + * @{
4996 + */
4997 +
4998 +/**
4999 + * Set the default router's IP address.
5000 + *
5001 + * \param addr A pointer to a 4-byte array containing the IP address
5002 + * of the default router.
5003 + *
5004 + * \hideinitializer
5005 + */
5006 +#define uip_setdraddr(addr) do { uip_arp_draddr[0] = addr[0]; \
5007 + uip_arp_draddr[1] = addr[1]; } while(0)
5008 +
5009 +/**
5010 + * Set the netmask.
5011 + *
5012 + * \param addr A pointer to a 4-byte array containing the IP address
5013 + * of the netmask.
5014 + *
5015 + * \hideinitializer
5016 + */
5017 +#define uip_setnetmask(addr) do { uip_arp_netmask[0] = addr[0]; \
5018 + uip_arp_netmask[1] = addr[1]; } while(0)
5019 +
5020 +
5021 +/**
5022 + * Get the default router's IP address.
5023 + *
5024 + * \param addr A pointer to a 4-byte array that will be filled in with
5025 + * the IP address of the default router.
5026 + *
5027 + * \hideinitializer
5028 + */
5029 +#define uip_getdraddr(addr) do { addr[0] = uip_arp_draddr[0]; \
5030 + addr[1] = uip_arp_draddr[1]; } while(0)
5031 +
5032 +/**
5033 + * Get the netmask.
5034 + *
5035 + * \param addr A pointer to a 4-byte array that will be filled in with
5036 + * the value of the netmask.
5037 + *
5038 + * \hideinitializer
5039 + */
5040 +#define uip_getnetmask(addr) do { addr[0] = uip_arp_netmask[0]; \
5041 + addr[1] = uip_arp_netmask[1]; } while(0)
5042 +
5043 +
5044 +/**
5045 + * Specifiy the Ethernet MAC address.
5046 + *
5047 + * The ARP code needs to know the MAC address of the Ethernet card in
5048 + * order to be able to respond to ARP queries and to generate working
5049 + * Ethernet headers.
5050 + *
5051 + * \note This macro only specifies the Ethernet MAC address to the ARP
5052 + * code. It cannot be used to change the MAC address of the Ethernet
5053 + * card.
5054 + *
5055 + * \param eaddr A pointer to a struct uip_eth_addr containing the
5056 + * Ethernet MAC address of the Ethernet card.
5057 + *
5058 + * \hideinitializer
5059 + */
5060 +#define uip_setethaddr(eaddr) do {uip_ethaddr.addr[0] = eaddr.addr[0]; \
5061 + uip_ethaddr.addr[1] = eaddr.addr[1];\
5062 + uip_ethaddr.addr[2] = eaddr.addr[2];\
5063 + uip_ethaddr.addr[3] = eaddr.addr[3];\
5064 + uip_ethaddr.addr[4] = eaddr.addr[4];\
5065 + uip_ethaddr.addr[5] = eaddr.addr[5];} while(0)
5066 +
5067 +/** @} */
5068 +
5069 +/**
5070 + * \internal Internal variables that are set using the macros
5071 + * uip_setdraddr and uip_setnetmask.
5072 + */
5073 +extern u16_t uip_arp_draddr[2], uip_arp_netmask[2];
5074 +#endif /* __UIP_ARP_H__ */
5075 +
5076 +
5077 --- /dev/null
5078 +++ b/net/uip-0.9/uipopt.h
5079 @@ -0,0 +1,557 @@
5080 +/**
5081 + * \defgroup uipopt Configuration options for uIP
5082 + * @{
5083 + *
5084 + * uIP is configured using the per-project configuration file
5085 + * "uipopt.h". This file contains all compile-time options for uIP and
5086 + * should be tweaked to match each specific project. The uIP
5087 + * distribution contains a documented example "uipopt.h" that can be
5088 + * copied and modified for each project.
5089 + */
5090 +
5091 +/**
5092 + * \file
5093 + * Configuration options for uIP.
5094 + * \author Adam Dunkels <adam@dunkels.com>
5095 + *
5096 + * This file is used for tweaking various configuration options for
5097 + * uIP. You should make a copy of this file into one of your project's
5098 + * directories instead of editing this example "uipopt.h" file that
5099 + * comes with the uIP distribution.
5100 + */
5101 +
5102 +/*
5103 + * Copyright (c) 2001-2003, Adam Dunkels.
5104 + * All rights reserved.
5105 + *
5106 + * Redistribution and use in source and binary forms, with or without
5107 + * modification, are permitted provided that the following conditions
5108 + * are met:
5109 + * 1. Redistributions of source code must retain the above copyright
5110 + * notice, this list of conditions and the following disclaimer.
5111 + * 2. Redistributions in binary form must reproduce the above copyright
5112 + * notice, this list of conditions and the following disclaimer in the
5113 + * documentation and/or other materials provided with the distribution.
5114 + * 3. The name of the author may not be used to endorse or promote
5115 + * products derived from this software without specific prior
5116 + * written permission.
5117 + *
5118 + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS
5119 + * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
5120 + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
5121 + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
5122 + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
5123 + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
5124 + * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
5125 + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
5126 + * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
5127 + * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
5128 + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
5129 + *
5130 + * This file is part of the uIP TCP/IP stack.
5131 + *
5132 + * $Id: uipopt.h,v 1.16.2.5 2003/10/07 13:22:51 adam Exp $
5133 + *
5134 + */
5135 +
5136 +#ifndef __UIPOPT_H__
5137 +#define __UIPOPT_H__
5138 +
5139 +/*------------------------------------------------------------------------------*/
5140 +/**
5141 + * \defgroup uipopttypedef uIP type definitions
5142 + * @{
5143 + */
5144 +
5145 +/**
5146 + * The 8-bit unsigned data type.
5147 + *
5148 + * This may have to be tweaked for your particular compiler. "unsigned
5149 + * char" works for most compilers.
5150 + */
5151 +typedef unsigned char u8_t;
5152 +
5153 +/**
5154 + * The 16-bit unsigned data type.
5155 + *
5156 + * This may have to be tweaked for your particular compiler. "unsigned
5157 + * short" works for most compilers.
5158 + */
5159 +typedef unsigned short u16_t;
5160 +
5161 +/**
5162 + * The statistics data type.
5163 + *
5164 + * This datatype determines how high the statistics counters are able
5165 + * to count.
5166 + */
5167 +typedef unsigned short uip_stats_t;
5168 +
5169 +/** @} */
5170 +
5171 +/*------------------------------------------------------------------------------*/
5172 +
5173 +/**
5174 + * \defgroup uipoptstaticconf Static configuration options
5175 + * @{
5176 + *
5177 + * These configuration options can be used for setting the IP address
5178 + * settings statically, but only if UIP_FIXEDADDR is set to 1. The
5179 + * configuration options for a specific node includes IP address,
5180 + * netmask and default router as well as the Ethernet address. The
5181 + * netmask, default router and Ethernet address are appliciable only
5182 + * if uIP should be run over Ethernet.
5183 + *
5184 + * All of these should be changed to suit your project.
5185 +*/
5186 +
5187 +/**
5188 + * Determines if uIP should use a fixed IP address or not.
5189 + *
5190 + * If uIP should use a fixed IP address, the settings are set in the
5191 + * uipopt.h file. If not, the macros uip_sethostaddr(),
5192 + * uip_setdraddr() and uip_setnetmask() should be used instead.
5193 + *
5194 + * \hideinitializer
5195 + */
5196 +#define UIP_FIXEDADDR 0
5197 +
5198 +/**
5199 + * Ping IP address asignment.
5200 + *
5201 + * uIP uses a "ping" packets for setting its own IP address if this
5202 + * option is set. If so, uIP will start with an empty IP address and
5203 + * the destination IP address of the first incoming "ping" (ICMP echo)
5204 + * packet will be used for setting the hosts IP address.
5205 + *
5206 + * \note This works only if UIP_FIXEDADDR is 0.
5207 + *
5208 + * \hideinitializer
5209 + */
5210 +#define UIP_PINGADDRCONF 0
5211 +
5212 +#define UIP_IPADDR0 192 /**< The first octet of the IP address of
5213 + this uIP node, if UIP_FIXEDADDR is
5214 + 1. \hideinitializer */
5215 +#define UIP_IPADDR1 168 /**< The second octet of the IP address of
5216 + this uIP node, if UIP_FIXEDADDR is
5217 + 1. \hideinitializer */
5218 +#define UIP_IPADDR2 0 /**< The third octet of the IP address of
5219 + this uIP node, if UIP_FIXEDADDR is
5220 + 1. \hideinitializer */
5221 +#define UIP_IPADDR3 250 /**< The fourth octet of the IP address of
5222 + this uIP node, if UIP_FIXEDADDR is
5223 + 1. \hideinitializer */
5224 +
5225 +#define UIP_NETMASK0 255 /**< The first octet of the netmask of
5226 + this uIP node, if UIP_FIXEDADDR is
5227 + 1. \hideinitializer */
5228 +#define UIP_NETMASK1 255 /**< The second octet of the netmask of
5229 + this uIP node, if UIP_FIXEDADDR is
5230 + 1. \hideinitializer */
5231 +#define UIP_NETMASK2 255 /**< The third octet of the netmask of
5232 + this uIP node, if UIP_FIXEDADDR is
5233 + 1. \hideinitializer */
5234 +#define UIP_NETMASK3 0 /**< The fourth octet of the netmask of
5235 + this uIP node, if UIP_FIXEDADDR is
5236 + 1. \hideinitializer */
5237 +
5238 +#define UIP_DRIPADDR0 192 /**< The first octet of the IP address of
5239 + the default router, if UIP_FIXEDADDR is
5240 + 1. \hideinitializer */
5241 +#define UIP_DRIPADDR1 168 /**< The second octet of the IP address of
5242 + the default router, if UIP_FIXEDADDR is
5243 + 1. \hideinitializer */
5244 +#define UIP_DRIPADDR2 0 /**< The third octet of the IP address of
5245 + the default router, if UIP_FIXEDADDR is
5246 + 1. \hideinitializer */
5247 +#define UIP_DRIPADDR3 1 /**< The fourth octet of the IP address of
5248 + the default router, if UIP_FIXEDADDR is
5249 + 1. \hideinitializer */
5250 +
5251 +/**
5252 + * Specifies if the uIP ARP module should be compiled with a fixed
5253 + * Ethernet MAC address or not.
5254 + *
5255 + * If this configuration option is 0, the macro uip_setethaddr() can
5256 + * be used to specify the Ethernet address at run-time.
5257 + *
5258 + * \hideinitializer
5259 + */
5260 +#define UIP_FIXEDETHADDR 0
5261 +
5262 +#define UIP_ETHADDR0 0x00 /**< The first octet of the Ethernet
5263 + address if UIP_FIXEDETHADDR is
5264 + 1. \hideinitializer */
5265 +#define UIP_ETHADDR1 0xbd /**< The second octet of the Ethernet
5266 + address if UIP_FIXEDETHADDR is
5267 + 1. \hideinitializer */
5268 +#define UIP_ETHADDR2 0x3b /**< The third octet of the Ethernet
5269 + address if UIP_FIXEDETHADDR is
5270 + 1. \hideinitializer */
5271 +#define UIP_ETHADDR3 0x33 /**< The fourth octet of the Ethernet
5272 + address if UIP_FIXEDETHADDR is
5273 + 1. \hideinitializer */
5274 +#define UIP_ETHADDR4 0x05 /**< The fifth octet of the Ethernet
5275 + address if UIP_FIXEDETHADDR is
5276 + 1. \hideinitializer */
5277 +#define UIP_ETHADDR5 0x71 /**< The sixth octet of the Ethernet
5278 + address if UIP_FIXEDETHADDR is
5279 + 1. \hideinitializer */
5280 +
5281 +/** @} */
5282 +/*------------------------------------------------------------------------------*/
5283 +/**
5284 + * \defgroup uipoptip IP configuration options
5285 + * @{
5286 + *
5287 + */
5288 +/**
5289 + * The IP TTL (time to live) of IP packets sent by uIP.
5290 + *
5291 + * This should normally not be changed.
5292 + */
5293 +#define UIP_TTL 255
5294 +
5295 +/**
5296 + * Turn on support for IP packet reassembly.
5297 + *
5298 + * uIP supports reassembly of fragmented IP packets. This features
5299 + * requires an additonal amount of RAM to hold the reassembly buffer
5300 + * and the reassembly code size is approximately 700 bytes. The
5301 + * reassembly buffer is of the same size as the uip_buf buffer
5302 + * (configured by UIP_BUFSIZE).
5303 + *
5304 + * \note IP packet reassembly is not heavily tested.
5305 + *
5306 + * \hideinitializer
5307 + */
5308 +#define UIP_REASSEMBLY 0
5309 +
5310 +/**
5311 + * The maximum time an IP fragment should wait in the reassembly
5312 + * buffer before it is dropped.
5313 + *
5314 + */
5315 +#define UIP_REASS_MAXAGE 40
5316 +
5317 +/** @} */
5318 +
5319 +/*------------------------------------------------------------------------------*/
5320 +/**
5321 + * \defgroup uipoptudp UDP configuration options
5322 + * @{
5323 + *
5324 + * \note The UDP support in uIP is still not entirely complete; there
5325 + * is no support for sending or receiving broadcast or multicast
5326 + * packets, but it works well enough to support a number of vital
5327 + * applications such as DNS queries, though
5328 + */
5329 +
5330 +/**
5331 + * Toggles wether UDP support should be compiled in or not.
5332 + *
5333 + * \hideinitializer
5334 + */
5335 +#define UIP_UDP 0
5336 +
5337 +/**
5338 + * Toggles if UDP checksums should be used or not.
5339 + *
5340 + * \note Support for UDP checksums is currently not included in uIP,
5341 + * so this option has no function.
5342 + *
5343 + * \hideinitializer
5344 + */
5345 +#define UIP_UDP_CHECKSUMS 0
5346 +
5347 +/**
5348 + * The maximum amount of concurrent UDP connections.
5349 + *
5350 + * \hideinitializer
5351 + */
5352 +#define UIP_UDP_CONNS 10
5353 +
5354 +/**
5355 + * The name of the function that should be called when UDP datagrams arrive.
5356 + *
5357 + * \hideinitializer
5358 + */
5359 +#define UIP_UDP_APPCALL udp_appcall
5360 +
5361 +/** @} */
5362 +/*------------------------------------------------------------------------------*/
5363 +/**
5364 + * \defgroup uipopttcp TCP configuration options
5365 + * @{
5366 + */
5367 +
5368 +/**
5369 + * Determines if support for opening connections from uIP should be
5370 + * compiled in.
5371 + *
5372 + * If the applications that are running on top of uIP for this project
5373 + * do not need to open outgoing TCP connections, this configration
5374 + * option can be turned off to reduce the code size of uIP.
5375 + *
5376 + * \hideinitializer
5377 + */
5378 +#define UIP_ACTIVE_OPEN 1
5379 +
5380 +/**
5381 + * The maximum number of simultaneously open TCP connections.
5382 + *
5383 + * Since the TCP connections are statically allocated, turning this
5384 + * configuration knob down results in less RAM used. Each TCP
5385 + * connection requires approximatly 30 bytes of memory.
5386 + *
5387 + * \hideinitializer
5388 + */
5389 +#define UIP_CONNS 10
5390 +
5391 +/**
5392 + * The maximum number of simultaneously listening TCP ports.
5393 + *
5394 + * Each listening TCP port requires 2 bytes of memory.
5395 + *
5396 + * \hideinitializer
5397 + */
5398 +#define UIP_LISTENPORTS 10
5399 +
5400 +/**
5401 + * The size of the advertised receiver's window.
5402 + *
5403 + * Should be set low (i.e., to the size of the uip_buf buffer) is the
5404 + * application is slow to process incoming data, or high (32768 bytes)
5405 + * if the application processes data quickly.
5406 + *
5407 + * \hideinitializer
5408 + */
5409 +#define UIP_RECEIVE_WINDOW 32768
5410 +
5411 +/**
5412 + * Determines if support for TCP urgent data notification should be
5413 + * compiled in.
5414 + *
5415 + * Urgent data (out-of-band data) is a rarely used TCP feature that
5416 + * very seldom would be required.
5417 + *
5418 + * \hideinitializer
5419 + */
5420 +#define UIP_URGDATA 1
5421 +
5422 +/**
5423 + * The initial retransmission timeout counted in timer pulses.
5424 + *
5425 + * This should not be changed.
5426 + */
5427 +#define UIP_RTO 3
5428 +
5429 +/**
5430 + * The maximum number of times a segment should be retransmitted
5431 + * before the connection should be aborted.
5432 + *
5433 + * This should not be changed.
5434 + */
5435 +#define UIP_MAXRTX 8
5436 +
5437 +/**
5438 + * The maximum number of times a SYN segment should be retransmitted
5439 + * before a connection request should be deemed to have been
5440 + * unsuccessful.
5441 + *
5442 + * This should not need to be changed.
5443 + */
5444 +#define UIP_MAXSYNRTX 3
5445 +
5446 +/**
5447 + * The TCP maximum segment size.
5448 + *
5449 + * This is should not be to set to more than UIP_BUFSIZE - UIP_LLH_LEN - 40.
5450 + */
5451 +#define UIP_TCP_MSS (UIP_BUFSIZE - UIP_LLH_LEN - 40)
5452 +
5453 +/**
5454 + * How long a connection should stay in the TIME_WAIT state.
5455 + *
5456 + * This configiration option has no real implication, and it should be
5457 + * left untouched.
5458 + */
5459 +#define UIP_TIME_WAIT_TIMEOUT 120
5460 +
5461 +
5462 +/** @} */
5463 +/*------------------------------------------------------------------------------*/
5464 +/**
5465 + * \defgroup uipoptarp ARP configuration options
5466 + * @{
5467 + */
5468 +
5469 +/**
5470 + * The size of the ARP table.
5471 + *
5472 + * This option should be set to a larger value if this uIP node will
5473 + * have many connections from the local network.
5474 + *
5475 + * \hideinitializer
5476 + */
5477 +#define UIP_ARPTAB_SIZE 8
5478 +
5479 +/**
5480 + * The maxium age of ARP table entries measured in 10ths of seconds.
5481 + *
5482 + * An UIP_ARP_MAXAGE of 120 corresponds to 20 minutes (BSD
5483 + * default).
5484 + */
5485 +#define UIP_ARP_MAXAGE 120
5486 +
5487 +/** @} */
5488 +
5489 +/*------------------------------------------------------------------------------*/
5490 +
5491 +/**
5492 + * \defgroup uipoptgeneral General configuration options
5493 + * @{
5494 + */
5495 +
5496 +/**
5497 + * The size of the uIP packet buffer.
5498 + *
5499 + * The uIP packet buffer should not be smaller than 60 bytes, and does
5500 + * not need to be larger than 1500 bytes. Lower size results in lower
5501 + * TCP throughput, larger size results in higher TCP throughput.
5502 + *
5503 + * \hideinitializer
5504 + */
5505 +#define UIP_BUFSIZE 1500
5506 +
5507 +
5508 +/**
5509 + * Determines if statistics support should be compiled in.
5510 + *
5511 + * The statistics is useful for debugging and to show the user.
5512 + *
5513 + * \hideinitializer
5514 + */
5515 +#define UIP_STATISTICS 1
5516 +
5517 +/**
5518 + * Determines if logging of certain events should be compiled in.
5519 + *
5520 + * This is useful mostly for debugging. The function uip_log()
5521 + * must be implemented to suit the architecture of the project, if
5522 + * logging is turned on.
5523 + *
5524 + * \hideinitializer
5525 + */
5526 +#define UIP_LOGGING 0
5527 +
5528 +/**
5529 + * Print out a uIP log message.
5530 + *
5531 + * This function must be implemented by the module that uses uIP, and
5532 + * is called by uIP whenever a log message is generated.
5533 + */
5534 +void uip_log(char *msg);
5535 +
5536 +/**
5537 + * The link level header length.
5538 + *
5539 + * This is the offset into the uip_buf where the IP header can be
5540 + * found. For Ethernet, this should be set to 14. For SLIP, this
5541 + * should be set to 0.
5542 + *
5543 + * \hideinitializer
5544 + */
5545 +#define UIP_LLH_LEN 14
5546 +
5547 +
5548 +/** @} */
5549 +/*------------------------------------------------------------------------------*/
5550 +/**
5551 + * \defgroup uipoptcpu CPU architecture configuration
5552 + * @{
5553 + *
5554 + * The CPU architecture configuration is where the endianess of the
5555 + * CPU on which uIP is to be run is specified. Most CPUs today are
5556 + * little endian, and the most notable exception are the Motorolas
5557 + * which are big endian. The BYTE_ORDER macro should be changed to
5558 + * reflect the CPU architecture on which uIP is to be run.
5559 + */
5560 +#ifndef LITTLE_ENDIAN
5561 +#define LITTLE_ENDIAN 3412
5562 +#endif /* LITTLE_ENDIAN */
5563 +#ifndef BIG_ENDIAN
5564 +#define BIG_ENDIAN 1234
5565 +#endif /* BIGE_ENDIAN */
5566 +
5567 +/**
5568 + * The byte order of the CPU architecture on which uIP is to be run.
5569 + *
5570 + * This option can be either BIG_ENDIAN (Motorola byte order) or
5571 + * LITTLE_ENDIAN (Intel byte order).
5572 + *
5573 + * \hideinitializer
5574 + */
5575 +/*#ifndef BYTE_ORDER*/
5576 +#define BYTE_ORDER BIG_ENDIAN
5577 +/*#endif*/ /* BYTE_ORDER */
5578 +
5579 +/** @} */
5580 +/*------------------------------------------------------------------------------*/
5581 +
5582 +/**
5583 + * \defgroup uipoptapp Appication specific configurations
5584 + * @{
5585 + *
5586 + * An uIP application is implemented using a single application
5587 + * function that is called by uIP whenever a TCP/IP event occurs. The
5588 + * name of this function must be registered with uIP at compile time
5589 + * using the UIP_APPCALL definition.
5590 + *
5591 + * uIP applications can store the application state within the
5592 + * uip_conn structure by specifying the size of the application
5593 + * structure with the UIP_APPSTATE_SIZE macro.
5594 + *
5595 + * The file containing the definitions must be included in the
5596 + * uipopt.h file.
5597 + *
5598 + * The following example illustrates how this can look.
5599 + \code
5600 +
5601 +void httpd_appcall(void);
5602 +#define UIP_APPCALL httpd_appcall
5603 +
5604 +struct httpd_state {
5605 + u8_t state;
5606 + u16_t count;
5607 + char *dataptr;
5608 + char *script;
5609 +};
5610 +#define UIP_APPSTATE_SIZE (sizeof(struct httpd_state))
5611 + \endcode
5612 + */
5613 +
5614 +/**
5615 + * \var #define UIP_APPCALL
5616 + *
5617 + * The name of the application function that uIP should call in
5618 + * response to TCP/IP events.
5619 + *
5620 + */
5621 +
5622 +/**
5623 + * \var #define UIP_APPSTATE_SIZE
5624 + *
5625 + * The size of the application state that is to be stored in the
5626 + * uip_conn structure.
5627 + */
5628 +/** @} */
5629 +
5630 +/* Include the header file for the application program that should be
5631 + used. If you don't use the example web server, you should change
5632 + this. */
5633 +#include "httpd.h"
5634 +
5635 +
5636 +#endif /* __UIPOPT_H__ */
5637 --- a/board/infineon/easy50712/danube.c
5638 +++ b/board/infineon/easy50712/danube.c
5639 @@ -354,7 +354,7 @@ int do_http_upgrade(const unsigned char
5640 }
5641 /* write the image to the flash */
5642 puts("http ugrade ...\n");
5643 - sprintf(buf, "era ${kernel_addr} +0x%x; cp.b ${ram_addr} ${kernel_addr} 0x%x", size, size);
5644 + sprintf(buf, "era ${kernel_addr} +0x%lx; cp.b ${ram_addr} ${kernel_addr} 0x%lx", size, size);
5645 return run_command(buf, 0);
5646 }
5647
5648 --- a/common/main.c
5649 +++ b/common/main.c
5650 @@ -273,6 +273,8 @@ static __inline__ int abortboot(int boot
5651
5652 void main_loop (void)
5653 {
5654 + int ret;
5655 +
5656 #ifndef CONFIG_SYS_HUSH_PARSER
5657 static char lastcommand[CONFIG_SYS_CBSIZE] = { 0, };
5658 int len;
5659 @@ -403,12 +407,22 @@ void main_loop (void)
5660 # endif
5661
5662 # ifndef CONFIG_SYS_HUSH_PARSER
5663 - run_command (s, 0);
5664 + ret = run_command (s, 0);
5665 # else
5666 - parse_string_outer(s, FLAG_PARSE_SEMICOLON |
5667 + ret = parse_string_outer(s, FLAG_PARSE_SEMICOLON |
5668 FLAG_EXIT_FROM_LOOP);
5669 # endif
5670
5671 +# ifdef CONFIG_CMD_HTTPD
5672 + if (ret != 0) {
5673 + printf("Failed to execute bootcmd "
5674 + "(maybe invalid u-boot environment?), "
5675 + "starting httpd to update firmware...\n");
5676 + NetLoopHttpd();
5677 + }
5678 +# endif
5679 +
5680 +
5681 # ifdef CONFIG_AUTOBOOT_KEYED
5682 disable_ctrlc(prev); /* restore Control C checking */
5683 # endif
5684 --- a/include/configs/easy50712.h
5685 +++ b/include/configs/easy50712.h
5686 @@ -114,4 +114,7 @@
5687
5688 #define CONFIG_CMD_HTTPD /* enable upgrade via HTTPD */
5689
5690 +#define CONFIG_IPADDR 192.168.0.119
5691 +#define CONFIG_ETHADDR 00:01:02:03:04:05
5692 +
5693 #endif /* __CONFIG_H */
5694 --- a/lib_mips/time.c
5695 +++ b/lib_mips/time.c
5696 @@ -29,6 +29,8 @@ static unsigned long timestamp;
5697 /* how many counter cycles in a jiffy */
5698 #define CYCLES_PER_JIFFY (CONFIG_SYS_MIPS_TIMER_FREQ + CONFIG_SYS_HZ / 2) / CONFIG_SYS_HZ
5699
5700 +unsigned long ifx_get_cpuclk(void);
5701 +
5702 /*
5703 * timer without interrupts
5704 */
5705 --- a/net/httpd.c
5706 +++ b/net/httpd.c
5707 @@ -35,12 +35,14 @@ HttpdHandler (void)
5708 }
5709 }
5710
5711 +#if 0
5712 static void
5713 HttpdTimeout (void)
5714 {
5715 puts ("T ");
5716 NetSetTimeout (TIMEOUT * 1000, HttpdTimeout);
5717 }
5718 +#endif
5719
5720 void
5721 HttpdStart (void)
5722 --- a/net/net.c
5723 +++ b/net/net.c
5724 @@ -1966,7 +1966,7 @@ NetSendHttpd(void)
5725 void
5726 NetReceiveHttpd(volatile uchar * inpkt, int len)
5727 {
5728 - memcpy(uip_buf, inpkt, len);
5729 + memcpy(uip_buf, (const void *)inpkt, len);
5730 uip_len = len;
5731 if(BUF->type == htons(UIP_ETHTYPE_IP)) {
5732 uip_arp_ipin();
5733 @@ -1989,6 +1989,7 @@ NetLoopHttpd(void)
5734 unsigned long long tout = 0;
5735 bd_t *bd = gd->bd;
5736 unsigned short int ip[2];
5737 + struct uip_eth_addr eaddr;
5738
5739 #ifdef CONFIG_NET_MULTI
5740 NetRestarted = 0;
5741 @@ -2039,6 +2040,15 @@ restart:
5742 eth_getenv_enetaddr("ethaddr", NetOurEther);
5743 #endif
5744
5745 + eaddr.addr[0] = NetOurEther[0];
5746 + eaddr.addr[1] = NetOurEther[1];
5747 + eaddr.addr[2] = NetOurEther[2];
5748 + eaddr.addr[3] = NetOurEther[3];
5749 + eaddr.addr[4] = NetOurEther[4];
5750 + eaddr.addr[5] = NetOurEther[5];
5751 +
5752 + uip_setethaddr(eaddr);
5753 +
5754 NetCopyIP(&NetOurIP, &bd->bi_ip_addr);
5755 NetOurGatewayIP = getenv_IPaddr ("gatewayip");
5756 NetOurSubnetMask= getenv_IPaddr ("netmask");
5757 @@ -2072,6 +2082,14 @@ restart:
5758 tout = t1;
5759 }
5760 }
5761 +
5762 + if (ctrlc()) {
5763 + eth_halt();
5764 + puts ("\nAbort\n");
5765 + return (-1);
5766 + }
5767 +
5768 +
5769 if(!httpd_upload_complete)
5770 continue;
5771 printf("Bytes transferred = %ld (%lx hex)\n",
5772 --- a/net/uip-0.9/fsdata.c
5773 +++ b/net/uip-0.9/fsdata.c
5774 @@ -1,199 +1,108 @@
5775 -static const char data_flashing_html[] = {
5776 - /* /flashing.html */
5777 - 0x2f, 0x66, 0x6c, 0x61, 0x73, 0x68, 0x69, 0x6e, 0x67, 0x2e, 0x68, 0x74, 0x6d, 0x6c, 0,
5778 - 0x48, 0x54, 0x54, 0x50, 0x2f, 0x31, 0x2e, 0x30, 0x20, 0x32,
5779 - 0x30, 0x30, 0x20, 0x4f, 0x4b, 0xd, 0xa, 0x53, 0x65, 0x72,
5780 - 0x76, 0x65, 0x72, 0x3a, 0x20, 0x75, 0x49, 0x50, 0x2f, 0x30,
5781 - 0x2e, 0x39, 0x20, 0x28, 0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f,
5782 - 0x2f, 0x64, 0x75, 0x6e, 0x6b, 0x65, 0x6c, 0x73, 0x2e, 0x63,
5783 - 0x6f, 0x6d, 0x2f, 0x61, 0x64, 0x61, 0x6d, 0x2f, 0x75, 0x69,
5784 - 0x70, 0x2f, 0x29, 0xd, 0xa, 0x43, 0x6f, 0x6e, 0x74, 0x65,
5785 - 0x6e, 0x74, 0x2d, 0x74, 0x79, 0x70, 0x65, 0x3a, 0x20, 0x74,
5786 - 0x65, 0x78, 0x74, 0x2f, 0x68, 0x74, 0x6d, 0x6c, 0xd, 0xa,
5787 - 0xd, 0xa, 0x3c, 0x68, 0x74, 0x6d, 0x6c, 0x3e, 0x3c, 0x62,
5788 - 0x6f, 0x64, 0x79, 0x20, 0x73, 0x74, 0x79, 0x6c, 0x65, 0x3d,
5789 - 0x22, 0x6d, 0x61, 0x72, 0x67, 0x69, 0x6e, 0x3a, 0x20, 0x30,
5790 - 0x70, 0x74, 0x20, 0x61, 0x75, 0x74, 0x6f, 0x3b, 0x20, 0x68,
5791 - 0x65, 0x69, 0x67, 0x68, 0x74, 0x3a, 0x31, 0x30, 0x30, 0x25,
5792 - 0x3b, 0x20, 0x63, 0x6f, 0x6c, 0x6f, 0x72, 0x3a, 0x20, 0x23,
5793 - 0x66, 0x66, 0x66, 0x3b, 0x20, 0x62, 0x61, 0x63, 0x6b, 0x67,
5794 - 0x72, 0x6f, 0x75, 0x6e, 0x64, 0x2d, 0x63, 0x6f, 0x6c, 0x6f,
5795 - 0x72, 0x3a, 0x20, 0x23, 0x66, 0x62, 0x62, 0x30, 0x33, 0x34,
5796 - 0x3b, 0x22, 0x3e, 0x3c, 0x63, 0x65, 0x6e, 0x74, 0x65, 0x72,
5797 - 0x3e, 0x3c, 0x68, 0x31, 0x3e, 0x55, 0x70, 0x67, 0x72, 0x61,
5798 - 0x64, 0x69, 0x6e, 0x67, 0x20, 0x73, 0x79, 0x73, 0x74, 0x65,
5799 - 0x6d, 0x20, 0x2e, 0x2e, 0x2e, 0x2e, 0x3c, 0x2f, 0x68, 0x31,
5800 - 0x3e, 0x3c, 0x2f, 0x63, 0x65, 0x6e, 0x74, 0x65, 0x72, 0x3e,
5801 - 0x3c, 0x2f, 0x62, 0x6f, 0x64, 0x79, 0x3e, 0x3c, 0x2f, 0x68,
5802 - 0x74, 0x6d, 0x6c, 0x3e, 0xa, };
5803 -
5804 -static const char data_fail_html[] = {
5805 - /* /fail.html */
5806 - 0x2f, 0x66, 0x61, 0x69, 0x6c, 0x2e, 0x68, 0x74, 0x6d, 0x6c, 0,
5807 - 0x48, 0x54, 0x54, 0x50, 0x2f, 0x31, 0x2e, 0x30, 0x20, 0x32,
5808 - 0x30, 0x30, 0x20, 0x4f, 0x4b, 0xd, 0xa, 0x53, 0x65, 0x72,
5809 - 0x76, 0x65, 0x72, 0x3a, 0x20, 0x75, 0x49, 0x50, 0x2f, 0x30,
5810 - 0x2e, 0x39, 0x20, 0x28, 0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f,
5811 - 0x2f, 0x64, 0x75, 0x6e, 0x6b, 0x65, 0x6c, 0x73, 0x2e, 0x63,
5812 - 0x6f, 0x6d, 0x2f, 0x61, 0x64, 0x61, 0x6d, 0x2f, 0x75, 0x69,
5813 - 0x70, 0x2f, 0x29, 0xd, 0xa, 0x43, 0x6f, 0x6e, 0x74, 0x65,
5814 - 0x6e, 0x74, 0x2d, 0x74, 0x79, 0x70, 0x65, 0x3a, 0x20, 0x74,
5815 - 0x65, 0x78, 0x74, 0x2f, 0x68, 0x74, 0x6d, 0x6c, 0xd, 0xa,
5816 - 0xd, 0xa, 0x3c, 0x68, 0x74, 0x6d, 0x6c, 0x3e, 0xa, 0x9,
5817 - 0x3c, 0x68, 0x65, 0x61, 0x64, 0x3e, 0xa, 0x9, 0x9, 0x3c,
5818 - 0x74, 0x69, 0x74, 0x6c, 0x65, 0x3e, 0xa, 0x9, 0x9, 0x9,
5819 - 0x4c, 0x61, 0x46, 0x6f, 0x6e, 0x65, 0x72, 0x61, 0x20, 0x46,
5820 - 0x61, 0x69, 0x6c, 0x73, 0x61, 0x66, 0x65, 0x20, 0x55, 0x49,
5821 - 0xa, 0x9, 0x9, 0x3c, 0x2f, 0x74, 0x69, 0x74, 0x6c, 0x65,
5822 - 0x3e, 0xa, 0x9, 0x3c, 0x62, 0x6f, 0x64, 0x79, 0x3e, 0xa,
5823 - 0x9, 0x9, 0x3c, 0x68, 0x31, 0x3e, 0x46, 0x6c, 0x61, 0x73,
5824 - 0x68, 0x69, 0x6e, 0x67, 0x20, 0x66, 0x61, 0x69, 0x6c, 0x65,
5825 - 0x64, 0x3c, 0x2f, 0x68, 0x31, 0x3e, 0xa, 0x9, 0x9, 0x45,
5826 - 0x52, 0x52, 0x4f, 0x52, 0x20, 0x2d, 0x20, 0x74, 0x68, 0x65,
5827 - 0x20, 0x69, 0x6d, 0x61, 0x67, 0x65, 0x20, 0x79, 0x6f, 0x75,
5828 - 0x20, 0x75, 0x70, 0x6c, 0x6f, 0x61, 0x64, 0x65, 0x64, 0x20,
5829 - 0x66, 0x61, 0x69, 0x6c, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x20,
5830 - 0x70, 0x61, 0x73, 0x73, 0x20, 0x76, 0x65, 0x72, 0x69, 0x66,
5831 - 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x20, 0x50,
5832 - 0x6c, 0x65, 0x61, 0x73, 0x65, 0x20, 0x6d, 0x61, 0x6b, 0x65,
5833 - 0x20, 0x73, 0x75, 0x72, 0x65, 0x20, 0x74, 0x6f, 0x20, 0x75,
5834 - 0x73, 0x65, 0x20, 0x61, 0x6e, 0x20, 0x6f, 0x66, 0x66, 0x69,
5835 - 0x63, 0x69, 0x61, 0x6c, 0x20, 0x75, 0x70, 0x64, 0x61, 0x74,
5836 - 0x65, 0x20, 0x70, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x64,
5837 - 0x20, 0x62, 0x79, 0x20, 0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f,
5838 - 0x2f, 0x64, 0x6f, 0x77, 0x6e, 0x6c, 0x6f, 0x61, 0x64, 0x2e,
5839 - 0x66, 0x6f, 0x6e, 0x6f, 0x73, 0x66, 0x65, 0x72, 0x61, 0x2e,
5840 - 0x6f, 0x72, 0x67, 0x2f, 0xa, 0x9, 0x3c, 0x2f, 0x62, 0x6f,
5841 - 0x64, 0x79, 0x3e, 0xa, 0x3c, 0x2f, 0x68, 0x74, 0x6d, 0x6c,
5842 - 0x3e, 0xa, };
5843 -
5844 -static const char data_404_html[] = {
5845 - /* /404.html */
5846 - 0x2f, 0x34, 0x30, 0x34, 0x2e, 0x68, 0x74, 0x6d, 0x6c, 0,
5847 - 0x48, 0x54, 0x54, 0x50, 0x2f, 0x31, 0x2e, 0x30, 0x20, 0x34,
5848 - 0x30, 0x34, 0x20, 0x46, 0x69, 0x6c, 0x65, 0x20, 0x6e, 0x6f,
5849 - 0x74, 0x20, 0x66, 0x6f, 0x75, 0x6e, 0x64, 0xd, 0xa, 0x53,
5850 - 0x65, 0x72, 0x76, 0x65, 0x72, 0x3a, 0x20, 0x75, 0x49, 0x50,
5851 - 0x2f, 0x30, 0x2e, 0x39, 0x20, 0x28, 0x68, 0x74, 0x74, 0x70,
5852 - 0x3a, 0x2f, 0x2f, 0x64, 0x75, 0x6e, 0x6b, 0x65, 0x6c, 0x73,
5853 - 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x61, 0x64, 0x61, 0x6d, 0x2f,
5854 - 0x75, 0x69, 0x70, 0x2f, 0x29, 0xd, 0xa, 0x43, 0x6f, 0x6e,
5855 - 0x74, 0x65, 0x6e, 0x74, 0x2d, 0x74, 0x79, 0x70, 0x65, 0x3a,
5856 - 0x20, 0x74, 0x65, 0x78, 0x74, 0x2f, 0x68, 0x74, 0x6d, 0x6c,
5857 - 0xd, 0xa, 0xd, 0xa, 0x3c, 0x68, 0x74, 0x6d, 0x6c, 0x3e,
5858 - 0x3c, 0x62, 0x6f, 0x64, 0x79, 0x20, 0x62, 0x67, 0x63, 0x6f,
5859 - 0x6c, 0x6f, 0x72, 0x3d, 0x22, 0x77, 0x68, 0x69, 0x74, 0x65,
5860 - 0x22, 0x3e, 0x3c, 0x63, 0x65, 0x6e, 0x74, 0x65, 0x72, 0x3e,
5861 - 0x3c, 0x68, 0x31, 0x3e, 0x34, 0x30, 0x34, 0x20, 0x2d, 0x20,
5862 - 0x66, 0x69, 0x6c, 0x65, 0x20, 0x6e, 0x6f, 0x74, 0x20, 0x66,
5863 - 0x6f, 0x75, 0x6e, 0x64, 0x3c, 0x2f, 0x68, 0x31, 0x3e, 0x3c,
5864 - 0x2f, 0x63, 0x65, 0x6e, 0x74, 0x65, 0x72, 0x3e, 0x3c, 0x2f,
5865 - 0x62, 0x6f, 0x64, 0x79, 0x3e, 0x3c, 0x2f, 0x68, 0x74, 0x6d,
5866 - 0x6c, 0x3e, };
5867 -
5868 -static const char data_index_html[] = {
5869 - /* /index.html */
5870 - 0x2f, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x2e, 0x68, 0x74, 0x6d, 0x6c, 0,
5871 - 0x48, 0x54, 0x54, 0x50, 0x2f, 0x31, 0x2e, 0x30, 0x20, 0x32,
5872 - 0x30, 0x30, 0x20, 0x4f, 0x4b, 0xd, 0xa, 0x53, 0x65, 0x72,
5873 - 0x76, 0x65, 0x72, 0x3a, 0x20, 0x75, 0x49, 0x50, 0x2f, 0x30,
5874 - 0x2e, 0x39, 0x20, 0x28, 0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f,
5875 - 0x2f, 0x64, 0x75, 0x6e, 0x6b, 0x65, 0x6c, 0x73, 0x2e, 0x63,
5876 - 0x6f, 0x6d, 0x2f, 0x61, 0x64, 0x61, 0x6d, 0x2f, 0x75, 0x69,
5877 - 0x70, 0x2f, 0x29, 0xd, 0xa, 0x43, 0x6f, 0x6e, 0x74, 0x65,
5878 - 0x6e, 0x74, 0x2d, 0x74, 0x79, 0x70, 0x65, 0x3a, 0x20, 0x74,
5879 - 0x65, 0x78, 0x74, 0x2f, 0x68, 0x74, 0x6d, 0x6c, 0xd, 0xa,
5880 - 0xd, 0xa, 0x3c, 0x68, 0x74, 0x6d, 0x6c, 0x3e, 0xa, 0x9,
5881 - 0x3c, 0x68, 0x65, 0x61, 0x64, 0x3e, 0xa, 0x9, 0x9, 0x3c,
5882 - 0x74, 0x69, 0x74, 0x6c, 0x65, 0x3e, 0xa, 0x9, 0x9, 0x9,
5883 - 0x4c, 0x61, 0x46, 0x6f, 0x6e, 0x65, 0x72, 0x61, 0x20, 0x46,
5884 - 0x61, 0x69, 0x6c, 0x73, 0x61, 0x66, 0x65, 0x20, 0x55, 0x49,
5885 - 0xa, 0x9, 0x9, 0x3c, 0x2f, 0x74, 0x69, 0x74, 0x6c, 0x65,
5886 - 0x3e, 0xa, 0x9, 0x3c, 0x2f, 0x68, 0x65, 0x61, 0x64, 0x3e,
5887 - 0xa, 0x9, 0x3c, 0x62, 0x6f, 0x64, 0x79, 0x20, 0x73, 0x74,
5888 - 0x79, 0x6c, 0x65, 0x3d, 0x22, 0x6d, 0x61, 0x72, 0x67, 0x69,
5889 - 0x6e, 0x3a, 0x20, 0x30, 0x70, 0x74, 0x20, 0x61, 0x75, 0x74,
5890 - 0x6f, 0x3b, 0x20, 0x68, 0x65, 0x69, 0x67, 0x68, 0x74, 0x3a,
5891 - 0x31, 0x30, 0x30, 0x25, 0x3b, 0x20, 0x63, 0x6f, 0x6c, 0x6f,
5892 - 0x72, 0x3a, 0x20, 0x23, 0x30, 0x30, 0x30, 0x3b, 0x20, 0x62,
5893 - 0x61, 0x63, 0x6b, 0x67, 0x72, 0x6f, 0x75, 0x6e, 0x64, 0x2d,
5894 - 0x63, 0x6f, 0x6c, 0x6f, 0x72, 0x3a, 0x20, 0x23, 0x66, 0x62,
5895 - 0x62, 0x30, 0x33, 0x34, 0x3b, 0x22, 0x3e, 0xa, 0x9, 0x9,
5896 - 0x3c, 0x68, 0x31, 0x3e, 0x4c, 0x61, 0x46, 0x6f, 0x6e, 0x65,
5897 - 0x72, 0x61, 0x20, 0x46, 0x61, 0x69, 0x6c, 0x73, 0x61, 0x66,
5898 - 0x65, 0x20, 0x55, 0x49, 0x3c, 0x2f, 0x68, 0x31, 0x3e, 0xa,
5899 - 0x9, 0x9, 0x3c, 0x66, 0x6f, 0x72, 0x6d, 0x20, 0x6d, 0x65,
5900 - 0x74, 0x68, 0x6f, 0x64, 0x3d, 0x22, 0x70, 0x6f, 0x73, 0x74,
5901 - 0x22, 0x20, 0x65, 0x6e, 0x63, 0x74, 0x79, 0x70, 0x65, 0x3d,
5902 - 0x22, 0x6d, 0x75, 0x6c, 0x74, 0x69, 0x70, 0x61, 0x72, 0x74,
5903 - 0x2f, 0x66, 0x6f, 0x72, 0x6d, 0x2d, 0x64, 0x61, 0x74, 0x61,
5904 - 0x22, 0x3e, 0xa, 0x9, 0x9, 0x9, 0x3c, 0x69, 0x6e, 0x70,
5905 - 0x75, 0x74, 0x20, 0x74, 0x79, 0x70, 0x65, 0x3d, 0x66, 0x69,
5906 - 0x6c, 0x65, 0x20, 0x6e, 0x61, 0x6d, 0x65, 0x3d, 0x66, 0x69,
5907 - 0x72, 0x6d, 0x77, 0x61, 0x72, 0x65, 0x3e, 0xa, 0x9, 0x9,
5908 - 0x9, 0x3c, 0x69, 0x6e, 0x70, 0x75, 0x74, 0x20, 0x74, 0x79,
5909 - 0x70, 0x65, 0x3d, 0x73, 0x75, 0x62, 0x6d, 0x69, 0x74, 0x3e,
5910 - 0xa, 0x9, 0x9, 0x3c, 0x2f, 0x66, 0x6f, 0x72, 0x6d, 0x3e,
5911 - 0xa, 0x9, 0x3c, 0x2f, 0x62, 0x6f, 0x64, 0x79, 0x3e, 0xa,
5912 - 0x3c, 0x2f, 0x68, 0x74, 0x6d, 0x6c, 0x3e, 0xa, };
5913 -
5914 -static const char data_flash_html[] = {
5915 - /* /flash.html */
5916 - 0x2f, 0x66, 0x6c, 0x61, 0x73, 0x68, 0x2e, 0x68, 0x74, 0x6d, 0x6c, 0,
5917 - 0x48, 0x54, 0x54, 0x50, 0x2f, 0x31, 0x2e, 0x30, 0x20, 0x32,
5918 - 0x30, 0x30, 0x20, 0x4f, 0x4b, 0xd, 0xa, 0x53, 0x65, 0x72,
5919 - 0x76, 0x65, 0x72, 0x3a, 0x20, 0x75, 0x49, 0x50, 0x2f, 0x30,
5920 - 0x2e, 0x39, 0x20, 0x28, 0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f,
5921 - 0x2f, 0x64, 0x75, 0x6e, 0x6b, 0x65, 0x6c, 0x73, 0x2e, 0x63,
5922 - 0x6f, 0x6d, 0x2f, 0x61, 0x64, 0x61, 0x6d, 0x2f, 0x75, 0x69,
5923 - 0x70, 0x2f, 0x29, 0xd, 0xa, 0x43, 0x6f, 0x6e, 0x74, 0x65,
5924 - 0x6e, 0x74, 0x2d, 0x74, 0x79, 0x70, 0x65, 0x3a, 0x20, 0x74,
5925 - 0x65, 0x78, 0x74, 0x2f, 0x68, 0x74, 0x6d, 0x6c, 0xd, 0xa,
5926 - 0xd, 0xa, 0x3c, 0x68, 0x74, 0x6d, 0x6c, 0x3e, 0xa, 0x9,
5927 - 0x3c, 0x68, 0x65, 0x61, 0x64, 0x3e, 0xa, 0x9, 0x9, 0x3c,
5928 - 0x74, 0x69, 0x74, 0x6c, 0x65, 0x3e, 0xa, 0x9, 0x9, 0x9,
5929 - 0x4c, 0x61, 0x46, 0x6f, 0x6e, 0x65, 0x72, 0x61, 0x20, 0x46,
5930 - 0x61, 0x69, 0x6c, 0x73, 0x61, 0x66, 0x65, 0x20, 0x55, 0x49,
5931 - 0xa, 0x9, 0x9, 0x3c, 0x2f, 0x74, 0x69, 0x74, 0x6c, 0x65,
5932 - 0x3e, 0xa, 0x9, 0x3c, 0x2f, 0x68, 0x65, 0x61, 0x64, 0x3e,
5933 - 0xa, 0x9, 0x3c, 0x62, 0x6f, 0x64, 0x79, 0x20, 0x73, 0x74,
5934 - 0x79, 0x6c, 0x65, 0x3d, 0x22, 0x6d, 0x61, 0x72, 0x67, 0x69,
5935 - 0x6e, 0x3a, 0x20, 0x30, 0x70, 0x74, 0x20, 0x61, 0x75, 0x74,
5936 - 0x6f, 0x3b, 0x20, 0x68, 0x65, 0x69, 0x67, 0x68, 0x74, 0x3a,
5937 - 0x31, 0x30, 0x30, 0x25, 0x3b, 0x20, 0x63, 0x6f, 0x6c, 0x6f,
5938 - 0x72, 0x3a, 0x20, 0x23, 0x30, 0x30, 0x30, 0x3b, 0x20, 0x62,
5939 - 0x61, 0x63, 0x6b, 0x67, 0x72, 0x6f, 0x75, 0x6e, 0x64, 0x2d,
5940 - 0x63, 0x6f, 0x6c, 0x6f, 0x72, 0x3a, 0x20, 0x23, 0x66, 0x62,
5941 - 0x62, 0x30, 0x33, 0x34, 0x3b, 0x22, 0x3e, 0xa, 0x9, 0x9,
5942 - 0x3c, 0x68, 0x31, 0x3e, 0x46, 0x6c, 0x61, 0x73, 0x68, 0x69,
5943 - 0x6e, 0x67, 0x3c, 0x2f, 0x68, 0x31, 0x3e, 0xa, 0x9, 0x9,
5944 - 0x54, 0x68, 0x65, 0x20, 0x73, 0x79, 0x73, 0x74, 0x65, 0x6d,
5945 - 0x20, 0x69, 0x73, 0x20, 0x6e, 0x6f, 0x77, 0x20, 0x74, 0x72,
5946 - 0x79, 0x69, 0x6e, 0x67, 0x20, 0x74, 0x6f, 0x20, 0x66, 0x6c,
5947 - 0x61, 0x73, 0x68, 0x2e, 0x20, 0x49, 0x66, 0x20, 0x74, 0x68,
5948 - 0x65, 0x72, 0x65, 0x20, 0x69, 0x73, 0x20, 0x61, 0x20, 0x70,
5949 - 0x72, 0x6f, 0x62, 0x6c, 0x65, 0x6d, 0x2c, 0x20, 0x74, 0x68,
5950 - 0x65, 0x20, 0x6c, 0x65, 0x64, 0x73, 0x20, 0x77, 0x69, 0x6c,
5951 - 0x6c, 0x20, 0x73, 0x74, 0x61, 0x72, 0x74, 0x20, 0x74, 0x6f,
5952 - 0x20, 0x62, 0x6c, 0x69, 0x6e, 0x6b, 0x2e, 0xa, 0xa, 0x9,
5953 - 0x9, 0x41, 0x66, 0x74, 0x65, 0x72, 0x20, 0x61, 0x20, 0x73,
5954 - 0x75, 0x63, 0x63, 0x65, 0x73, 0x73, 0x66, 0x75, 0x6c, 0x6c,
5955 - 0x20, 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, 0x20, 0x74, 0x68,
5956 - 0x65, 0x20, 0x62, 0x6f, 0x78, 0x20, 0x77, 0x69, 0x6c, 0x6c,
5957 - 0x20, 0x72, 0x65, 0x62, 0x6f, 0x6f, 0x74, 0xa, 0x9, 0x3c,
5958 - 0x2f, 0x62, 0x6f, 0x64, 0x79, 0x3e, 0xa, 0x3c, 0x2f, 0x68,
5959 - 0x74, 0x6d, 0x6c, 0x3e, 0xa, };
5960 -
5961 -const struct fsdata_file file_flashing_html[] = {{NULL, data_flashing_html, data_flashing_html + 15, sizeof(data_flashing_html) - 15}};
5962 +static const char data_flashing_html[] =
5963 +"HTTP/1.0 200 OK\n"
5964 +"Server: uIP/0.9 (http://dunkels.com/adam/uip/)\n"
5965 +"Content-type: text/html\n"
5966 +"\n"
5967 +"<html>\n"
5968 +"\t<head>\n"
5969 +"\t\t<title>\n"
5970 +"\t\t\tFailsafe UI\n"
5971 +"\t\t</title>\n"
5972 +"\t</head>\n"
5973 +"\t<body>\n"
5974 +"\t\t<center><h1>Upgrading system...</h1></center>\n"
5975 +"\t</body>\n"
5976 +"</html>\n";
5977 +
5978 +static const char data_fail_html[] =
5979 +"HTTP/1.0 200 OK\n"
5980 +"Server: uIP/0.9 (http://dunkels.com/adam/uip/)\n"
5981 +"Content-type: text/html\n"
5982 +"\n"
5983 +"<html>\n"
5984 +"\t<head>\n"
5985 +"\t\t<title>\n"
5986 +"\t\t\tFailsafe UI\n"
5987 +"\t\t</title>\n"
5988 +"\t</head>\n"
5989 +"\t<body>\n"
5990 +"\t\t<h1>Flashing failed</h1>\n"
5991 +"\t\tERROR - the image you uploaded failed to pass verification.<br>\n"
5992 +"\t\tPlease make sure to use an official update provided by http://lantiq.com/\n"
5993 +"\t</body>\n"
5994 +"</html>\n";
5995 +
5996 +static const char data_404_html[] =
5997 +"HTTP/1.0 404 File not found\n"
5998 +"Server: uIP/0.9 (http://dunkels.com/adam/uip/)\n"
5999 +"Content-type: text/html\n"
6000 +"\n"
6001 +"<html>\n"
6002 +"\t<head>\n"
6003 +"\t\t<title>\n"
6004 +"\t\t\tFailsafe UI\n"
6005 +"\t\t</title>\n"
6006 +"\t</head>\n"
6007 +"\t<body>\n"
6008 +"\t\t<center><h1>404 - file not found</h1></center>\n"
6009 +"\t</body>\n"
6010 +"</html>\n";
6011 +
6012 +static const char data_index_html[] =
6013 +"HTTP/1.0 200 OK\n"
6014 +"Server: uIP/0.9 (http://dunkels.com/adam/uip/)\n"
6015 +"Content-type: text/html\n"
6016 +"\n"
6017 +"<html>\n"
6018 +"\t<head>\n"
6019 +"\t\t<title>\n"
6020 +"\t\t\tFailsafe UI\n"
6021 +"\t\t</title>\n"
6022 +"\t</head>\n"
6023 +"\t<body>\n"
6024 +"\t\t<h1>Failsafe UI</h1>\n"
6025 +"\t\t<form method=\"post\" enctype=\"multipart/form-data\">\n"
6026 +"\t\t\t<input type=file name=firmware>\n"
6027 +"\t\t\t<input type=submit>\n"
6028 +"\t\t</form>\n"
6029 +"\t</body>\n"
6030 +"</html>\n";
6031 +
6032 +static const char data_flash_html[] =
6033 +"HTTP/1.0 200 OK\n"
6034 +"Server: uIP/0.9 (http://dunkels.com/adam/uip/)\n"
6035 +"Content-type: text/html\n"
6036 +"\n"
6037 +"<html>\n"
6038 +"\t<head>\n"
6039 +"\t\t<title>\n"
6040 +"\t\t\tFailsafe UI\n"
6041 +"\t\t</title>\n"
6042 +"\t</head>\n"
6043 +"\t<body>\n"
6044 +"\t\t<h1>Flashing...</h1>\n"
6045 +"\t\tThe system is now trying to flash. If there is a problem, the LEDs will "
6046 +"start to blink.<br>\n"
6047 +"\n"
6048 +"\t\tAfter a successful update the box will reboot\n"
6049 +"\t</body>\n"
6050 +"</html>\n";
6051 +
6052 +const struct fsdata_file file_flashing_html[] =
6053 +{{NULL, "/flashing.html", data_flashing_html, sizeof(data_flashing_html)}};
6054 +
6055 +const struct fsdata_file file_fail_html[] =
6056 +{{file_flashing_html, "/fail.html", data_fail_html, sizeof(data_fail_html)}};
6057
6058 -const struct fsdata_file file_fail_html[] = {{file_flashing_html, data_fail_html, data_fail_html + 11, sizeof(data_fail_html) - 11}};
6059 +const struct fsdata_file file_404_html[] =
6060 +{{file_fail_html, "/404.html", data_404_html, sizeof(data_404_html)}};
6061
6062 -const struct fsdata_file file_404_html[] = {{file_fail_html, data_404_html, data_404_html + 10, sizeof(data_404_html) - 10}};
6063 +const struct fsdata_file file_index_html[] =
6064 +{{file_404_html, "/index.html", data_index_html, sizeof(data_index_html)}};
6065
6066 -const struct fsdata_file file_index_html[] = {{file_404_html, data_index_html, data_index_html + 12, sizeof(data_index_html) - 12}};
6067 -
6068 -const struct fsdata_file file_flash_html[] = {{file_index_html, data_flash_html, data_flash_html + 12, sizeof(data_flash_html) - 12}};
6069 +const struct fsdata_file file_flash_html[] =
6070 +{{file_index_html, "/flash.html", data_flash_html, sizeof(data_flash_html)}};
6071
6072 #define FS_ROOT file_flash_html
6073
6074 -#define FS_NUMFILES 5
6075 \ No newline at end of file
6076 +#define FS_NUMFILES 5
6077 --- a/net/uip-0.9/httpd.c
6078 +++ b/net/uip-0.9/httpd.c
6079 @@ -130,7 +130,7 @@ httpd_appcall(void)
6080 if(!fs_open((const char *)&uip_appdata[4], &fsfile))
6081 {
6082 PRINTLN("couldn't open file");
6083 - fs_open(file_index_html.name, &fsfile);
6084 + fs_open(file_404_html.name, &fsfile);
6085 }
6086 }
6087 hs->script = 0;
6088 @@ -141,7 +141,7 @@ httpd_appcall(void)
6089 if(hs->state == HTTP_FIRMWARE)
6090 {
6091 unsigned char *start = (unsigned char*)uip_appdata;
6092 - char *clen = strstr(start, "Content-Length:");
6093 + char *clen = strstr((char *)start, "Content-Length:");
6094 int len = 0;
6095 unsigned char *next, *end;
6096 unsigned char *boundary_start;
6097 @@ -150,14 +150,14 @@ httpd_appcall(void)
6098 if(clen)
6099 {
6100 clen += sizeof("Content-Length:");
6101 - next = strstr(clen, eol);
6102 + next = (unsigned char *)strstr(clen, eol);
6103 if(next)
6104 {
6105 len = atoi(clen);
6106 next++;
6107 printf("expecting %d bytes\n", len);
6108 upload_data = httpd_upload_data = (unsigned char *)do_http_tmp_address();
6109 - printf("received data will be stored at 0x%08X\n", upload_data);
6110 + printf("received data will be stored at %p\n", upload_data);
6111 if(!upload_data)
6112 {
6113 printf("failed to allocate memory\n");
6114 @@ -174,14 +174,14 @@ httpd_appcall(void)
6115 uip_close();
6116 return;
6117 }
6118 - boundary_start = strstr(next, "---");
6119 + boundary_start = (unsigned char *)strstr((char *)next, "---");
6120 if(!boundary_start)
6121 {
6122 uip_close();
6123 return;
6124 }
6125 - end = strstr(boundary_start, eol);
6126 - if(!eol)
6127 + end = (unsigned char *)strstr((char *)boundary_start, eol);
6128 + if(!end)
6129 {
6130 uip_close();
6131 return;
6132 @@ -189,13 +189,13 @@ httpd_appcall(void)
6133 boundary_len = end - boundary_start;
6134 memcpy(boundary, boundary_start, boundary_len);
6135 boundary[boundary_len] = 0;
6136 - next = strstr(boundary_start, "name=\"firmware\";");
6137 + next = (unsigned char *)strstr((char *)boundary_start, "name=\"firmware\";");
6138 if(!next)
6139 {
6140 uip_close();
6141 return;
6142 }
6143 - next = strstr(next, eol2);
6144 + next = (unsigned char *)strstr((char *)next, eol2);
6145 if(!next)
6146 {
6147 printf("could not find start of data\n");
6148 @@ -259,7 +259,6 @@ httpd_appcall(void)
6149 {
6150 if(upload_running)
6151 {
6152 - int i;
6153 httpd_upload_complete = 1;
6154 // for(i = 0; i < hs->upload_total; i++)
6155 // printf("%c", httpd_upload_data[i]);
6156 @@ -267,7 +266,7 @@ httpd_appcall(void)
6157 uip_close();
6158 }
6159 }
6160 - uip_send(hs->dataptr, hs->count);
6161 + uip_send((unsigned char *)hs->dataptr, hs->count);
6162 }
6163 break;
6164
Personal OpenWRT clone
This page took 0.306038 seconds and 5 git commands to generate.