add ipv6 support

components/net/lwip-head/COPYING

+/*
+ * Copyright (c) 2001, 2002 Swedish Institute of Computer Science.
+ * All rights reserved. 
+ * 
+ * Redistribution and use in source and binary forms, with or without modification, 
+ * are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ * 3. The name of the author may not be used to endorse or promote products
+ *    derived from this software without specific prior written permission. 
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED 
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF 
+ * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT 
+ * SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, 
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT 
+ * OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING 
+ * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY 
+ * OF SUCH DAMAGE.
+ *
+ * This file is part of the lwIP TCP/IP stack.
+ * 
+ * Author: Adam Dunkels <adam@sics.se>
+ *
+ */
+
+

components/net/lwip-head/FILES

+src/      - The source code for the lwIP TCP/IP stack.
+doc/      - The documentation for lwIP.
+
+See also the FILES file in each subdirectory.

components/net/lwip-head/README

+INTRODUCTION
+
+lwIP is a small independent implementation of the TCP/IP protocol
+suite that has been developed by Adam Dunkels at the Computer and
+Networks Architectures (CNA) lab at the Swedish Institute of Computer
+Science (SICS).
+
+The focus of the lwIP TCP/IP implementation is to reduce the RAM usage
+while still having a full scale TCP. This making lwIP suitable for use
+in embedded systems with tens of kilobytes of free RAM and room for
+around 40 kilobytes of code ROM.
+
+FEATURES
+
+  * IP (Internet Protocol) including packet forwarding over multiple network
+    interfaces
+  * ICMP (Internet Control Message Protocol) for network maintenance and debugging
+  * IGMP (Internet Group Management Protocol) for multicast traffic management
+  * UDP (User Datagram Protocol) including experimental UDP-lite extensions
+  * TCP (Transmission Control Protocol) with congestion control, RTT estimation
+    and fast recovery/fast retransmit
+  * Specialized raw/native API for enhanced performance
+  * Optional Berkeley-like socket API
+  * DNS (Domain names resolver)
+  * SNMP (Simple Network Management Protocol)
+  * DHCP (Dynamic Host Configuration Protocol)
+  * AUTOIP (for IPv4, conform with RFC 3927)
+  * PPP (Point-to-Point Protocol)
+  * ARP (Address Resolution Protocol) for Ethernet
+
+LICENSE
+
+lwIP is freely available under a BSD license.
+
+DEVELOPMENT
+
+lwIP has grown into an excellent TCP/IP stack for embedded devices,
+and developers using the stack often submit bug fixes, improvements,
+and additions to the stack to further increase its usefulness.
+
+Development of lwIP is hosted on Savannah, a central point for
+software development, maintenance and distribution. Everyone can
+help improve lwIP by use of Savannah's interface, CVS and the
+mailing list. A core team of developers will commit changes to the
+CVS source tree.
+
+The lwIP TCP/IP stack is maintained in the 'lwip' CVS module and
+contributions (such as platform ports) are in the 'contrib' module.
+
+See doc/savannah.txt for details on CVS server access for users and
+developers.
+
+Last night's CVS tar ball can be downloaded from:
+  http://savannah.gnu.org/cvs.backups/lwip.tar.gz [CHANGED - NEEDS FIXING]
+
+The current CVS trees are web-browsable:
+  http://savannah.nongnu.org/cgi-bin/viewcvs/lwip/lwip/
+  http://savannah.nongnu.org/cgi-bin/viewcvs/lwip/contrib/
+
+Submit patches and bugs via the lwIP project page:
+  http://savannah.nongnu.org/projects/lwip/
+
+
+DOCUMENTATION
+
+The original out-dated homepage of lwIP and Adam Dunkels' papers on
+lwIP are at the official lwIP home page:
+  http://www.sics.se/~adam/lwip/
+
+Self documentation of the source code is regularly extracted from the
+current CVS sources and is available from this web page:
+  http://www.nongnu.org/lwip/
+
+There is now a constantly growin wiki about lwIP at
+  http://lwip.wikia.com/wiki/LwIP_Wiki
+
+Also, there are mailing lists you can subscribe at
+  http://savannah.nongnu.org/mail/?group=lwip
+plus searchable archives:
+  http://lists.nongnu.org/archive/html/lwip-users/
+  http://lists.nongnu.org/archive/html/lwip-devel/
+
+Reading Adam's papers, the files in docs/, browsing the source code
+documentation and browsing the mailing list archives is a good way to
+become familiar with the design of lwIP.
+
+Adam Dunkels <adam@sics.se>
+Leon Woestenberg <leon.woestenberg@gmx.net>
+

