len0rd/FreeRTOS-Kernel
1
0
Fork 0
mirror of https://github.com/FreeRTOS/FreeRTOS-Kernel.git synced 2025-04-20 05:21:59 -04:00
Code Issues Packages Projects Releases Wiki Activity

Some re-formatting of uip.c.

Browse source
This commit is contained in:
Richard Barry 2010-09-10 18:40:31 +00:00
parent 904e22b667
commit 2641267c85
1 changed files with 987 additions and 1006 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

175
Demo/Common/ethernet/FreeTCPIP/uip.c
View file

@ -75,10 +75,9 @@
#include "net/uip_arp.h" #include "net/uip_arp.h"
#include "net/uip_arch.h" #include "net/uip_arch.h"
#if !UIP_CONF_IPV6 /* If UIP_CONF_IPV6 is defined, we compile the /* If UIP_CONF_IPV6 is defined, we compile the uip6.c file instead of this one.
uip6.c file instead of this one. Therefore Therefore this #ifndef removes the entire compilation output of the uip.c file */
this #ifndef removes the entire compilation #if !UIP_CONF_IPV6
output of the uip.c file */
#if UIP_CONF_IPV6 #if UIP_CONF_IPV6
#include "net/uip-neighbor.h" #include "net/uip-neighbor.h"
@ -90,9 +89,8 @@
/* Variable definitions. */ /* Variable definitions. */
/* The IP address of this host. If it is defined to be fixed (by /* The IP address of this host. If it is defined to be fixed (by setting
setting UIP_FIXEDADDR to 1 in uipopt.h), the address is set UIP_FIXEDADDR to 1 in uipopt.h), the address is set here. Otherwise, the address */
here. Otherwise, the address */
#if UIP_FIXEDADDR > 0 #if UIP_FIXEDADDR > 0
const uip_ipaddr_t uip_hostaddr = { UIP_IPADDR0, UIP_IPADDR1, UIP_IPADDR2, UIP_IPADDR3 }; const uip_ipaddr_t uip_hostaddr = { UIP_IPADDR0, UIP_IPADDR1, UIP_IPADDR2, UIP_IPADDR3 };
const uip_ipaddr_t uip_draddr = { UIP_DRIPADDR0, UIP_DRIPADDR1, UIP_DRIPADDR2, UIP_DRIPADDR3 }; const uip_ipaddr_t uip_draddr = { UIP_DRIPADDR0, UIP_DRIPADDR1, UIP_DRIPADDR2, UIP_DRIPADDR3 };
@ -105,12 +103,9 @@ const uip_ipaddr_t uip_broadcast_addr =
#if UIP_CONF_IPV6 #if UIP_CONF_IPV6
{ { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff } }; { { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff } };
#else /* UIP_CONF_IPV6 */ #else /* UIP_CONF_IPV6 */
{ { { 0xff, 0xff, 0xff, 0xff } };
{
0xff, 0xff, 0xff, 0xff
}
};
#endif /* UIP_CONF_IPV6 */ #endif /* UIP_CONF_IPV6 */
const uip_ipaddr_t uip_all_zeroes_addr = { { 0x0, /* rest is 0 */ } }; const uip_ipaddr_t uip_all_zeroes_addr = { { 0x0, /* rest is 0 */ } };
#if UIP_FIXEDETHADDR #if UIP_FIXEDETHADDR
@ -118,62 +113,59 @@ const struct uip_eth_addr uip_ethaddr = { { UIP_ETHADDR0, UIP_ETHADDR1, UIP_ETHA
#else #else
struct uip_eth_addr uip_ethaddr = { { 0, 0, 0, 0, 0, 0 } }; struct uip_eth_addr uip_ethaddr = { { 0, 0, 0, 0, 0, 0 } };
#endif #endif
#ifndef UIP_CONF_EXTERNAL_BUFFER #ifndef UIP_CONF_EXTERNAL_BUFFER
u8_t uip_buf[UIP_BUFSIZE + 2]; /* The packet buffer that contains /* The packet buffer that contains incoming packets. */
incoming packets. */ u8_t uip_buf[ UIP_BUFSIZE + 2 ];
#endif /* UIP_CONF_EXTERNAL_BUFFER */ #endif /* UIP_CONF_EXTERNAL_BUFFER */
void *uip_appdata; /* The uip_appdata pointer points to /* The uip_appdata pointer points to application data. */
application data. */ void *uip_appdata;
void *uip_sappdata; /* The uip_appdata pointer points to
the application data which is to /* The uip_appdata pointer points to the application data which is to be sent. */
be sent. */ void *uip_sappdata;
#if UIP_URGDATA > 0 #if UIP_URGDATA > 0
void *uip_urgdata; /* The uip_urgdata pointer points to /* The uip_urgdata pointer points to urgent data (out-of-band data), if
urgent data (out-of-band data), if
present. */ present. */
void *uip_urgdata;
u16_t uip_urglen, uip_surglen; u16_t uip_urglen, uip_surglen;
#endif /* UIP_URGDATA > 0 */ #endif /* UIP_URGDATA > 0 */
/* The uip_len is either 8 or 16 bits, depending on the maximum packet size. */
u16_t uip_len, uip_slen; u16_t uip_len, uip_slen;
/* The uip_len is either 8 or 16 bits, /* The uip_flags variable is used for communication between the TCP/IP stack
depending on the maximum packet
size. */
u8_t uip_flags; /* The uip_flags variable is used for
communication between the TCP/IP stack
and the application program. */ and the application program. */
struct uip_conn *uip_conn; /* uip_conn always points to the current u8_t uip_flags;
connection. */
/* uip_conn always points to the current connection. */
struct uip_conn *uip_conn;
struct uip_conn uip_conns[ UIP_CONNS ]; struct uip_conn uip_conns[ UIP_CONNS ];
/* The uip_conns array holds all TCP /* The uip_conns array holds all TCP connections. */
connections. */
u16_t uip_listenports[UIP_LISTENPORTS]; u16_t uip_listenports[UIP_LISTENPORTS];
/* The uip_listenports list all currently /* The uip_listenports list all currently listning ports. */
listning ports. */
#if UIP_UDP #if UIP_UDP
struct uip_udp_conn *uip_udp_conn; struct uip_udp_conn *uip_udp_conn;
struct uip_udp_conn uip_udp_conns[UIP_UDP_CONNS]; struct uip_udp_conn uip_udp_conns[UIP_UDP_CONNS];
#endif /* UIP_UDP */ #endif /* UIP_UDP */
static u16_t ipid; /* Ths ipid variable is an increasing /* Ths ipid variable is an increasing number that is used for the IP ID field. */
number that is used for the IP ID static u16_t ipid;
field. */
void uip_setipid( u16_t id ) void uip_setipid( u16_t id )
{ {
ipid = id; ipid = id;
} }
static u8_t iss[4]; /* The iss variable is used for the TCP /* The iss variable is used for the TCP initial sequence number. */
initial sequence number. */ static u8_t iss[ 4 ];
#if UIP_ACTIVE_OPEN #if UIP_ACTIVE_OPEN
static u16_t lastport; /* Keeps track of the last port used for /* Keeps track of the last port used for a new connection. */
a new connection. */ static u16_t lastport;
#endif /* UIP_ACTIVE_OPEN */ #endif /* UIP_ACTIVE_OPEN */
/* Temporary variables. */ /* Temporary variables. */
@ -216,6 +208,7 @@ static u16_t tmp16;
#define FBUF ( ( struct uip_tcpip_hdr * ) &uip_reassbuf[0] ) #define FBUF ( ( struct uip_tcpip_hdr * ) &uip_reassbuf[0] )
#define ICMPBUF ( ( struct uip_icmpip_hdr * ) &uip_buf[UIP_LLH_LEN] ) #define ICMPBUF ( ( struct uip_icmpip_hdr * ) &uip_buf[UIP_LLH_LEN] )
#define UDPBUF ( ( struct uip_udpip_hdr * ) &uip_buf[UIP_LLH_LEN] ) #define UDPBUF ( ( struct uip_udpip_hdr * ) &uip_buf[UIP_LLH_LEN] )
#if UIP_STATISTICS == 1 #if UIP_STATISTICS == 1
struct uip_stats uip_stat; struct uip_stats uip_stat;
#define UIP_STAT( s ) s #define UIP_STAT( s ) s
@ -261,12 +254,11 @@ void uip_add32( u8_t *op32, u16_t op16 )
} }
} }
} }
/*---------------------------------------------------------------------------*/
#endif /* UIP_ARCH_ADD32 */ #endif /* UIP_ARCH_ADD32 */
#if !UIP_ARCH_CHKSUM #if !UIP_ARCH_CHKSUM
/*---------------------------------------------------------------------------*/
static u16_t chksum( u16_t sum, const u8_t *data, u16_t len ) static u16_t chksum( u16_t sum, const u8_t *data, u16_t len )
{ {
u16_t t; u16_t t;
@ -277,7 +269,8 @@ static u16_t chksum( u16_t sum, const u8_t *data, u16_t len )
last_byte = data + len - 1; last_byte = data + len - 1;
while( dataptr < last_byte ) while( dataptr < last_byte )
{ /* At least two more bytes */ {
/* At least two more bytes */
t = ( dataptr[ 0 ] << 8 ) + dataptr[ 1 ]; t = ( dataptr[ 0 ] << 8 ) + dataptr[ 1 ];
sum += t; sum += t;
if( sum < t ) if( sum < t )
@ -301,14 +294,14 @@ static u16_t chksum( u16_t sum, const u8_t *data, u16_t len )
/* Return sum in host byte order. */ /* Return sum in host byte order. */
return sum; return sum;
} }
/*---------------------------------------------------------------------------*/ /*---------------------------------------------------------------------------*/
u16_t uip_chksum( u16_t *data, u16_t len ) u16_t uip_chksum( u16_t *data, u16_t len )
{ {
return htons( chksum( 0, ( u8_t * ) data, len ) ); return htons( chksum( 0, ( u8_t * ) data, len ) );
} }
/*---------------------------------------------------------------------------*/ /*---------------------------------------------------------------------------*/
#ifndef UIP_ARCH_IPCHKSUM #ifndef UIP_ARCH_IPCHKSUM
u16_t uip_ipchksum( void ) u16_t uip_ipchksum( void )
{ {
@ -319,10 +312,9 @@ u16_t uip_ipchksum( void )
//DEBUG_PRINTF( "uip_ipchksum: sum 0x%04x\n", sum ); //DEBUG_PRINTF( "uip_ipchksum: sum 0x%04x\n", sum );
return( sum == 0 ) ? 0xffff : htons( sum ); return( sum == 0 ) ? 0xffff : htons( sum );
} }
#endif #endif
/*---------------------------------------------------------------------------*/ /*---------------------------------------------------------------------------*/
static u16_t upper_layer_chksum( u8_t proto ) static u16_t upper_layer_chksum( u8_t proto )
{ {
u16_t upper_layer_len; u16_t upper_layer_len;
@ -347,33 +339,32 @@ static u16_t upper_layer_chksum( u8_t proto )
return( sum == 0 ) ? 0xffff : htons( sum ); return( sum == 0 ) ? 0xffff : htons( sum );
} }
/*---------------------------------------------------------------------------*/ /*---------------------------------------------------------------------------*/
#if UIP_CONF_IPV6 #if UIP_CONF_IPV6
u16_t uip_icmp6chksum( void ) u16_t uip_icmp6chksum( void )
{ {
return upper_layer_chksum( UIP_PROTO_ICMP6 ); return upper_layer_chksum( UIP_PROTO_ICMP6 );
} }
#endif /* UIP_CONF_IPV6 */ #endif /* UIP_CONF_IPV6 */
/*---------------------------------------------------------------------------*/ /*---------------------------------------------------------------------------*/
u16_t uip_tcpchksum( void ) u16_t uip_tcpchksum( void )
{ {
return upper_layer_chksum( UIP_PROTO_TCP ); return upper_layer_chksum( UIP_PROTO_TCP );
} }
/*---------------------------------------------------------------------------*/ /*---------------------------------------------------------------------------*/
#if UIP_UDP_CHECKSUMS #if UIP_UDP_CHECKSUMS
u16_t uip_udpchksum( void ) u16_t uip_udpchksum( void )
{ {
return upper_layer_chksum( UIP_PROTO_UDP ); return upper_layer_chksum( UIP_PROTO_UDP );
} }
#endif /* UIP_UDP_CHECKSUMS */ #endif /* UIP_UDP_CHECKSUMS */
#endif /* UIP_ARCH_CHKSUM */
#endif /* UIP_ARCH_CHKSUM */
/*---------------------------------------------------------------------------*/ /*---------------------------------------------------------------------------*/
void uip_init( void ) void uip_init( void )
{ {
for( c = 0; c < UIP_LISTENPORTS; ++c ) for( c = 0; c < UIP_LISTENPORTS; ++c )
@ -395,7 +386,6 @@ void uip_init( void )
{ {
uip_udp_conns[ c ].lport = 0; uip_udp_conns[ c ].lport = 0;
} }
#endif /* UIP_UDP */ #endif /* UIP_UDP */
/* IPv4 initialization. */ /* IPv4 initialization. */
@ -403,8 +393,8 @@ void uip_init( void )
/* uip_hostaddr[ 0 ] = uip_hostaddr[ 1 ] = 0;*/ /* uip_hostaddr[ 0 ] = uip_hostaddr[ 1 ] = 0;*/
#endif /* UIP_FIXEDADDR */ #endif /* UIP_FIXEDADDR */
} }
/*---------------------------------------------------------------------------*/ /*---------------------------------------------------------------------------*/
#if UIP_ACTIVE_OPEN #if UIP_ACTIVE_OPEN
struct uip_conn *uip_connect( uip_ipaddr_t *ripaddr, u16_t rport ) struct uip_conn *uip_connect( uip_ipaddr_t *ripaddr, u16_t rport )
{ {
@ -475,10 +465,9 @@ again:
return conn; return conn;
} }
/*---------------------------------------------------------------------------*/
#endif /* UIP_ACTIVE_OPEN */ #endif /* UIP_ACTIVE_OPEN */
/*---------------------------------------------------------------------------*/
#if UIP_UDP #if UIP_UDP
struct uip_udp_conn *uip_udp_new( const uip_ipaddr_t *ripaddr, u16_t rport ) struct uip_udp_conn *uip_udp_new( const uip_ipaddr_t *ripaddr, u16_t rport )
{ {
@ -531,10 +520,9 @@ again:
return conn; return conn;
} }
/*---------------------------------------------------------------------------*/
#endif /* UIP_UDP */ #endif /* UIP_UDP */
/*---------------------------------------------------------------------------*/
void uip_unlisten( u16_t port ) void uip_unlisten( u16_t port )
{ {
for( c = 0; c < UIP_LISTENPORTS; ++c ) for( c = 0; c < UIP_LISTENPORTS; ++c )
@ -546,8 +534,8 @@ void uip_unlisten( u16_t port )
} }
} }
} }
/*---------------------------------------------------------------------------*/ /*---------------------------------------------------------------------------*/
void uip_listen( u16_t port ) void uip_listen( u16_t port )
{ {
for( c = 0; c < UIP_LISTENPORTS; ++c ) for( c = 0; c < UIP_LISTENPORTS; ++c )
@ -559,7 +547,6 @@ void uip_listen( u16_t port )
} }
} }
} }
/*---------------------------------------------------------------------------*/ /*---------------------------------------------------------------------------*/
/* XXX: IP fragment reassembly: not well-tested. */ /* XXX: IP fragment reassembly: not well-tested. */
@ -694,12 +681,13 @@ static u8_t uip_reass( void )
} }
nullreturn: nullreturn:
return 0; return 0;
} }
/*---------------------------------------------------------------------------*/
#endif /* UIP_REASSEMBLY */ #endif /* UIP_REASSEMBLY */
/*---------------------------------------------------------------------------*/
static void uip_add_rcv_nxt( u16_t n ) static void uip_add_rcv_nxt( u16_t n )
{ {
uip_add32( uip_conn->rcv_nxt, n ); uip_add32( uip_conn->rcv_nxt, n );
@ -708,8 +696,8 @@ static void uip_add_rcv_nxt( u16_t n )
uip_conn->rcv_nxt[ 2 ] = uip_acc32[ 2 ]; uip_conn->rcv_nxt[ 2 ] = uip_acc32[ 2 ];
uip_conn->rcv_nxt[ 3 ] = uip_acc32[ 3 ]; uip_conn->rcv_nxt[ 3 ] = uip_acc32[ 3 ];
} }
/*---------------------------------------------------------------------------*/ /*---------------------------------------------------------------------------*/
void uip_process( u8_t flag ) void uip_process( u8_t flag )
{ {
register struct uip_conn *uip_connr = uip_conn; register struct uip_conn *uip_connr = uip_conn;
@ -719,7 +707,6 @@ void uip_process( u8_t flag )
{ {
goto udp_send; goto udp_send;
} }
#endif /* UIP_UDP */ #endif /* UIP_UDP */
uip_sappdata = uip_appdata = &uip_buf[UIP_IPTCPH_LEN + UIP_LLH_LEN]; uip_sappdata = uip_appdata = &uip_buf[UIP_IPTCPH_LEN + UIP_LLH_LEN];
@ -746,7 +733,6 @@ void uip_process( u8_t flag )
{ {
--uip_reasstmr; --uip_reasstmr;
} }
#endif /* UIP_REASSEMBLY */ #endif /* UIP_REASSEMBLY */
/* Increase the initial sequence number. */ /* Increase the initial sequence number. */
@ -827,7 +813,6 @@ void uip_process( u8_t flag )
goto tcp_send_synack; goto tcp_send_synack;
#if UIP_ACTIVE_OPEN #if UIP_ACTIVE_OPEN
case UIP_SYN_SENT: case UIP_SYN_SENT:
/* In the SYN_SENT state, we retransmit out SYN. */ /* In the SYN_SENT state, we retransmit out SYN. */
BUF->flags = 0; BUF->flags = 0;
@ -881,7 +866,6 @@ void uip_process( u8_t flag )
goto drop; goto drop;
} }
} }
#endif #endif
/* This is where the input processing starts. */ /* This is where the input processing starts. */
@ -920,7 +904,7 @@ void uip_process( u8_t flag )
{ {
uip_len = ( BUF->len[ 0 ] << 8 ) + BUF->len[ 1 ]; uip_len = ( BUF->len[ 0 ] << 8 ) + BUF->len[ 1 ];
#if UIP_CONF_IPV6 #if UIP_CONF_IPV6
uip_len += 40; /* The length reported in the IPv6 header is the /* The length reported in the IPv6 header is the
length of the payload that follows the length of the payload that follows the
header. However, uIP uses the uip_len variable header. However, uIP uses the uip_len variable
for holding the size of the entire packet, for holding the size of the entire packet,
@ -929,6 +913,7 @@ void uip_process( u8_t flag )
contains the length of the entire packet. But contains the length of the entire packet. But
for IPv6 we need to add the size of the IPv6 for IPv6 we need to add the size of the IPv6
header (40 bytes). */ header (40 bytes). */
uip_len += 40;
#endif /* UIP_CONF_IPV6 */ #endif /* UIP_CONF_IPV6 */
} }
else else
@ -947,7 +932,6 @@ void uip_process( u8_t flag )
{ {
goto drop; goto drop;
} }
#else /* UIP_REASSEMBLY */ #else /* UIP_REASSEMBLY */
UIP_STAT( ++uip_stat.ip.drop ); UIP_STAT( ++uip_stat.ip.drop );
UIP_STAT( ++uip_stat.ip.fragerr ); UIP_STAT( ++uip_stat.ip.fragerr );
@ -955,7 +939,6 @@ void uip_process( u8_t flag )
goto drop; goto drop;
#endif /* UIP_REASSEMBLY */ #endif /* UIP_REASSEMBLY */
} }
#endif /* UIP_CONF_IPV6 */ #endif /* UIP_CONF_IPV6 */
if( uip_ipaddr_cmp(&uip_hostaddr, &uip_all_zeroes_addr) ) if( uip_ipaddr_cmp(&uip_hostaddr, &uip_all_zeroes_addr) )
@ -974,7 +957,6 @@ void uip_process( u8_t flag )
UIP_LOG( "ip: packet dropped since no address assigned." ); UIP_LOG( "ip: packet dropped since no address assigned." );
goto drop; goto drop;
} }
#endif /* UIP_PINGADDRCONF */ #endif /* UIP_PINGADDRCONF */
} }
else else
@ -983,12 +965,10 @@ void uip_process( u8_t flag )
UDP packet, which may be destined to us. */ UDP packet, which may be destined to us. */
#if UIP_BROADCAST #if UIP_BROADCAST
//DEBUG_PRINTF( "UDP IP checksum 0x%04x\n", uip_ipchksum() ); //DEBUG_PRINTF( "UDP IP checksum 0x%04x\n", uip_ipchksum() );
if( BUF->proto == UIP_PROTO_UDP && uip_ipaddr_cmp(&BUF->destipaddr, &uip_broadcast_addr) /*&& if( BUF->proto == UIP_PROTO_UDP && uip_ipaddr_cmp(&BUF->destipaddr, &uip_broadcast_addr) /*&& uip_ipchksum() == 0xffff*/ )
uip_ipchksum() == 0xffff*/ )
{ {
goto udp_input; goto udp_input;
} }
#endif /* UIP_BROADCAST */ #endif /* UIP_BROADCAST */
/* Check if the packet is destined for our IP address. */ /* Check if the packet is destined for our IP address. */
@ -998,7 +978,6 @@ void uip_process( u8_t flag )
UIP_STAT( ++uip_stat.ip.drop ); UIP_STAT( ++uip_stat.ip.drop );
goto drop; goto drop;
} }
#else /* UIP_CONF_IPV6 */ #else /* UIP_CONF_IPV6 */
/* For IPv6, packet reception is a little trickier as we need to /* For IPv6, packet reception is a little trickier as we need to
make sure that we listen to certain multicast addresses (all make sure that we listen to certain multicast addresses (all
@ -1010,26 +989,23 @@ void uip_process( u8_t flag )
UIP_STAT( ++uip_stat.ip.drop ); UIP_STAT( ++uip_stat.ip.drop );
goto drop; goto drop;
} }
#endif /* UIP_CONF_IPV6 */ #endif /* UIP_CONF_IPV6 */
} }
#if !UIP_CONF_IPV6 #if !UIP_CONF_IPV6
if( uip_ipchksum() != 0xffff ) if( uip_ipchksum() != 0xffff )
{ /* Compute and check the IP header {
checksum. */ /* Compute and check the IP header checksum. */
UIP_STAT( ++uip_stat.ip.drop ); UIP_STAT( ++uip_stat.ip.drop );
UIP_STAT( ++uip_stat.ip.chkerr ); UIP_STAT( ++uip_stat.ip.chkerr );
UIP_LOG( "ip: bad checksum." ); UIP_LOG( "ip: bad checksum." );
goto drop; goto drop;
} }
#endif /* UIP_CONF_IPV6 */ #endif /* UIP_CONF_IPV6 */
if( BUF->proto == UIP_PROTO_TCP ) if( BUF->proto == UIP_PROTO_TCP )
{ /* Check for TCP packet. If so, {
proceed with TCP input /* Check for TCP packet. If so, proceed with TCP input processing. */
processing. */
goto tcp_input; goto tcp_input;
} }
@ -1038,14 +1014,13 @@ void uip_process( u8_t flag )
{ {
goto udp_input; goto udp_input;
} }
#endif /* UIP_UDP */ #endif /* UIP_UDP */
#if !UIP_CONF_IPV6 #if !UIP_CONF_IPV6
/* ICMPv4 processing code follows. */ /* ICMPv4 processing code follows. */
if( BUF->proto != UIP_PROTO_ICMP ) if( BUF->proto != UIP_PROTO_ICMP )
{ /* We only allow ICMP packets from {
here. */ /* We only allow ICMP packets from here. */
UIP_STAT( ++uip_stat.ip.drop ); UIP_STAT( ++uip_stat.ip.drop );
UIP_STAT( ++uip_stat.ip.protoerr ); UIP_STAT( ++uip_stat.ip.protoerr );
UIP_LOG( "ip: neither tcp nor icmp." ); UIP_LOG( "ip: neither tcp nor icmp." );
@ -1055,6 +1030,7 @@ void uip_process( u8_t flag )
#if UIP_PINGADDRCONF #if UIP_PINGADDRCONF
icmp_input : icmp_input :
#endif /* UIP_PINGADDRCONF */ #endif /* UIP_PINGADDRCONF */
UIP_STAT( ++uip_stat.icmp.recv ); UIP_STAT( ++uip_stat.icmp.recv );
/* ICMP echo (i.e., ping) processing. This is simple, we only change /* ICMP echo (i.e., ping) processing. This is simple, we only change
@ -1076,7 +1052,6 @@ void uip_process( u8_t flag )
{ {
uip_hostaddr = BUF->destipaddr; uip_hostaddr = BUF->destipaddr;
} }
#endif /* UIP_PINGADDRCONF */ #endif /* UIP_PINGADDRCONF */
ICMPBUF->type = ICMP_ECHO_REPLY; ICMPBUF->type = ICMP_ECHO_REPLY;
@ -1099,13 +1074,15 @@ void uip_process( u8_t flag )
goto ip_send_nolen; goto ip_send_nolen;
/* End of IPv4 input header processing code. */ /* End of IPv4 input header processing code. */
#else /* !UIP_CONF_IPV6 */ #else /* !UIP_CONF_IPV6 */
/* This is IPv6 ICMPv6 processing code. */ /* This is IPv6 ICMPv6 processing code. */
//DEBUG_PRINTF( "icmp6_input: length %d\n", uip_len ); //DEBUG_PRINTF( "icmp6_input: length %d\n", uip_len );
if( BUF->proto != UIP_PROTO_ICMP6 ) if( BUF->proto != UIP_PROTO_ICMP6 )
{ /* We only allow ICMPv6 packets from {
here. */ /* We only allow ICMPv6 packets from here. */
UIP_STAT( ++uip_stat.ip.drop ); UIP_STAT( ++uip_stat.ip.drop );
UIP_STAT( ++uip_stat.ip.protoerr ); UIP_STAT( ++uip_stat.ip.protoerr );
UIP_LOG( "ip: neither tcp nor icmp6." ); UIP_LOG( "ip: neither tcp nor icmp6." );
@ -1222,7 +1199,9 @@ void uip_process( u8_t flag )
} }
UIP_LOG( "udp: no matching connection found" ); UIP_LOG( "udp: no matching connection found" );
#if UIP_CONF_ICMP_DEST_UNREACH && !UIP_CONF_IPV6 #if UIP_CONF_ICMP_DEST_UNREACH && !UIP_CONF_IPV6
/* Copy fields from packet header into payload of this ICMP packet. */ /* Copy fields from packet header into payload of this ICMP packet. */
memcpy( &(ICMPBUF->payload[ 0 ]), ICMPBUF, UIP_IPH_LEN + 8 ); memcpy( &(ICMPBUF->payload[ 0 ]), ICMPBUF, UIP_IPH_LEN + 8 );
@ -1299,9 +1278,7 @@ udp_send:
{ {
UDPBUF->udpchksum = 0xffff; UDPBUF->udpchksum = 0xffff;
} }
#endif /* UIP_UDP_CHECKSUMS */ #endif /* UIP_UDP_CHECKSUMS */
goto ip_send_nolen; goto ip_send_nolen;
#endif /* UIP_UDP */ #endif /* UIP_UDP */
@ -1310,8 +1287,8 @@ udp_send:
/* Start of TCP input header processing code. */ /* Start of TCP input header processing code. */
if( uip_tcpchksum() != 0xffff ) if( uip_tcpchksum() != 0xffff )
{ /* Compute and check the TCP {
checksum. */ /* Compute and check the TCP checksum. */
UIP_STAT( ++uip_stat.tcp.drop ); UIP_STAT( ++uip_stat.tcp.drop );
UIP_STAT( ++uip_stat.tcp.chkerr ); UIP_STAT( ++uip_stat.tcp.chkerr );
UIP_LOG( "tcp: bad checksum." ); UIP_LOG( "tcp: bad checksum." );
@ -1522,7 +1499,6 @@ found_listen:
/* Our response will be a SYNACK. */ /* Our response will be a SYNACK. */
#if UIP_ACTIVE_OPEN #if UIP_ACTIVE_OPEN
tcp_send_synack : BUF->flags = TCP_ACK; tcp_send_synack : BUF->flags = TCP_ACK;
tcp_send_syn: tcp_send_syn:
BUF->flags |= TCP_SYN; BUF->flags |= TCP_SYN;
#else /* UIP_ACTIVE_OPEN */ #else /* UIP_ACTIVE_OPEN */
@ -1667,8 +1643,8 @@ found:
} }
goto drop; goto drop;
#if UIP_ACTIVE_OPEN
#if UIP_ACTIVE_OPEN
case UIP_SYN_SENT: case UIP_SYN_SENT:
/* In SYN_SENT, we wait for a SYNACK that is sent in response to /* In SYN_SENT, we wait for a SYNACK that is sent in response to
our SYN. The rcv_nxt is set to sequence number in the SYNACK our SYN. The rcv_nxt is set to sequence number in the SYNACK
@ -2074,7 +2050,9 @@ tcp_send:
} }
tcp_send_noconn: tcp_send_noconn:
BUF->ttl = UIP_TTL; BUF->ttl = UIP_TTL;
#if UIP_CONF_IPV6 #if UIP_CONF_IPV6
/* For IPv6, the IP length field does not include the IPv6 IP header /* For IPv6, the IP length field does not include the IPv6 IP header
length. */ length. */
@ -2110,7 +2088,9 @@ ip_send_nolen:
//DEBUG_PRINTF( "uip ip_send_nolen: chkecum 0x%04x\n", uip_ipchksum() ); //DEBUG_PRINTF( "uip ip_send_nolen: chkecum 0x%04x\n", uip_ipchksum() );
#endif /* UIP_CONF_IPV6 */ #endif /* UIP_CONF_IPV6 */
UIP_STAT( ++uip_stat.tcp.sent ); UIP_STAT( ++uip_stat.tcp.sent );
#if UIP_CONF_IPV6 #if UIP_CONF_IPV6
send : send :
#endif /* UIP_CONF_IPV6 */ #endif /* UIP_CONF_IPV6 */
@ -2127,8 +2107,8 @@ drop:
uip_flags = 0; uip_flags = 0;
return; return;
} }
/*---------------------------------------------------------------------------*/ /*---------------------------------------------------------------------------*/
u16_t htons( u16_t val ) u16_t htons( u16_t val )
{ {
return HTONS( val ); return HTONS( val );
@ -2138,12 +2118,14 @@ u32_t htonl( u32_t val )
{ {
return HTONL( val ); return HTONL( val );
} }
/*---------------------------------------------------------------------------*/ /*---------------------------------------------------------------------------*/
void uip_send( const void *data, int len ) void uip_send( const void *data, int len )
{ {
int copylen; int copylen;
#define MIN( a, b ) ( (a) < (b) ? (a) : (b) ) #define MIN( a, b ) ( (a) < (b) ? (a) : (b) )
copylen = MIN( len, UIP_BUFSIZE - UIP_LLH_LEN - UIP_TCPIP_HLEN - ( int ) copylen = MIN( len, UIP_BUFSIZE - UIP_LLH_LEN - UIP_TCPIP_HLEN - ( int )
(( char * ) uip_sappdata - ( char * ) &uip_buf[UIP_LLH_LEN + UIP_TCPIP_HLEN]) ); (( char * ) uip_sappdata - ( char * ) &uip_buf[UIP_LLH_LEN + UIP_TCPIP_HLEN]) );
if( copylen > 0 ) if( copylen > 0 )
@ -2155,7 +2137,6 @@ void uip_send( const void *data, int len )
} }
} }
} }
/*---------------------------------------------------------------------------*/ /*---------------------------------------------------------------------------*/
/** @} */ /** @} */