/*

 * Copyright (c) 2011, Broadcom Corporation

 * Copyright (c) 2014, QLogic Corporation

 *

 * Written by:  Eddie Wai  (eddie.wai@broadcom.com)

 *              Based on Kevin Tran's iSCSI boot code

 *

 * 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. All advertising materials mentioning features or use of this software

 *    must display the following acknowledgement:

 *      This product includes software developed by Adam Dunkels.

 * 4. 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.

 *

 * ipv6.c - This file contains simplifed IPv6 processing code.

 *

 */

#include <stdio.h>

#include <string.h>

#include <arpa/inet.h>

#include "logger.h"

#include "uip.h"

#include "ipv6.h"

#include "ipv6_pkt.h"

#include "icmpv6.h"

#include "uipopt.h"

#include "dhcpv6.h"

#include "ping.h"

static inline int best_match_bufcmp(u8_t *a, u8_t *b, int len)

{

	int i;

	for (i = 0; i < len; i++) {

		if (a[i] != b[i])

			break;

	}

	return i;

}

/* Local function prototypes */

static int ipv6_is_it_our_address(struct ipv6_context *context,

				  struct ipv6_addr *ip_addr);

static void ipv6_insert_protocol_chksum(struct ipv6_hdr *ipv6);

static void ipv6_update_arp_table(struct ipv6_context *context,

				  struct ipv6_addr *ip_addr,

				  struct mac_address *mac_addr);

static void ipv6_icmp_init_link_option(struct ipv6_context *context,

				       struct icmpv6_opt_link_addr *link_opt,

				       u8_t type);

static void ipv6_icmp_rx(struct ipv6_context *context);

static void ipv6_icmp_handle_nd_adv(struct ipv6_context *context);

static void ipv6_icmp_handle_nd_sol(struct ipv6_context *context);

static void ipv6_icmp_handle_echo_request(struct ipv6_context *context);

static void ipv6_icmp_handle_router_adv(struct ipv6_context *context);

static void ipv6_icmp_process_prefix(struct ipv6_context *context,

				     struct icmpv6_opt_prefix *icmp_prefix);

static void ipv6_udp_rx(struct ipv6_context *context);

int iscsiL2Send(struct ipv6_context *context, int pkt_len)

{

	LOG_DEBUG("IPv6: iscsiL2Send");

	uip_send(context->ustack,

		 (void *)context->ustack->data_link_layer, pkt_len);

	return pkt_len;

}

int iscsiL2AddMcAddr(struct ipv6_context *context,

		     struct mac_address *new_mc_addr)

{

	int i;

	struct mac_address *mc_addr;

	const struct mac_address all_zeroes_mc = { { { 0, 0, 0, 0, 0, 0 } } };

	mc_addr = context->mc_addr;

	for (i = 0; i < MAX_MCADDR_TABLE; i++, mc_addr++)

		if (!memcmp((char *)mc_addr,

			    (char *)new_mc_addr, sizeof(struct mac_address)))

			return TRUE;	/* Already in the mc table */

	mc_addr = context->mc_addr;

	for (i = 0; i < MAX_MCADDR_TABLE; i++, mc_addr++) {

		if (!memcmp((char *)mc_addr,

		    (char *)&all_zeroes_mc, sizeof(struct mac_address))) {

			memcpy((char *)mc_addr,

			       (char *)new_mc_addr, sizeof(struct mac_address));

			LOG_DEBUG("IPv6: mc_addr added "

				  "%02x:%02x:%02x:%02x:%02x:%02x",

				  *(u8_t *)new_mc_addr,

				  *((u8_t *)new_mc_addr + 1),

				  *((u8_t *)new_mc_addr + 2),

				  *((u8_t *)new_mc_addr + 3),

				  *((u8_t *)new_mc_addr + 4),

				  *((u8_t *)new_mc_addr + 5));

			return TRUE;

		}

	}

	return FALSE;

}

int iscsiL2IsOurMcAddr(struct ipv6_context *context,

		       struct mac_address *dest_mac)

{

	int i;

	struct mac_address *mc_addr;

	mc_addr = context->mc_addr;