components/net/lwip-head/SConscript

+Import('RTT_ROOT')
+from building import *
+
+src = Split("""
+src/api/api_lib.c
+src/api/api_msg.c
+src/api/err.c
+src/api/netbuf.c
+src/api/netdb.c
+src/api/netifapi.c
+src/api/sockets.c
+src/api/tcpip.c
+src/api/pppapi.c
+src/arch/sys_arch.c
+src/core/def.c
+src/core/dhcp.c
+src/core/dns.c
+src/core/init.c
+src/core/mem.c
+src/core/memp.c
+src/core/netif.c
+src/core/pbuf.c
+src/core/raw.c
+src/core/stats.c
+src/core/sys.c
+src/core/tcp.c
+src/core/tcp_in.c
+src/core/tcp_out.c
+src/core/timers.c
+src/core/udp.c
+src/core/inet_chksum.c
+src/core/ipv4/autoip.c
+src/core/ipv4/icmp.c
+src/core/ipv4/igmp.c
+src/core/ipv4/ip4.c
+src/core/ipv4/ip4_addr.c
+src/core/ipv4/ip_frag.c
+src/core/ipv6/dhcp6.c
+src/core/ipv6/ethip6.c
+src/core/ipv6/icmp6.c
+src/core/ipv6/inet6.c
+src/core/ipv6/ip6_addr.c
+src/core/ipv6/ip6.c
+src/core/ipv6/ip6_frag.c
+src/core/ipv6/mld6.c
+src/core/ipv6/nd6.c
+src/netif/etharp.c
+src/netif/ethernetif.c
+src/netif/slipif.c
+""")
+
+snmp_src = Split("""
+src/core/snmp/asn1_dec.c
+src/core/snmp/asn1_enc.c
+src/core/snmp/mib2.c
+src/core/snmp/mib_structs.c
+src/core/snmp/msg_in.c
+src/core/snmp/msg_out.c
+""")
+
+ppp_src = Split("""
+src/netif/ppp/auth.c
+src/netif/ppp/ccp.c
+src/netif/ppp/chap_ms.c
+src/netif/ppp/chap_md5.c
+src/netif/ppp/chap_new.c
+src/netif/ppp/demand.c
+src/netif/ppp/eap.c
+src/netif/ppp/ecp.c
+src/netif/ppp/eui64.c
+src/netif/ppp/fsm.c
+src/netif/ppp/ipcp.c
+src/netif/ppp/ipv6cp.c
+src/netif/ppp/lcp.c
+src/netif/ppp/magic.c
+src/netif/ppp/multilink.c
+src/netif/ppp/ppp.c
+src/netif/ppp/pppcrypt.c
+src/netif/ppp/pppoe.c
+src/netif/ppp/pppol2tp.c
+src/netif/ppp/upap.c
+src/netif/ppp/utils.c
+src/netif/ppp/vj.c
+src/netif/ppp/polarssl/des.c
+src/netif/ppp/polarssl/md4.c
+src/netif/ppp/polarssl/md5.c
+src/netif/ppp/polarssl/sha1.c
+""")
+
+# The set of source files associated with this SConscript file.
+path = [GetCurrentDir() + '/src',
+    GetCurrentDir() + '/src/include',
+    GetCurrentDir() + '/src/include/ipv4',
+	GetCurrentDir() + '/src/include/ipv6',
+    GetCurrentDir() + '/src/arch/include',
+    GetCurrentDir() + '/src/include/netif']
+
+if GetDepend(['RT_LWIP_SNMP']):
+    src += snmp_src
+
+if GetDepend(['RT_LWIP_PPP']):
+    src += ppp_src
+    path += [GetCurrentDir() + '/src/netif/ppp']
+
+# For testing apps
+if GetDepend(['RT_USING_NETUTILS']):
+    src += Glob('./apps/*.c')
+
+group = DefineGroup('LwIP', src, depend = ['RT_USING_LWIP', 'RT_USING_LWIP_HEAD'], CPPPATH = path)
+
+Return('group')

