#include <netinet/in.h>

#include <netinet/ip6.h>

#include <netinet/icmp6.h>

#include <sys/types.h>

#include <arpa/inet.h>

#include "uip.h"

#include "dhcpc.h"

#include "ipv6_ndpc.h"

#include "brcm_iscsi.h"

#include "ping.h"

/**

 * \defgroup uip The uIP TCP/IP stack

 * @{

 *

 * uIP is an implementation of the TCP/IP protocol stack intended for

 * small 8-bit and 16-bit microcontrollers.

 *

 * uIP provides the necessary protocols for Internet communication,

 * with a very small code footprint and RAM requirements - the uIP

 * code size is on the order of a few kilobytes and RAM usage is on

 * the order of a few hundred bytes.

 */

/**

 * \file

 * The uIP TCP/IP stack code.

 * \author Adam Dunkels <adam@dunkels.com>

 */

/*

 * Copyright (c) 2001-2003, Adam Dunkels.

 * 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 uIP TCP/IP stack.

 *

 *

 */

/*

 * uIP is a small implementation of the IP, UDP and TCP protocols (as

 * well as some basic ICMP stuff). The implementation couples the IP,

 * UDP, TCP and the application layers very tightly. To keep the size

 * of the compiled code down, this code frequently uses the goto

 * statement. While it would be possible to break the uip_process()

 * function into many smaller functions, this would increase the code

 * size because of the overhead of parameter passing and the fact that

 * the optimier would not be as efficient.

 *

 * The principle is that we have a small buffer, called the uip_buf,

 * in which the device driver puts an incoming packet. The TCP/IP

 * stack parses the headers in the packet, and calls the

 * application. If the remote host has sent data to the application,

 * this data is present in the uip_buf and the application read the

 * data from there. It is up to the application to put this data into

 * a byte stream if needed. The application will not be fed with data

 * that is out of sequence.

 *

 * If the application whishes to send data to the peer, it should put

 * its data into the uip_buf. The uip_appdata pointer points to the

 * first available byte. The TCP/IP stack will calculate the

 * checksums, and fill in the necessary header fields and finally send

 * the packet back to the peer.

*/

#include "logger.h"

#include "uip.h"

#include "uipopt.h"

#include "uip_arch.h"

#include "uip_eth.h"

#include "uip-neighbor.h"

#include <string.h>

/*******************************************************************************

 * Constants

 ******************************************************************************/

#define PFX "uip "

static const uip_ip4addr_t all_ones_addr4 = { 0xffff, 0xffff };

const uip_ip6addr_t all_zeroes_addr6 = {

	0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000

};

const uip_ip4addr_t all_zeroes_addr4 = { 0x0000, 0x0000 };

const uint8_t mutlicast_ipv6_prefix[16] = {

	0xfc, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00,

	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00

};

const uint8_t link_local_addres_prefix[16] = {

	0xfe, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00

};

const uint32_t link_local_address_prefix_length = 10;

/* Structures and definitions. */

#define TCP_FIN 0x01

#define TCP_SYN 0x02

#define TCP_RST 0x04

#define TCP_PSH 0x08

#define TCP_ACK 0x10

#define TCP_URG 0x20

#define TCP_CTL 0x3f

#define TCP_OPT_END     0	/* End of TCP options list */

#define TCP_OPT_NOOP    1	/* "No-operation" TCP option */

#define TCP_OPT_MSS     2	/* Maximum segment size TCP option */

#define TCP_OPT_MSS_LEN 4	/* Length of TCP MSS option. */

#define ICMP_ECHO_REPLY 0

#define ICMP_ECHO       8

#define ICMP6_ECHO_REPLY             129

#define ICMP6_ECHO                   128

#define ICMP6_NEIGHBOR_SOLICITATION  135

#define ICMP6_NEIGHBOR_ADVERTISEMENT 136

#define ICMP6_FLAG_S (1 << 6)

#define ICMP6_OPTION_SOURCE_LINK_ADDRESS 1

#define ICMP6_OPTION_TARGET_LINK_ADDRESS 2

/* Macros. */

#define FBUF ((struct uip_tcpip_hdr *)&uip_reassbuf[0])