	for (i = 0; i < MAX_MCADDR_TABLE; i++, mc_addr++)

		if (!memcmp((char *)mc_addr,

			    (char *)dest_mac->addr, sizeof(struct mac_address)))

			return TRUE;

	return FALSE;

}

void ipv6_init(struct ndpc_state *ndp, int cfg)

{

	int i;

	struct ipv6_context *context = (struct ipv6_context *)ndp->ipv6_context;

	struct mac_address *mac_addr = (struct mac_address *)ndp->mac_addr;

	struct ipv6_arp_entry *ipv6_arp_table;

	struct ipv6_prefix_entry *ipv6_prefix_table;

	struct mac_address mc_addr;

	if (context == NULL) {

		LOG_ERR("IPV6: INIT ipv6_context is NULL");

		return;

	}

	memset((char *)context, 0, sizeof(struct ipv6_context));

	/* Associate the nic_iface's ustack to this ipv6_context */

	context->ustack = ndp->ustack;

	ipv6_arp_table = &context->ipv6_arp_table[0];

	ipv6_prefix_table = &context->ipv6_prefix_table[0];

	memset((char *)ipv6_arp_table, 0, sizeof(*ipv6_arp_table));

	memset((char *)ipv6_prefix_table, 0, sizeof(*ipv6_prefix_table));

	memcpy((char *)&context->mac_addr,

	       (char *)mac_addr, sizeof(struct mac_address));

	/*

	 * Per RFC 2373.

	 * There are two types of local-use unicast addresses defined.  These

	 * are Link-Local and Site-Local.  The Link-Local is for use on a single

	 * link and the Site-Local is for use in a single site.  Link-Local

	 * addresses have the following format:

	 *

	 * |   10     |

	 * |  bits    |        54 bits          |          64 bits           |

	 * +----------+-------------------------+----------------------------+

	 * |1111111010|           0             |       interface ID         |

	 * +----------+-------------------------+----------------------------+

	 */

	if (context->ustack->linklocal_autocfg != IPV6_LL_AUTOCFG_OFF) {

		context->link_local_addr.addr8[0] = 0xfe;

		context->link_local_addr.addr8[1] = 0x80;

		/* Bit 1 is 1 to indicate universal scope. */

		context->link_local_addr.addr8[8] = mac_addr->addr[0] | 0x2;

		context->link_local_addr.addr8[9] = mac_addr->addr[1];

		context->link_local_addr.addr8[10] = mac_addr->addr[2];

		context->link_local_addr.addr8[11] = 0xff;

		context->link_local_addr.addr8[12] = 0xfe;

		context->link_local_addr.addr8[13] = mac_addr->addr[3];

		context->link_local_addr.addr8[14] = mac_addr->addr[4];

		context->link_local_addr.addr8[15] = mac_addr->addr[5];

		context->link_local_multi.addr8[0] = 0xff;

		context->link_local_multi.addr8[1] = 0x02;

		context->link_local_multi.addr8[11] = 0x01;

		context->link_local_multi.addr8[12] = 0xff;

		context->link_local_multi.addr8[13] |=

		    context->link_local_addr.addr8[13];

		context->link_local_multi.addr16[7] =

		    context->link_local_addr.addr16[7];

		/* Default Prefix length is 64 */

		/* Add Link local address to the head of the ipv6 address

		   list */

		ipv6_add_prefix_entry(context,

				      &context->link_local_addr, 64);

	}

	/*

	 * Convert Multicast IP address to Multicast MAC adress per

	 * RFC 2464: Transmission of IPv6 Packets over Ethernet Networks

	 *

	 * An IPv6 packet with a multicast destination address DST, consisting

	 * of the sixteen octets DST[1] through DST[16], is transmitted to the

	 * Ethernet multicast address whose first two octets are the value 3333

	 * hexadecimal and whose last four octets are the last four octets of

	 * DST.

	 *

	 *          +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

	 *          |0 0 1 1 0 0 1 1|0 0 1 1 0 0 1 1|

	 *          +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

	 *          |   DST[13]     |   DST[14]     |

	 *          +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

	 *          |   DST[15]     |   DST[16]     |

	 *          +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

	 *

	 * IPv6 requires the following Multicast IP addresses setup per node.

	 */

	for (i = 0; i < 3; i++) {

		mc_addr.addr[0] = 0x33;

		mc_addr.addr[1] = 0x33;

		mc_addr.addr[2] = 0x0;

		mc_addr.addr[3] = 0x0;

		mc_addr.addr[4] = 0x0;

		switch (i) {

		case 0:

			/* All Nodes Multicast IPv6 address : ff02::1 */

			mc_addr.addr[5] = 0x1;

			break;

		case 1:

			/* All Host Multicast IPv6 address : ff02::3 */

			mc_addr.addr[5] = 0x3;

			break;

		case 2:

			/* Solicited Node Multicast Address: ff02::01:ffxx:yyzz

			 */

			mc_addr.addr[2] = 0xff;

			mc_addr.addr[3] = mac_addr->addr[3];

			mc_addr.addr[4] = mac_addr->addr[4];

			mc_addr.addr[5] = mac_addr->addr[5];

			break;

		default:

			break;

		}

		iscsiL2AddMcAddr(context, &mc_addr);

	}

	/* Default HOP number */

	context->hop_limit = IPV6_HOP_LIMIT;

}