components/net/lwip-head/UPGRADING

+This file lists major changes between release versions that require
+ports or applications to be changed. Use it to update a port or an
+application written for an older version of lwIP to correctly work
+with newer versions.
+
+
+(CVS HEAD)
+
+  * [Enter new changes just after this line - do not remove this line]
+
+  ++ Application changes:
+
+  * Replaced struct ip_addr by typedef ip_addr_t (struct ip_addr is kept for
+    compatibility to old applications, but will be removed in the future).
+
+  * Renamed mem_realloc() to mem_trim() to prevent confusion with realloc()
+
+  +++ Raw API:
+    * Changed the semantics of tcp_close() (since it was rather a
+      shutdown before): Now the application does *NOT* get any calls to the recv
+      callback (aside from NULL/closed) after calling tcp_close()
+
+    * When calling tcp_abort() from a raw API TCP callback function,
+      make sure you return ERR_ABRT to prevent accessing unallocated memory.
+      (ERR_ABRT now means the applicaiton has called tcp_abort!)
+
+  +++ Netconn API:
+    * Changed netconn_receive() and netconn_accept() to return
+      err_t, not a pointer to new data/netconn.
+
+  +++ Socket API:
+    * LWIP_SO_RCVTIMEO: when accept() or recv() time out, they
+      now set errno to EWOULDBLOCK/EAGAIN, not ETIMEDOUT.
+
+    * Added a minimal version of posix fctl() to have a
+      standardised way to set O_NONBLOCK for nonblocking sockets.
+
+  +++ all APIs:
+    * correctly implemented SO(F)_REUSEADDR
+
+  ++ Port changes
+
+  +++ new files:
+
+    * Added 4 new files: def.c, timers.c, timers.h, tcp_impl.h:
+
+    * Moved stack-internal parts of tcp.h to tcp_impl.h, tcp.h now only contains
+      the actual application programmer's API
+  
+    * Separated timer implementation from sys.h/.c, moved to timers.h/.c;
+      Added timer implementation for NO_SYS==1, set NO_SYS_NO_TIMERS==1 if you
+      still want to use your own timer implementation for NO_SYS==0 (as before).
+
+  +++ sys layer:
+
+    * Converted mbox- and semaphore-functions to take pointers to sys_mbox_t/
+      sys_sem_t;
+
+    * Converted sys_mbox_new/sys_sem_new to take pointers and return err_t;
+
+    * Added Mutex concept in sys_arch (define LWIP_COMPAT_MUTEX to let sys.h use
+      binary semaphores instead of mutexes - as before)
+
+  +++ new options:
+
+     * Don't waste memory when chaining segments, added option TCP_OVERSIZE to
+       prevent creating many small pbufs when calling tcp_write with many small
+       blocks of data. Instead, pbufs are allocated larger than needed and the
+       space is used for later calls to tcp_write.
+
+     * Added LWIP_NETIF_TX_SINGLE_PBUF to always copy to try to create single pbufs
+       in tcp_write/udp_send.
+
+    * Added an additional option LWIP_ETHERNET to support ethernet without ARP
+      (necessary for pure PPPoE)
+
+    * Add MEMP_SEPARATE_POOLS to place memory pools in separate arrays. This may
+      be used to place these pools into user-defined memory by using external
+      declaration.
+
+    * Added TCP_SNDQUEUELOWAT corresponding to TCP_SNDLOWAT
+
+  +++ new pools:
+
+     * Netdb uses a memp pool for allocating memory when getaddrinfo() is called,
+       so MEMP_NUM_NETDB has to be set accordingly.
+
+     * DNS_LOCAL_HOSTLIST_IS_DYNAMIC uses a memp pool instead of the heap, so
+       MEMP_NUM_LOCALHOSTLIST has to be set accordingly.
+
+     * Snmp-agent uses a memp pools instead of the heap, so MEMP_NUM_SNMP_* have
+       to be set accordingly.
+
+     * PPPoE uses a MEMP pool instead of the heap, so MEMP_NUM_PPPOE_INTERFACES
+       has to be set accordingly
+
+  * Integrated loopif into netif.c - loopif does not have to be created by the
+    port any more, just define LWIP_HAVE_LOOPIF to 1.
+
+  * Added define LWIP_RAND() for lwip-wide randomization (needs to be defined
+    in cc.h, e.g. used by igmp)
+
+  * Added printf-formatter X8_F to printf u8_t as hex
+
+  * The heap now may be moved to user-defined memory by defining
+    LWIP_RAM_HEAP_POINTER as a void pointer to that memory's address
+
+  * added autoip_set_struct() and dhcp_set_struct() to let autoip and dhcp work
+    with user-allocated structs instead of calling mem_malloc
+
+  * Added const char* name to mem- and memp-stats for easier debugging.
+
+  * Calculate the TCP/UDP checksum while copying to only fetch data once:
+    Define LWIP_CHKSUM_COPY to a memcpy-like function that returns the checksum
+
+  * Added SO_REUSE_RXTOALL to pass received UDP broadcast/multicast packets to
+    more than one pcb.
+
+  * Changed the semantics of ARP_QUEUEING==0: ARP_QUEUEING now cannot be turned
+    off any more, if this is set to 0, only one packet (the most recent one) is
+    queued (like demanded by RFC 1122).
+
+  
+  ++ Major bugfixes/improvements
+
+  * Implemented tcp_shutdown() to only shut down one end of a connection
+  * Implemented shutdown() at socket- and netconn-level
+  * Added errorset support to select() + improved select speed overhead
+  * Merged pppd to v2.3.11 (including some backported bugfixes from 2.4.x)
+  * Added timer implementation for NO_SYS==1 (may be disabled with NO_SYS_NO_TIMERS==1
+  * Use macros defined in ip_addr.h to work with IP addresses
+  * Implemented many nonblocking socket/netconn functions
+  * Fixed ARP input processing: only add a new entry if a request was directed as us
+  * mem_realloc() to mem_trim() to prevent confusion with realloc()
+  * Some improvements for AutoIP (don't route/forward link-local addresses, don't break
+    existing connections when assigning a routable address)
+  * Correctly handle remote side overrunning our rcv_wnd in ooseq case
+  * Removed packing from ip_addr_t, the packed version is now only used in protocol headers
+  * Corrected PBUF_POOL_BUFSIZE for ports where ETH_PAD_SIZE > 0
+  * Added support for static ARP table entries
+
+(STABLE-1.3.2)
+
+  * initial version of this file

components/net/lwip-head/apps/ipv6/tcpclient6.c

+#include <rtthread.h>
+#include <lwip/netdb.h>
+#include <lwip/sockets.h>
+
+#define SERV_PORT 12345
+#define SERVADDR "4006:e024:680:c6e:223:8bff:fe59:de90"	// Do not use link-local address, lwip-head did not implement it.
+#define BUF_SIZE 1024
+static const char send_data[] = "This is TCP Client from RT-Thread.";
+
+void tcpclient6(void)
+{
+	char* recv_data;
+	int sockfd, bytes_received;
+	struct sockaddr_in6 server_addr6;
+	int status = 0;
+	
+	recv_data = rt_malloc(BUF_SIZE);
+	if(recv_data == RT_NULL)
+	{
+		rt_kprintf("No memory\n");
+		return ;
+	}
+	
+	if((sockfd = socket(PF_INET6, SOCK_STREAM, 0)) == -1)
+	{
+		rt_kprintf("Socket error\n");
+		rt_free(recv_data);
+		return ;
+	}
+	
+	memset(&server_addr6, 0, sizeof(server_addr6));
+	server_addr6.sin6_family = AF_INET6;
+	server_addr6.sin6_port = htons(SERV_PORT);
+	if(inet_pton(AF_INET6, SERVADDR, &server_addr6.sin6_addr.s6_addr) != 1)
+	{
+		rt_kprintf("inet_pton() error\n");
+		rt_free(recv_data);
+		return ;
+	}
+	
+	status = connect(sockfd, (struct sockaddr *)&server_addr6, sizeof(server_addr6));
+	if(status < 0)
+	{
+		rt_kprintf("Connect error:%d\n", status);
+		rt_free(recv_data);
+		return ;
+	}
+	
+	while(1)
+	{
+		bytes_received = recv(sockfd, recv_data, BUF_SIZE -1, 0);
+		if(bytes_received <= 0)
+		{
+			closesocket(sockfd);
+			rt_free(recv_data);
+			break;
+		}
+		recv_data[bytes_received] = '\0';
+		if(strcmp(recv_data, "q") == 0 || strcmp(recv_data, "Q") == 0)
+		{
+			closesocket(sockfd);
+			rt_free(recv_data);
+			break;
+		}
+		else
+		{
+			rt_kprintf("\nReceived data = %s ", recv_data);
+		}
+		send(sockfd, send_data, strlen(send_data), 0);
+	}
+
+	return;		
+}
+
+#ifdef RT_USING_FINSH
+#include <finsh.h>
+FINSH_FUNCTION_EXPORT(tcpclient6, startup tcp client via ipv6);
+#endif

components/net/lwip-head/apps/ipv6/tcpecho6.c

+#include <rtthread.h>
+#include <finsh.h>
+#include <lwip/api.h>
+
+#define TCP_ECHO_PORT 10001
+void tcpecho6(void)
+{
+	struct netconn *conn, *newconn;
+	err_t err;
+	
+	conn = netconn_new(NETCONN_TCP_IPV6);
+	netconn_bind_ip6(conn, IP6_ADDR_ANY, TCP_ECHO_PORT);
+	netconn_listen(conn);
+	
+	while(1)
+	{
+		err = netconn_accept(conn, &newconn);
+		if(err == ERR_OK)
+		{
+			struct netbuf *buf;
+			void *data;
+			u16_t len;
+			
+			while(netconn_recv(newconn, &buf) == ERR_OK)
+			{
+				do
+				{
+					netbuf_data(buf, &data, &len);
+					err = netconn_write(newconn, data, len, NETCONN_COPY);
+					if(err != ERR_OK)
+						rt_kprintf("netconn_write() error\n");
+				}while(netbuf_next(buf) >= 0);
+				netbuf_delete(buf);
+			}
+			netconn_delete(newconn);
+		}
+	}
+}
+
+#ifdef RT_USING_FINSH
+#include <finsh.h>
+FINSH_FUNCTION_EXPORT(tcpecho6, startup tcp echo server via ipv6);
+#endif

components/net/lwip-head/apps/ipv6/tcpserver6.c

+#include <rtthread.h>
+#include <lwip/sockets.h>
+
+#define SERV_PORT 10001
+#define BUF_SIZE  1024
+#define BACKLOG	  5
+
+static const char send_data[] = "This is TCP Server from RT-Thread.";
+
+void tcpserver6(void)
+{
+	int sockfd, clientfd;
+	struct sockaddr_in6 server_addr6, client_addr6;
+	int bytes_received;
+	char *recv_data;
+	rt_uint32_t sin_size;
+	rt_bool_t stop = RT_FALSE;
+
+	recv_data = rt_malloc(BUF_SIZE);
+	if(recv_data == RT_NULL)
+	{
+		rt_kprintf("No memory\n");
+		return ;
+	}
+	
+	if((sockfd = socket(PF_INET6, SOCK_STREAM, 0)) == -1)
+	{
+		rt_kprintf("Socket error\n");
+		rt_free(recv_data);
+		return ;
+	}
+	
+	server_addr6.sin6_family = AF_INET6;
+	memcpy(server_addr6.sin6_addr.s6_addr, IP6_ADDR_ANY, 16);
+	server_addr6.sin6_port = htons(SERV_PORT);
+
+	if(bind(sockfd, (struct sockaddr *)&server_addr6, sizeof(struct sockaddr)) == -1)
+	{
+		rt_kprintf("Bind error\n");
+		rt_free(recv_data);
+		return ;
+	}
+	if(listen(sockfd, BACKLOG) == -1)
+	{
+		rt_kprintf("Listen error\n");
+		rt_free(recv_data);
+		return ;
+	}
+
+	rt_sprintf(recv_data, "%4d", SERV_PORT);
+	rt_kprintf("\nTCPServer Waiting for client on port %s...\n", recv_data);
+	
+	while(stop != RT_TRUE)
+	{ 
+		sin_size = sizeof(struct sockaddr_in6);
+		clientfd = accept(sockfd, (struct sockaddr *)&client_addr6, &sin_size);
+		rt_kprintf("I got a connection from (IP:%s, PORT:%d\n)", inet6_ntoa(client_addr6.sin6_addr), ntohs(client_addr6.sin6_port));
+		while(1)
+		{
+			send(clientfd, send_data, strlen(send_data), 0);
+
+			bytes_received = recv(clientfd, recv_data, BUF_SIZE, 0);
+			if(bytes_received <= 0)
+			{
+				closesocket(clientfd);
+				break;
+			}
+			recv_data[bytes_received] = '\0';
+			if(strcmp(recv_data, "q") == 0 || strcmp(recv_data, "Q") == 0)
+			{
+				closesocket(clientfd);
+				break;
+			}
+			else if(strcmp(recv_data, "exit") == 0)
+			{
+				closesocket(clientfd);
+				stop = RT_TRUE;
+				break;
+			}
+			else
+			{
+				rt_kprintf("RECEIVED DATA = %s\n", recv_data);
+			}
+		}
+	}
+	
+	closesocket(sockfd);
+	rt_free(recv_data);
+	
+	return ;
+}
+#ifdef RT_USING_FINSH
+#include <finsh.h>
+FINSH_FUNCTION_EXPORT(tcpserver6, start tcp server via ipv6 );
+#endif

components/net/lwip-head/apps/ipv6/udpclient6.c

+#include <rtthread.h>
+#include <lwip/netdb.h>
+#include <lwip/sockets.h>
+
+#define SERV_PORT 22345
+#define SERVADDR "4006:e024:680:c6e:223:8bff:fe59:de90"
+#define BUF_SIZE 1024
+static const char send_data[] = "This is UDP Client from RT-Thread.";
+
+void udpclient6(void)
+{
+	char *recv_data;
+	int sockfd;
+	struct sockaddr_in6 server_addr6, client_addr6;
+	socklen_t clientlen;
+	
+	recv_data = rt_malloc(BUF_SIZE);
+	if(recv_data == RT_NULL)
+	{
+		rt_kprintf("No memory\n");
+		return ;
+	}
+	
+	if((sockfd = socket(PF_INET6, SOCK_DGRAM, 0)) == -1)
+	{
+		rt_kprintf("Socket error\n");
+		rt_free(recv_data);
+		return ;
+	}
+	
+	memset(&server_addr6, 0, sizeof(server_addr6));
+	server_addr6.sin6_family = AF_INET6;
+	server_addr6.sin6_port = htons(SERV_PORT);
+	if(inet_pton(AF_INET6, SERVADDR, &server_addr6.sin6_addr.s6_addr) != 1)
+	{
+		rt_kprintf("inet_pton() error\n");
+		rt_free(recv_data);
+		return ;
+	}
+	
+	if(sendto(sockfd, send_data, sizeof(recv_data), 0, (struct sockaddr *)&server_addr6, sizeof(server_addr6)) < 0)
+	{
+		rt_kprintf("Sendto error\n");
+		rt_free(recv_data);
+		return ;
+	}
+	
+	rt_kprintf("Waiting for a reply...\n");
+	
+	clientlen = sizeof(client_addr6);
+	if(recvfrom(sockfd, recv_data, BUF_SIZE, 0, (struct sockaddr *)&client_addr6, &clientlen) < 0)
+	{
+		rt_kprintf("Recvfrom error\n");
+		rt_free(recv_data);
+		return ;
+	}
+	rt_kprintf("got '%s'\n", recv_data);
+	closesocket(sockfd);
+}
+#ifdef RT_USING_FINSH
+#include <finsh.h>
+FINSH_FUNCTION_EXPORT(udpclient6, start udp server via ipv6);
+#endif

components/net/lwip-head/apps/ipv6/udpecho6.c

+#include <rtthread.h>
+#include <finsh.h>
+#include <lwip/api.h>
+
+#define UDP_ECHO_PORT 10002
+
+void udpecho6(void)
+{
+	struct netconn *conn, *newconn;
+	struct netbuf *buf;
+	struct ip6_addr *addr6;
+	unsigned short port;
+	err_t err;
+	
+	
+	conn = netconn_new(NETCONN_UDP_IPV6);
+	netconn_bind_ip6(conn, IP6_ADDR_ANY, UDP_ECHO_PORT);
+	
+	while(1)
+	{
+		netconn_recv(conn, &buf);
+		addr6 = netbuf_fromaddr_ip6(buf);
+		port = netbuf_fromport(buf);
+		netconn_connect_ip6(conn, addr6, port);
+		netconn_sendto_ip6(conn, buf, addr6, port);
+		netbuf_delete(buf);
+	}
+}
+#ifdef RT_USING_FINSH
+#include <finsh.h>
+FINSH_FUNCTION_EXPORT(udpecho6, startup udpecho via ipv6);
+#endif

components/net/lwip-head/apps/ipv6/udpserver6.c

+#include <rtthread.h>
+#include <lwip/sockets.h>
+
+#define SERV_PORT 10012
+#define BUF_SIZE  1024
+
+static const char send_data[] = "This is UDP Server from RT-Thread.";
+
+void udpserver6(void)
+{
+	int sockfd;
+	struct sockaddr_in6 server_addr6;
+	struct sockaddr_in6 client_addr6;
+	int bytes_read;
+	char *recv_data;
+	rt_uint32_t addr_len;
+
+	recv_data = rt_malloc(BUF_SIZE);
+	if(recv_data == RT_NULL)
+	{
+		rt_kprintf("No memory\n");
+		return ;
+	}
+
+	if((sockfd = socket(AF_INET6, SOCK_DGRAM, 0)) == -1)
+	{
+		rt_kprintf("Socket error\n");
+		rt_free(recv_data);
+		return ;
+	}
+	
+	server_addr6.sin6_family = AF_INET6;
+	server_addr6.sin6_port = htons(SERV_PORT);
+	memcpy(server_addr6.sin6_addr.s6_addr, IP6_ADDR_ANY, 16);
+	
+	if(bind(sockfd, (struct sockaddr *)&server_addr6, sizeof(struct sockaddr)) == -1)
+	{
+		rt_kprintf("Bind error\n");
+		rt_free(recv_data);
+		return ;
+	}
+	rt_sprintf(recv_data, "%4d", SERV_PORT);
+	rt_kprintf("UDPServer Waiting for client on port %s...\n", recv_data);
+	
+	addr_len = sizeof(struct sockaddr);
+	while(1)
+	{
+		bytes_read = recvfrom(sockfd, recv_data, BUF_SIZE - 1, 0, (struct sockaddr *)&client_addr6, &addr_len);
+		recv_data[bytes_read] = '\0';
+		rt_kprintf("\n(%s, %d) said:", inet6_ntoa(client_addr6.sin6_addr), ntohs(client_addr6.sin6_port));
+		rt_kprintf("%s", recv_data);
+		
+		if(strcmp(recv_data, "exit") == 0)
+		{
+			closesocket(sockfd);
+			rt_free(recv_data);
+			break;
+		}
+	}
+	return ;
+}
+
+#ifdef RT_USING_FINSH
+#include <finsh.h>
+FINSH_FUNCTION_EXPORT(udpserver6, startup udp server via ipv6);
+#endif

components/net/lwip-head/doc/FILES

+savannah.txt   - How to obtain the current development source code.
+contrib.txt    - How to contribute to lwIP as a developer.
+rawapi.txt     - The documentation for the core API of lwIP.
+                 Also provides an overview about the other APIs and multithreading.
+snmp_agent.txt - The documentation for the lwIP SNMP agent.
+sys_arch.txt   - The documentation for a system abstraction layer of lwIP.

components/net/lwip-head/doc/contrib.txt

+1 Introduction
+
+This document describes some guidelines for people participating
+in lwIP development.
+
+2 How to contribute to lwIP
+
+Here is a short list of suggestions to anybody working with lwIP and 
+trying to contribute bug reports, fixes, enhancements, platform ports etc.
+First of all as you may already know lwIP is a volunteer project so feedback
+to fixes or questions might often come late. Hopefully the bug and patch tracking 
+features of Savannah help us not lose users' input.
+
+2.1 Source code style:
+
+1. do not use tabs.
+2. indentation is two spaces per level (i.e. per tab).
+3. end debug messages with a trailing newline (\n).
+4. one space between keyword and opening bracket.
+5. no space between function and opening bracket.
+6. one space and no newline before opening curly braces of a block.
+7. closing curly brace on a single line.
+8. spaces surrounding assignment and comparisons.
+9. don't initialize static and/or global variables to zero, the compiler takes care of that.
+10. use current source code style as further reference.
+
+2.2 Source code documentation style:
+
+1. JavaDoc compliant and Doxygen compatible.
+2. Function documentation above functions in .c files, not .h files.
+   (This forces you to synchronize documentation and implementation.)
+3. Use current documentation style as further reference.
+ 
+2.3 Bug reports and patches:
+
+1. Make sure you are reporting bugs or send patches against the latest
+   sources. (From the latest release and/or the current CVS sources.)
+2. If you think you found a bug make sure it's not already filed in the
+   bugtracker at Savannah.
+3. If you have a fix put the patch on Savannah. If it is a patch that affects
+   both core and arch specific stuff please separate them so that the core can
+   be applied separately while leaving the other patch 'open'. The prefered way
+   is to NOT touch archs you can't test and let maintainers take care of them.
+   This is a good way to see if they are used at all - the same goes for unix
+   netifs except tapif.
+4. Do not file a bug and post a fix to it to the patch area. Either a bug report
+   or a patch will be enough.
+   If you correct an existing bug then attach the patch to the bug rather than creating a new entry in the patch area.
+5. Patches should be specific to a single change or to related changes.Do not mix bugfixes with spelling and other
+   trivial fixes unless the bugfix is trivial too.Do not reorganize code and rename identifiers in the same patch you
+   change behaviour if not necessary.A patch is easier to read and understand if it's to the point and short than
+   if it's not to the point and long :) so the chances for it to be applied are greater. 
+
+2.4 Platform porters:
+
+1. If you have ported lwIP to a platform (an OS, a uC/processor or a combination of these) and
+   you think it could benefit others[1] you might want discuss this on the mailing list. You
+   can also ask for CVS access to submit and maintain your port in the contrib CVS module.
+   
\ No newline at end of file

components/net/lwip-head/src/FILES

+api/      - The code for the high-level wrapper API. Not needed if
+            you use the lowel-level call-back/raw API.
+
+core/     - The core of the TPC/IP stack; protocol implementations,
+            memory and buffer management, and the low-level raw API.
+
+include/  - lwIP include files.
+
+netif/    - Generic network interface device drivers are kept here,
+            as well as the ARP module.
+
+For more information on the various subdirectories, check the FILES
+file in each directory.

components/net/lwip-head/src/arch/include/arch/bpstruct.h

+/*
+ * Copyright (c) 2001-2003 Swedish Institute of Computer Science.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ * 3. The name of the author may not be used to endorse or promote products
+ *    derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT
+ * SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
+ * OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
+ * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
+ * OF SUCH DAMAGE.
+ *
+ * This file is part of the lwIP TCP/IP stack.
+ *
+ * Author: Adam Dunkels <adam@sics.se>
+ *
+ */
+
+#if defined(__ICCARM__)
+#pragma pack(1)
+#endif

components/net/lwip-head/src/core/ipv6/README

+IPv6 support in lwIP is very experimental.