#define UDPBUF(ustack) ((struct uip_udpip_hdr *)ustack->network_layer)

/******************************************************************************

 * Utility Functions

 *****************************************************************************/

static int is_ipv6(struct uip_stack *ustack)

{

	u16_t type;

	type = ETH_BUF(ustack->uip_buf)->type;

	type = ntohs(type);

	if (type == UIP_ETHTYPE_8021Q)

		type = ntohs(VLAN_ETH_BUF(ustack->uip_buf)->type);

	else

		type = ntohs(ETH_BUF(ustack->uip_buf)->type);

	return (type == UIP_ETHTYPE_IPv6);

}

int is_ipv6_link_local_address(uip_ip6addr_t *addr)

{

	u8_t *test_adddr = (u8_t *) addr;

	u8_t test_remainder;

	if (test_adddr[0] != link_local_addres_prefix[0])

		return 0;

	test_remainder = (test_adddr[1] & 0xC0) >> 6;

	if (test_remainder != 2)

		return 0;

	return 1;

}

void uip_sethostaddr4(struct uip_stack *ustack, uip_ip4addr_t *addr)

{

	pthread_mutex_lock(&ustack->lock);

	uip_ip4addr_copy(ustack->hostaddr, (addr));

	pthread_mutex_unlock(&ustack->lock);

}

void uip_setdraddr4(struct uip_stack *ustack, uip_ip4addr_t *addr)

{

	pthread_mutex_lock(&ustack->lock);

	uip_ip4addr_copy(ustack->default_route_addr, (addr));

	pthread_mutex_unlock(&ustack->lock);

}

void uip_setnetmask4(struct uip_stack *ustack, uip_ip4addr_t *addr)

{

	pthread_mutex_lock(&ustack->lock);

	uip_ip4addr_copy(ustack->netmask, (addr));

	pthread_mutex_unlock(&ustack->lock);

}

void uip_setethernetmac(struct uip_stack *ustack, uint8_t *mac)

{

	pthread_mutex_lock(&ustack->lock);

	memcpy(ustack->uip_ethaddr.addr, (mac), 6);

	pthread_mutex_unlock(&ustack->lock);

}

void set_uip_stack(struct uip_stack *ustack,

		   uip_ip4addr_t *ip,

		   uip_ip4addr_t *netmask,

		   uip_ip4addr_t *default_route, uint8_t *mac_addr)

{

	if (ip)

		uip_sethostaddr4(ustack, ip);

	if (netmask)

		uip_setnetmask4(ustack, netmask);

	if (default_route)

		uip_setdraddr4(ustack, default_route);

	if (mac_addr)

		uip_setethernetmac(ustack, mac_addr);

}

#if !UIP_ARCH_ADD32

void uip_add32(u8_t *op32, u16_t op16, u8_t *uip_acc32)

{

	uip_acc32[3] = op32[3] + (op16 & 0xff);

	uip_acc32[2] = op32[2] + (op16 >> 8);

	uip_acc32[1] = op32[1];

	uip_acc32[0] = op32[0];

	if (uip_acc32[2] < (op16 >> 8)) {

		++uip_acc32[1];

		if (uip_acc32[1] == 0)

			++uip_acc32[0];

	}

	if (uip_acc32[3] < (op16 & 0xff)) {

		++uip_acc32[2];

		if (uip_acc32[2] == 0) {

			++uip_acc32[1];

			if (uip_acc32[1] == 0)

				++uip_acc32[0];

		}

	}

}

#endif /* UIP_ARCH_ADD32 */

#if !UIP_ARCH_CHKSUM

/*---------------------------------------------------------------------------*/

static u16_t chksum(u16_t sum, const u8_t *data, u16_t len)

{

	u16_t t;

	const u8_t *dataptr;

	const u8_t *last_byte;

	dataptr = data;

	last_byte = data + len - 1;

	while (dataptr < last_byte) {	/* At least two more bytes */

		t = (dataptr[0] << 8) + dataptr[1];

		sum += t;

		if (sum < t)

			sum++;	/* carry */

		dataptr += 2;

	}

	if (dataptr == last_byte) {

		t = (dataptr[0] << 8) + 0;

		sum += t;

		if (sum < t)

			sum++;	/* carry */

	}

	/* Return sum in host byte order. */

	return sum;

}