int ipv6_add_prefix_entry(struct ipv6_context *context,

			  struct ipv6_addr *ip_addr, u8_t prefix_len)

{

	int i;

	struct ipv6_prefix_entry *prefix_entry;

	struct ipv6_prefix_entry *ipv6_prefix_table =

				  context->ipv6_prefix_table;

	char addr_str[INET6_ADDRSTRLEN];

	/* Check if there is an valid entry already. */

	for (i = 0; i < IPV6_NUM_OF_ADDRESS_ENTRY; i++) {

		prefix_entry = &ipv6_prefix_table[i];

		if (prefix_entry->prefix_len != 0) {

			if (memcmp((char *)&prefix_entry->ip_addr,

				   (char *)ip_addr,

				   sizeof(struct ipv6_addr)) == 0) {

				/* We already initialize on this interface.

				   There is nothing to do */

				return 0;

			}

		}

	}

	/* Find an unused entry */

	for (i = 0; i < IPV6_NUM_OF_ADDRESS_ENTRY; i++) {

		prefix_entry = &ipv6_prefix_table[i];

		if (prefix_entry->prefix_len == 0)

			break;

	}

	if (prefix_entry->prefix_len != 0)

		return -1;

	prefix_entry->prefix_len = prefix_len / 8;

	memcpy((char *)&prefix_entry->ip_addr,

	       (char *)ip_addr, sizeof(struct ipv6_addr));

	inet_ntop(AF_INET6, &prefix_entry->ip_addr.addr8, addr_str,

		  sizeof(addr_str));

	LOG_DEBUG("IPv6: add prefix IP addr %s", addr_str);

	/* Put it on the list on head of the list. */

	if (context->addr_list != NULL)

		prefix_entry->next = context->addr_list;

	else

		prefix_entry->next = NULL;

	context->addr_list = prefix_entry;

	return 0;

}

void ipv6_rx_packet(struct ipv6_context *context, u16_t len)

{

	struct ipv6_hdr *ipv6;

	u16_t protocol;

	if (!context->ustack) {

		LOG_WARN("ipv6 rx pkt ipv6_context = %p ustack = %p", context,

			 context->ustack);

		return;

	}

	ipv6 = (struct ipv6_hdr *)context->ustack->network_layer;

	/* Make sure it's an IPv6 packet */

	if ((ipv6->ipv6_version_fc & 0xf0) != IPV6_VERSION) {

		/* It's not an IPv6 packet. Drop it. */

		LOG_WARN("IPv6 version 0x%x not IPv6", ipv6->ipv6_version_fc);

		return;

	}

	protocol = ipv6_process_rx(ipv6);

	switch (protocol) {

	case IPPROTO_ICMPV6:

		ipv6_icmp_rx(context);

		break;

	case IPPROTO_UDP:

		/* Indicate to UDP processing code */

		ipv6_udp_rx(context);

		break;

	default:

		break;

	}

}

void ipv6_mc_init_dest_mac(struct eth_hdr *eth, struct ipv6_hdr *ipv6)

{

	int i;

	/*

	 * Initialize address mapping of IPV6 Multicast to multicast MAC

	 * address per RFC 2464.

	 *

	 * An IPv6 packet with a multicast destination address DST, consisting

	 * of the sixteen octets DST[1] through DST[16], is transmitted to the

	 * Ethernet multicast address whose first two octets are the value 3333

	 * hexadecimal and whose last four octets are the last four octets of

	 * DST.

	 *

	 *              +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

	 *              |0 0 1 1 0 0 1 1|0 0 1 1 0 0 1 1|

	 *              +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

	 *              |   DST[13]     |   DST[14]     |

	 *              +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

	 *              |   DST[15]     |   DST[16]     |

	 *              +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

	 */

	eth->dest_mac.addr[0] = 0x33;

	eth->dest_mac.addr[1] = 0x33;

	for (i = 0; i < 4; i++)

		eth->dest_mac.addr[2 + i] = ipv6->ipv6_dst.addr8[12 + i];

}

int ipv6_autoconfig(struct ipv6_context *context)

{

	return ipv6_discover_address(context);

}

int ipv6_discover_address(struct ipv6_context *context)

{

	struct eth_hdr *eth =

			(struct eth_hdr *)context->ustack->data_link_layer;

	struct ipv6_hdr *ipv6 =

			(struct ipv6_hdr *)context->ustack->network_layer;

	struct icmpv6_hdr *icmp = (struct icmpv6_hdr *)((u8_t *)ipv6 +

						sizeof(struct ipv6_hdr));

	int rc = 0;

	/* Retrieve tx buffer */

	if (eth == NULL || ipv6 == NULL)

		return -EAGAIN;

	/* Setup IPv6 All Routers Multicast address : ff02::2 */

	memset((char *)&ipv6->ipv6_dst, 0, sizeof(struct ipv6_addr));

	ipv6->ipv6_dst.addr8[0] = 0xff;

	ipv6->ipv6_dst.addr8[1] = 0x02;

	ipv6->ipv6_dst.addr8[15] = 0x02;

	ipv6->ipv6_hop_limit = 255;

	/* Initialize MAC header based on destination MAC address */

	ipv6_mc_init_dest_mac(eth, ipv6);

	ipv6->ipv6_nxt_hdr = IPPROTO_ICMPV6;

	icmp->icmpv6_type = ICMPV6_RTR_SOL;

	icmp->icmpv6_code = 0;

	icmp->icmpv6_data = 0;

	icmp->icmpv6_cksum = 0;

	ipv6_icmp_init_link_option(context,

				   (struct icmpv6_opt_link_addr *)((u8_t *)icmp

					+ sizeof(struct icmpv6_hdr)),

					IPV6_ICMP_OPTION_SRC_ADDR);

	ipv6->ipv6_plen = HOST_TO_NET16((sizeof(struct icmpv6_hdr) +

					 sizeof(struct icmpv6_opt_link_addr)));

	memcpy((char *)&ipv6->ipv6_src,

	       (char *)&context->link_local_addr,

	       sizeof(struct ipv6_addr));

	icmp->icmpv6_cksum = 0;

	LOG_DEBUG("IPv6: Send rtr sol");

	ipv6_send(context, (u8_t *) icmp - (u8_t *) eth +

		  sizeof(struct icmpv6_hdr) +

		  sizeof(struct icmpv6_opt_link_addr));

	return rc;

}

u16_t ipv6_process_rx(struct ipv6_hdr *ipv6)

{

	return ipv6->ipv6_nxt_hdr;

}

int ipv6_send(struct ipv6_context *context, u16_t packet_len)

{

	struct eth_hdr *eth =

			(struct eth_hdr *)context->ustack->data_link_layer;

	struct ipv6_hdr *ipv6 =

			(struct ipv6_hdr *)context->ustack->network_layer;

	ipv6_setup_hdrs(context, eth, ipv6, packet_len);

	return iscsiL2Send(context, packet_len);

}