/*---------------------------------------------------------------------------*/

u16_t uip_chksum(u16_t *data, u16_t len)

{

	return htons(chksum(0, (u8_t *)data, len));

}

/*---------------------------------------------------------------------------*/

#ifndef UIP_ARCH_IPCHKSUM

u16_t uip_ipchksum(struct uip_stack *ustack)

{

	u16_t sum;

	u16_t uip_iph_len;

	if (is_ipv6(ustack))

		uip_iph_len = UIP_IPv6_H_LEN;

	else

		uip_iph_len = UIP_IPv4_H_LEN;

	sum = chksum(0, ustack->network_layer, uip_iph_len);

	return (sum == 0) ? 0xffff : htons(sum);

}

#endif

/*---------------------------------------------------------------------------*/

static u16_t upper_layer_chksum_ipv4(struct uip_stack *ustack, u8_t proto)

{

	u16_t upper_layer_len;

	u16_t sum;

	struct uip_tcp_ipv4_hdr *tcp_ipv4_hdr = NULL;

	tcp_ipv4_hdr = (struct uip_tcp_ipv4_hdr *)ustack->network_layer;

	upper_layer_len = (((u16_t) (tcp_ipv4_hdr->len[0]) << 8) +

			   tcp_ipv4_hdr->len[1]) - UIP_IPv4_H_LEN;

	/* First sum pseudoheader. */

	/* IP protocol and length fields. This addition cannot carry. */

	sum = upper_layer_len + proto;

	sum =

	    chksum(sum, (u8_t *)&tcp_ipv4_hdr->srcipaddr[0],

		   2 * sizeof(uip_ip4addr_t));

	/* Sum TCP header and data. */

	sum = chksum(sum, ustack->network_layer + UIP_IPv4_H_LEN,

		     upper_layer_len);

	return (sum == 0) ? 0xffff : htons(sum);

}

/*---------------------------------------------------------------------------*/

static uint16_t upper_layer_checksum_ipv6(uint8_t *data, uint8_t proto)

{

	uint16_t upper_layer_len;

	uint16_t sum;

	struct ip6_hdr *ipv6_hdr;

	uint8_t *upper_layer;

	uint32_t val;

	ipv6_hdr = (struct ip6_hdr *)data;

	upper_layer_len = ntohs(ipv6_hdr->ip6_plen);

	/* First sum pseudoheader. */

	sum = 0;

	sum = chksum(sum, (const u8_t *)ipv6_hdr->ip6_src.s6_addr,

		     sizeof(ipv6_hdr->ip6_src));

	sum = chksum(sum, (const u8_t *)ipv6_hdr->ip6_dst.s6_addr,

		     sizeof(ipv6_hdr->ip6_dst));

	val = htons(upper_layer_len);

	sum = chksum(sum, (u8_t *)&val, sizeof(val));

	val = htons(proto);

	sum = chksum(sum, (u8_t *)&val, sizeof(val));

	upper_layer = (uint8_t *)(ipv6_hdr + 1);

	sum = chksum(sum, upper_layer, upper_layer_len);

	return (sum == 0) ? 0xffff : htons(sum);

}

/*---------------------------------------------------------------------------*/

u16_t uip_icmp6chksum(struct uip_stack *ustack)

{

	uint8_t *data = ustack->network_layer;

	return upper_layer_checksum_ipv6(data, UIP_PROTO_ICMP6);

}

uint16_t icmpv6_checksum(uint8_t *data)

{

	return upper_layer_checksum_ipv6(data, IPPROTO_ICMPV6);

}

/*---------------------------------------------------------------------------*/

u16_t uip_tcpchksum(struct uip_stack *ustack)

{

	return upper_layer_chksum_ipv4(ustack, UIP_PROTO_TCP);

}

/*---------------------------------------------------------------------------*/

#if UIP_UDP_CHECKSUMS

static u16_t uip_udpchksum_ipv4(struct uip_stack *ustack)

{

	return upper_layer_chksum_ipv4(ustack, UIP_PROTO_UDP);

}

static u16_t uip_udpchksum_ipv6(struct uip_stack *ustack)

{

	uint8_t *data = ustack->network_layer;

	return upper_layer_checksum_ipv6(data, UIP_PROTO_UDP);

}

u16_t uip_udpchksum(struct uip_stack *ustack)

{

	if (is_ipv6(ustack))

		return uip_udpchksum_ipv6(ustack);

	else

		return uip_udpchksum_ipv4(ustack);

}

#endif /* UIP_UDP_CHECKSUMS */

#endif /* UIP_ARCH_CHKSUM */

/*---------------------------------------------------------------------------*/

void uip_init(struct uip_stack *ustack, uint8_t ipv6_enabled)

{

	u8_t c;

	for (c = 0; c < UIP_LISTENPORTS; ++c)

		ustack->uip_listenports[c] = 0;

	for (c = 0; c < UIP_CONNS; ++c)

		ustack->uip_conns[c].tcpstateflags = UIP_CLOSED;

#if UIP_ACTIVE_OPEN

	ustack->lastport = 1024;

#endif /* UIP_ACTIVE_OPEN */

#if UIP_UDP

	for (c = 0; c < UIP_UDP_CONNS; ++c)

		ustack->uip_udp_conns[c].lport = 0;

#endif /* UIP_UDP */

	/* IPv4 initialization. */

#if UIP_FIXEDADDR == 0

	/*  uip_hostaddr[0] = uip_hostaddr[1] = 0; */

#endif /* UIP_FIXEDADDR */

	/*  zero out the uIP statistics */

	memset(&ustack->stats, 0, sizeof(ustack->stats));

	/*  prepare the uIP lock */

	pthread_mutex_init(&ustack->lock, NULL);

	if (ipv6_enabled)

		ustack->enable_IPv6 = UIP_SUPPORT_IPv6_ENABLED;

	else

		ustack->enable_IPv6 = UIP_SUPPORT_IPv6_DISABLED;

	ustack->dhcpc = NULL;

	ustack->ndpc = NULL;

	ustack->ping_conf = NULL;

}

void uip_reset(struct uip_stack *ustack)

{

	/*  There was an associated DHCP object, this memory needs to be

	 *  freed */

	if (ustack->dhcpc)

		free(ustack->dhcpc);

	ndpc_exit(ustack->ndpc);

	memset(ustack, 0, sizeof(*ustack));

}

/*---------------------------------------------------------------------------*/

#if UIP_ACTIVE_OPEN

struct uip_conn *uip_connect(struct uip_stack *ustack, uip_ip4addr_t *ripaddr,

			     u16_t rport)

{

	u8_t c;

	register struct uip_conn *conn, *cconn;

	/* Find an unused local port. */

again:

	++ustack->lastport;

	if (ustack->lastport >= 32000)

		ustack->lastport = 4096;

	/* Check if this port is already in use, and if so try to find

	   another one. */

	for (c = 0; c < UIP_CONNS; ++c) {

		conn = &ustack->uip_conns[c];

		if (conn->tcpstateflags != UIP_CLOSED &&

		    conn->lport == htons(ustack->lastport)) {

			goto again;

		}

	}

	conn = 0;

	for (c = 0; c < UIP_CONNS; ++c) {

		cconn = &ustack->uip_conns[c];

		if (cconn->tcpstateflags == UIP_CLOSED) {

			conn = cconn;

			break;

		}

		if (cconn->tcpstateflags == UIP_TIME_WAIT) {

			if (conn == 0 || cconn->timer > conn->timer)

				conn = cconn;

		}

	}

	if (conn == 0)

		return 0;

	conn->tcpstateflags = UIP_SYN_SENT;

	conn->snd_nxt[0] = ustack->iss[0];

	conn->snd_nxt[1] = ustack->iss[1];

	conn->snd_nxt[2] = ustack->iss[2];

	conn->snd_nxt[3] = ustack->iss[3];

	conn->initialmss = conn->mss = UIP_TCP_MSS;

	conn->len = 1;		/* TCP length of the SYN is one. */

	conn->nrtx = 0;

	conn->timer = 1;	/* Send the SYN next time around. */

	conn->rto = UIP_RTO;

	conn->sa = 0;

	conn->sv = 16;		/* Initial value of the RTT variance. */

	conn->lport = htons(ustack->lastport);

	conn->rport = rport;

	uip_ip4addr_copy(&conn->ripaddr, ripaddr);

	return conn;

}

#endif /* UIP_ACTIVE_OPEN */

/*---------------------------------------------------------------------------*/

#if UIP_UDP

struct uip_udp_conn *uip_udp_new(struct uip_stack *ustack,

				 uip_ip4addr_t *ripaddr, u16_t rport)

{

	u8_t c;

	register struct uip_udp_conn *conn;

	/* Find an unused local port. */

again:

	++ustack->lastport;

	if (ustack->lastport >= 32000)

		ustack->lastport = 4096;

	for (c = 0; c < UIP_UDP_CONNS; ++c) {

		if (ustack->uip_udp_conns[c].lport == htons(ustack->lastport))

			goto again;

	}

	conn = 0;

	for (c = 0; c < UIP_UDP_CONNS; ++c) {

		if (ustack->uip_udp_conns[c].lport == 0) {

			conn = &ustack->uip_udp_conns[c];

			break;

		}

	}

	if (conn == 0)

		return 0;

	conn->lport = htons(ustack->lastport);

	conn->rport = rport;

	if (ripaddr == NULL)

		memset(conn->ripaddr, 0, sizeof(uip_ip4addr_t));

	else

		uip_ip4addr_copy(&conn->ripaddr, ripaddr);

	conn->ttl = UIP_TTL;

	return conn;

}

#endif /* UIP_UDP */

/*---------------------------------------------------------------------------*/

void uip_unlisten(struct uip_stack *ustack, u16_t port)

{

	u8_t c;

	for (c = 0; c < UIP_LISTENPORTS; ++c) {

		if (ustack->uip_listenports[c] == port) {

			ustack->uip_listenports[c] = 0;

			return;

		}

	}

}

/*---------------------------------------------------------------------------*/

void uip_listen(struct uip_stack *ustack, u16_t port)

{

	u8_t c;

	for (c = 0; c < UIP_LISTENPORTS; ++c) {

		if (ustack->uip_listenports[c] == 0) {

			ustack->uip_listenports[c] = port;

			return;

		}

	}

}

/**

 * Is new incoming data available?

 *

 * Will reduce to non-zero if there is new data for the application

 * present at the uip_appdata pointer. The size of the data is

 * avaliable through the uip_len variable.

 *

 * \hideinitializer

 */

int uip_newdata(struct uip_stack *ustack)

{

	return ustack->uip_flags & UIP_NEWDATA;

}

/**

 * Has previously sent data been acknowledged?

 *

 * Will reduce to non-zero if the previously sent data has been

 * acknowledged by the remote host. This means that the application

 * can send new data.

 *

 * \hideinitializer

 */

#define uip_acked()   (uip_flags & UIP_ACKDATA)

/**

 * Has the connection just been connected?

 *

 * Reduces to non-zero if the current connection has been connected to

 * a remote host. This will happen both if the connection has been

 * actively opened (with uip_connect()) or passively opened (with

 * uip_listen()).

 *

 * \hideinitializer

 */

int uip_connected(struct uip_stack *ustack)

{

	return ustack->uip_flags & UIP_CONNECTED;

}

/**

 * Has the connection been closed by the other end?

 *

 * Is non-zero if the connection has been closed by the remote

 * host. The application may then do the necessary clean-ups.

 *

 * \hideinitializer

 */

int uip_closed(struct uip_stack *ustack)

{

	return ustack->uip_flags & UIP_CLOSE;

}

/**

 * Has the connection been aborted by the other end?

 *

 * Non-zero if the current connection has been aborted (reset) by the

 * remote host.

 *

 * \hideinitializer

 */

int uip_aborted(struct uip_stack *ustack)

{

	return ustack->uip_flags & UIP_ABORT;

}

/**

 * Has the connection timed out?

 *

 * Non-zero if the current connection has been aborted due to too many

 * retransmissions.

 *

 * \hideinitializer

 */

int uip_timedout(struct uip_stack *ustack)

{

	return ustack->uip_flags & UIP_TIMEDOUT;

}

/**

 * Do we need to retransmit previously data?

 *

 * Reduces to non-zero if the previously sent data has been lost in

 * the network, and the application should retransmit it. The

 * application should send the exact same data as it did the last

 * time, using the uip_send() function.

 *

 * \hideinitializer

 */

int uip_rexmit(struct uip_stack *ustack)

{

	return ustack->uip_flags & UIP_REXMIT;

}

/**

 * Is the connection being polled by uIP?

 *

 * Is non-zero if the reason the application is invoked is that the

 * current connection has been idle for a while and should be

 * polled.

 *

 * The polling event can be used for sending data without having to

 * wait for the remote host to send data.

 *

 * \hideinitializer

 */

int uip_poll(struct uip_stack *ustack)

{

	return ustack->uip_flags & UIP_POLL;

}

int uip_initialmss(struct uip_stack *ustack)

{

	return ustack->uip_conn->initialmss;

}

int uip_mss(struct uip_stack *ustack)

{

	return ustack->uip_conn->mss;

}

/*---------------------------------------------------------------------------*/

/* XXX: IP fragment reassembly: not well-tested. */

#if UIP_REASSEMBLY && !UIP_CONF_IPV6

#define UIP_REASS_BUFSIZE (UIP_BUFSIZE - UIP_LLH_LEN)

static u8_t uip_reassbuf[UIP_REASS_BUFSIZE];

static u8_t uip_reassbitmap[UIP_REASS_BUFSIZE / (8 * 8)];

static const u8_t bitmap_bits[8] = { 0xff, 0x7f, 0x3f, 0x1f,

	0x0f, 0x07, 0x03, 0x01

};

static u16_t uip_reasslen;

static u8_t uip_reassflags;

#define UIP_REASS_FLAG_LASTFRAG 0x01

static u8_t uip_reasstmr;

#define IP_MF   0x20

static u8_t uip_reass(void)