void ipv6_send_udp_packet(struct ipv6_context *context, u16_t packet_len)

{

	struct eth_hdr *eth =

			(struct eth_hdr *)context->ustack->data_link_layer;

	struct ipv6_hdr *ipv6 =

			(struct ipv6_hdr *)context->ustack->network_layer;

	struct udp_hdr *udp = (struct udp_hdr *)((u8_t *)ipv6 +

						 sizeof(struct ipv6_hdr));

	ipv6->ipv6_nxt_hdr = IPPROTO_UDP;

	ipv6->ipv6_plen =

	    HOST_TO_NET16(packet_len - ((u8_t *)udp - (u8_t *)eth));

	udp->chksum = 0;

	/*

	 * We only use UDP packet for DHCPv6.  The source address is always

	 * link-local address.

	 */

	ipv6->ipv6_src.addr[0] = 0;

	/* Hop limit is always 1 for DHCPv6 packet. */

	ipv6->ipv6_hop_limit = 1;

	ipv6_send(context, packet_len);

}

void ipv6_setup_hdrs(struct ipv6_context *context, struct eth_hdr *eth,

		     struct ipv6_hdr *ipv6, u16_t packet_len)

{

	struct ipv6_addr *our_address;

	/* VLAN will be taken cared of in the nic layer */

	eth->len_type = HOST_TO_NET16(LAYER2_TYPE_IPV6);

	memcpy((char *)&eth->src_mac,

	       (char *)&context->mac_addr, sizeof(struct mac_address));

	/* Put the traffic class into the packet. */

	memset(&ipv6->ipv6_version_fc, 0, sizeof(u32_t));

	ipv6->ipv6_version_fc = IPV6_VERSION;

	if (ipv6->ipv6_hop_limit == 0)

		ipv6->ipv6_hop_limit = context->hop_limit;

	if (ipv6->ipv6_src.addr[0] == 0) {

		/* Need to initialize source IP address. */

		our_address = ipv6_our_address(context);

		if (our_address != NULL) {

			/* Assume that caller has filled in the destination

			   IP address */

			memcpy((char *)&ipv6->ipv6_src,

			       (char *)our_address, sizeof(struct ipv6_addr));

		}

	}

	ipv6_insert_protocol_chksum(ipv6);

}

static void ipv6_insert_protocol_chksum(struct ipv6_hdr *ipv6)

{

	u32_t sum;

	u16_t *ptr;

	u16_t *protocol_data_ptr;

	int i;

	u16_t protocol_data_len;

	u16_t checksum;

	/*

	 * This routine assumes that there is no extension header. This driver

	 * doesn't user extension header to keep driver small and simple.

	 *

	 * Pseudo check consists of the following:

	 * SRC IP, DST IP, Protocol Data Length, and Next Header.

	 */

	sum = 0;

	ptr = (u16_t *)&ipv6->ipv6_src;

	for (i = 0; i < sizeof(struct ipv6_addr); i += 2) {

		sum += HOST_TO_NET16(*ptr);

		ptr++;

	}

	/* Keep track where the layer header is */

	protocol_data_ptr = ptr;

	protocol_data_len = HOST_TO_NET16(ipv6->ipv6_plen);

	sum += protocol_data_len;

	sum += ipv6->ipv6_nxt_hdr;

	/* Sum now contains sum of IPv6 pseudo header.  Let's add the data

	   streams. */

	if (protocol_data_len & 1) {

		/* Length of data is odd */

		*((u8_t *) ptr + protocol_data_len) = 0;

		protocol_data_len++;

	}

	for (i = 0; i < protocol_data_len / 2; i++) {

		sum += HOST_TO_NET16(*ptr);

		ptr++;

	}

	sum = (sum >> 16) + (sum & 0xffff);

	sum += (sum >> 16);

	sum &= 0xffff;

	checksum = (u16_t) (~sum);

	checksum = HOST_TO_NET16(checksum);

	switch (ipv6->ipv6_nxt_hdr) {

	case IPPROTO_ICMPV6:

		/* Insert correct ICMPv6 checksum */

		((struct icmpv6_hdr *)(protocol_data_ptr))->icmpv6_cksum =

			checksum;

		break;

	case IPPROTO_UDP:

		/* Insert correct UDP checksum */

		((struct udp_hdr *)protocol_data_ptr)->chksum = checksum;

		break;

	default:

		break;

	}

}

int ipv6_is_it_our_link_local_address(struct ipv6_context *context,

				      struct ipv6_addr *ip_addr)

{

	u8_t *test_addr = (u8_t *) ip_addr->addr8;

	u8_t test_remainder;

	if (test_addr[0] != context->link_local_addr.addr8[0])

		return FALSE;

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

	if (test_remainder != 2)

		return FALSE;

	return TRUE;

}

static int ipv6_is_it_our_address(struct ipv6_context *context,

				  struct ipv6_addr *ipv6_addr)

{

	struct ipv6_prefix_entry *ipv6_prefix;

	for (ipv6_prefix = context->addr_list; ipv6_prefix != NULL;

	     ipv6_prefix = ipv6_prefix->next) {

		if (IPV6_ARE_ADDR_EQUAL(&ipv6_prefix->ip_addr, ipv6_addr))

			return TRUE;

	}

	return FALSE;

}

struct ipv6_addr *ipv6_our_address(struct ipv6_context *context)

{

	return &context->link_local_addr;

}

int ipv6_ip_in_arp_table(struct ipv6_context *context,

			 struct ipv6_addr *ip_addr,

			 struct mac_address *mac_addr)

{

	struct ipv6_arp_entry *arp_entry;

	int i;

	for (i = 0; i < UIP_ARPTAB_SIZE; i++) {

		arp_entry = &context->ipv6_arp_table[i];

		if (IPV6_ARE_ADDR_EQUAL(&arp_entry->ip_addr, ip_addr)) {

			memcpy((char *)mac_addr, &arp_entry->mac_addr,

			       sizeof(struct mac_address));

			return 1;

		}

	}

	return 0;

}

struct ipv6_addr *ipv6_find_longest_match(struct ipv6_context *context,

				   struct ipv6_addr *ip_addr)

{

	struct ipv6_prefix_entry *ipv6_prefix;

	struct ipv6_prefix_entry *best_match = NULL;

	int longest_len = -1;

	int len;

	for (ipv6_prefix = context->addr_list; ipv6_prefix != NULL;

	     ipv6_prefix = ipv6_prefix->next) {

		if (!IPV6_IS_ADDR_LINKLOCAL(&ipv6_prefix->ip_addr)) {

			len = best_match_bufcmp((u8_t *)&ipv6_prefix->ip_addr,

						(u8_t *)ip_addr,

						sizeof(struct ipv6_addr));

			if (len > longest_len) {

				best_match = ipv6_prefix;

				longest_len = len;

			}

		}

	}

	if (best_match)

		return &best_match->ip_addr;

	return NULL;

}

void ipv6_arp_out(struct ipv6_context *context, int *uip_len)

{

	/* Empty routine */

}

static void ipv6_update_arp_table(struct ipv6_context *context,

				  struct ipv6_addr *ip_addr,

				  struct mac_address *mac_addr)

{

	struct ipv6_arp_entry *arp_entry;

	int i;

	struct ipv6_arp_entry *ipv6_arp_table = context->ipv6_arp_table;

	LOG_DEBUG("IPv6: Neighbor update");

	/*

	 * Walk through the ARP mapping table and try to find an entry to

	 * update. If none is found, the IP -> MAC address mapping is

	 * inserted in the ARP table.

	 */

	for (i = 0; i < UIP_ARPTAB_SIZE; i++) {

		arp_entry = &ipv6_arp_table[i];

		/* Only check those entries that are actually in use. */

		if (arp_entry->ip_addr.addr[0] != 0) {

			/*

			 * Check if the source IP address of the incoming

			 * packet matches the IP address in this ARP table

			 * entry.

			 */

			if (IPV6_ARE_ADDR_EQUAL(&arp_entry->ip_addr, ip_addr)) {

				/* An old entry found, update this and return */

				memcpy((char *)&arp_entry->mac_addr,

				       (char *)mac_addr,

				       sizeof(struct mac_address));

				arp_entry->time = context->arptime;

				return;

			}

		}

	}