{

	u16_t offset, len;

	u16_t i;

	/* If ip_reasstmr is zero, no packet is present in the buffer, so we

	   write the IP header of the fragment into the reassembly

	   buffer. The timer is updated with the maximum age. */

	if (uip_reasstmr == 0) {

		memcpy(uip_reassbuf, &BUF(ustack)->vhl, uip_iph_len);

		uip_reasstmr = UIP_REASS_MAXAGE;

		uip_reassflags = 0;

		/* Clear the bitmap. */

		memset(uip_reassbitmap, 0, sizeof(uip_reassbitmap));

	}

	/* Check if the incoming fragment matches the one currently present

	   in the reasembly buffer. If so, we proceed with copying the

	   fragment into the buffer. */

	if (BUF(ustack)->srcipaddr[0] == FBUF(ustack)->srcipaddr[0] &&

	    BUF(ustack)->srcipaddr[1] == FBUF(ustack)->srcipaddr[1] &&

	    BUF(ustack)->destipaddr[0] == FBUF(ustack)->destipaddr[0] &&

	    BUF(ustack)->destipaddr[1] == FBUF(ustack)->destipaddr[1] &&

	    BUF(ustack)->ipid[0] == FBUF(ustack)->ipid[0] &&

	    BUF(ustack)->ipid[1] == FBUF(ustack)->ipid[1]) {

		len =

		    (BUF(ustack)->len[0] << 8) + BUF(ustack)->len[1] -

		    (BUF(ustack)->vhl & 0x0f) * 4;

		offset =

		    (((BUF(ustack)->ipoffset[0] & 0x3f) << 8) +

		     BUF(ustack)->ipoffset[1]) * 8;

		/* If the offset or the offset + fragment length overflows the

		   reassembly buffer, we discard the entire packet. */

		if (offset > UIP_REASS_BUFSIZE ||

		    offset + len > UIP_REASS_BUFSIZE) {

			uip_reasstmr = 0;

			goto nullreturn;

		}

		/* Copy the fragment into the reassembly buffer, at the right

		   offset. */

		memcpy(&uip_reassbuf[uip_iph_len + offset],

		       (char *)BUF + (int)((BUF(ustack)->vhl & 0x0f) * 4), len);

		/* Update the bitmap. */

		if (offset / (8 * 8) == (offset + len) / (8 * 8)) {

			/* If the two endpoints are in the same byte, we only

			   update that byte. */

			uip_reassbitmap[offset / (8 * 8)] |=

			    bitmap_bits[(offset / 8) & 7] &

			    ~bitmap_bits[((offset + len) / 8) & 7];

		} else {

			/* If the two endpoints are in different bytes, we

			   update the bytes in the endpoints and fill the

			   stuff inbetween with 0xff. */

			uip_reassbitmap[offset / (8 * 8)] |=

			    bitmap_bits[(offset / 8) & 7];

			for (i = 1 + offset / (8 * 8);

			     i < (offset + len) / (8 * 8); ++i) {

				uip_reassbitmap[i] = 0xff;

			}

			uip_reassbitmap[(offset + len) / (8 * 8)] |=

			    ~bitmap_bits[((offset + len) / 8) & 7];

		}

		/* If this fragment has the More Fragments flag set to zero, we

		   know that this is the last fragment, so we can calculate the

		   size of the entire packet. We also set the

		   IP_REASS_FLAG_LASTFRAG flag to indicate that we have received

		   the final fragment. */

		if ((BUF(ustack)->ipoffset[0] & IP_MF) == 0) {

			uip_reassflags |= UIP_REASS_FLAG_LASTFRAG;

			uip_reasslen = offset + len;

		}

		/* Finally, we check if we have a full packet in the buffer.

		   We do this by checking if we have the last fragment and if

		   all bits in the bitmap are set. */

		if (uip_reassflags & UIP_REASS_FLAG_LASTFRAG) {

			/* Check all bytes up to and including all but the last

			   byte in the bitmap. */

			for (i = 0; i < uip_reasslen / (8 * 8) - 1; ++i) {

				if (uip_reassbitmap[i] != 0xff)

					goto nullreturn;

			}

			/* Check the last byte in the bitmap. It should contain

			   just the right amount of bits. */

			if (uip_reassbitmap[uip_reasslen / (8 * 8)] !=

			    (u8_t) ~bitmap_bits[uip_reasslen / 8 & 7])

				goto nullreturn;

			/* If we have come this far, we have a full packet in

			   the buffer, so we allocate a pbuf and copy the

			   packet into it. We also reset the timer. */

			uip_reasstmr = 0;

			memcpy(BUF, FBUF, uip_reasslen);

			/* Pretend to be a "normal" (i.e., not fragmented) IP

			   packet from now on. */

			BUF(ustack)->ipoffset[0] = BUF(ustack)->ipoffset[1] = 0;

			BUF(ustack)->len[0] = uip_reasslen >> 8;

			BUF(ustack)->len[1] = uip_reasslen & 0xff;

			BUF(ustack)->ipchksum = 0;

			BUF(ustack)->ipchksum = ~(uip_ipchksum());

			return uip_reasslen;

		}

	}

nullreturn:

	return 0;

}

#endif /* UIP_REASSEMBLY */

/*---------------------------------------------------------------------------*/

static void uip_add_rcv_nxt(struct uip_stack *ustack, u16_t n)

{

	u8_t uip_acc32[4];

	uip_add32(ustack->uip_conn->rcv_nxt, n, uip_acc32);

	ustack->uip_conn->rcv_nxt[0] = uip_acc32[0];

	ustack->uip_conn->rcv_nxt[1] = uip_acc32[1];

	ustack->uip_conn->rcv_nxt[2] = uip_acc32[2];

	ustack->uip_conn->rcv_nxt[3] = uip_acc32[3];

}

/*---------------------------------------------------------------------------*/

/** @} */

/**

 * \defgroup uipdevfunc uIP device driver functions

 * @{

 *

 * These functions are used by a network device driver for interacting

 * with uIP.

 */

/**

 * Process an incoming packet.

 *

 * This function should be called when the device driver has received

 * a packet from the network. The packet from the device driver must

 * be present in the uip_buf buffer, and the length of the packet

 * should be placed in the uip_len variable.

 *

 * When the function returns, there may be an outbound packet placed

 * in the uip_buf packet buffer. If so, the uip_len variable is set to