	/*

	 * If we get here, no existing ARP table entry was found, so we

	 * create one.

	 *

	 * First, we try to find an unused entry in the ARP table.

	 */

	for (i = 0; i < UIP_ARPTAB_SIZE; i++) {

		arp_entry = &ipv6_arp_table[i];

		if (arp_entry->ip_addr.addr[0] == 0)

			break;

	}

	if (i == UIP_ARPTAB_SIZE)

		return;

	/* Index j is the entry that is least used */

	arp_entry = &ipv6_arp_table[i];

	memcpy((char *)&arp_entry->ip_addr, (char *)ip_addr,

	       sizeof(struct ipv6_addr));

	memcpy((char *)&arp_entry->mac_addr,

	       (char *)mac_addr, sizeof(struct mac_address));

	arp_entry->time = context->arptime;

}

/* DestIP is intact */

int ipv6_send_nd_solicited_packet(struct ipv6_context *context,

				  struct eth_hdr *eth, struct ipv6_hdr *ipv6)

{

	struct icmpv6_hdr *icmp;

	int pkt_len = 0;

	struct ipv6_addr *longest_match_addr;

	char addr_str[INET6_ADDRSTRLEN];

	ipv6->ipv6_nxt_hdr = IPPROTO_ICMPV6;

	/* Depending on the IPv6 address of the target, we'll need to determine

	   whether we use the assigned IPv6 address/RA or the link local address

	*/

	/* Use Link-local as source address */

	if (ipv6_is_it_our_link_local_address(context, &ipv6->ipv6_dst) ==

	    TRUE) {

		LOG_DEBUG("IPv6: NS using link local");

		memcpy((char *)&ipv6->ipv6_src,

		       (char *)&context->link_local_addr,

		       sizeof(struct ipv6_addr));

	} else {

		longest_match_addr =

		    ipv6_find_longest_match(context, &ipv6->ipv6_dst);

		if (longest_match_addr) {

			LOG_DEBUG("IPv6: NS using longest match addr");

			memcpy((char *)&ipv6->ipv6_src,

			       (char *)longest_match_addr,

			       sizeof(struct ipv6_addr));

		} else {

			LOG_DEBUG("IPv6: NS using link local instead");

			memcpy((char *)&ipv6->ipv6_src,

			       (char *)&context->link_local_addr,

			       sizeof(struct ipv6_addr));

		}

	}

	icmp = (struct icmpv6_hdr *)((u8_t *)ipv6 + sizeof(struct ipv6_hdr));

	inet_ntop(AF_INET6, &ipv6->ipv6_src.addr8, addr_str, sizeof(addr_str));

	LOG_DEBUG("IPv6: NS host IP addr: %s", addr_str);

	/*

	 * Destination IP address to be resolved is after the ICMPv6

	 * header.

	 */

	memcpy((char *)((u8_t *)icmp + sizeof(struct icmpv6_hdr)),

	       (char *)&ipv6->ipv6_dst, sizeof(struct ipv6_addr));

	/*

	 * Destination IP in the IPv6 header contains solicited-node multicast

	 * address corresponding to the target address.

	 *

	 * ff02::01:ffxx:yyzz. Where xyz are least

	 * significant of 24-bit MAC address.

	 */

	memset((char *)&ipv6->ipv6_dst, 0, sizeof(struct ipv6_addr) - 3);

	ipv6->ipv6_dst.addr8[0] = 0xff;

	ipv6->ipv6_dst.addr8[1] = 0x02;

	ipv6->ipv6_dst.addr8[11] = 0x01;

	ipv6->ipv6_dst.addr8[12] = 0xff;

	ipv6_mc_init_dest_mac(eth, ipv6);

	ipv6->ipv6_hop_limit = 255;

	icmp->icmpv6_type = ICMPV6_NEIGH_SOL;

	icmp->icmpv6_code = 0;

	icmp->icmpv6_data = 0;

	icmp->icmpv6_cksum = 0;

	ipv6_icmp_init_link_option(context,

				   (struct icmpv6_opt_link_addr *)((u8_t *)icmp

						+ sizeof(struct icmpv6_hdr)

						+ sizeof(struct ipv6_addr)),

						IPV6_ICMP_OPTION_SRC_ADDR);

	ipv6->ipv6_plen = HOST_TO_NET16((sizeof(struct icmpv6_hdr) +

			  sizeof(struct icmpv6_opt_link_addr) +

			  sizeof(struct ipv6_addr)));

	/* Total packet size */

	pkt_len = (u8_t *) icmp - (u8_t *) eth +

	    sizeof(struct icmpv6_hdr) +

	    sizeof(struct icmpv6_opt_link_addr) + sizeof(struct ipv6_addr);

	ipv6_setup_hdrs(context, eth, ipv6, pkt_len);

	return pkt_len;

}

static void ipv6_icmp_init_link_option(struct ipv6_context *context,

				       struct icmpv6_opt_link_addr *link_opt,

				       u8_t type)

{

	link_opt->hdr.type = type;

	link_opt->hdr.len = sizeof(struct icmpv6_opt_link_addr) / 8;

	memcpy((char *)&link_opt->link_addr,

	       (char *)&context->mac_addr, sizeof(struct mac_address));

}

static void ipv6_icmp_rx(struct ipv6_context *context)

{

	struct ipv6_hdr *ipv6 =

			(struct ipv6_hdr *)context->ustack->network_layer;

	struct icmpv6_hdr *icmp = (struct icmpv6_hdr *)((u8_t *)ipv6 +

						sizeof(struct ipv6_hdr));

	uip_icmp_echo_hdr_t *icmp_echo_hdr =

				(uip_icmp_echo_hdr_t *)((u8_t *)ipv6 +

						sizeof(struct ipv6_hdr));

	switch (icmp->icmpv6_type) {

	case ICMPV6_RTR_ADV:

		ipv6_icmp_handle_router_adv(context);

		break;

	case ICMPV6_NEIGH_SOL:

		ipv6_icmp_handle_nd_sol(context);

		break;

	case ICMPV6_NEIGH_ADV:

		ipv6_icmp_handle_nd_adv(context);

		break;

	case ICMPV6_ECHO_REQUEST:

		/* Response with ICMP reply */

		ipv6_icmp_handle_echo_request(context);

		break;

	case ICMPV6_ECHO_REPLY:

		/* Handle ICMP reply */

		process_icmp_packet(icmp_echo_hdr, context->ustack);

		break;

	default:

		break;

	}

}

static void ipv6_icmp_handle_router_adv(struct ipv6_context *context)

{

	struct ipv6_hdr *ipv6 =

			(struct ipv6_hdr *)context->ustack->network_layer;

	struct icmpv6_router_advert *icmp =

	(struct icmpv6_router_advert *)((u8_t *)ipv6 + sizeof(struct ipv6_hdr));

	struct icmpv6_opt_hdr *icmp_opt;

	u16_t opt_len;

	u16_t len;

	char addr_str[INET6_ADDRSTRLEN];

	if (context->flags & IPV6_FLAGS_ROUTER_ADV_RECEIVED)

		return;

	opt_len = HOST_TO_NET16(ipv6->ipv6_plen) -

		  sizeof(struct icmpv6_router_advert);

	icmp_opt = (struct icmpv6_opt_hdr *)((u8_t *)icmp +

				      sizeof(struct icmpv6_router_advert));

	len = 0;

	while (len < opt_len) {

		icmp_opt = (struct icmpv6_opt_hdr *)((u8_t *)icmp +

					sizeof(struct icmpv6_router_advert) +

					len);

		switch (icmp_opt->type) {

		case IPV6_ICMP_OPTION_PREFIX:

			ipv6_icmp_process_prefix(context,

					(struct icmpv6_opt_prefix *)icmp_opt);

			context->flags |= IPV6_FLAGS_ROUTER_ADV_RECEIVED;

			break;

		default: