[thirdparty/u-boot.git] / net / ndisc.c

// SPDX-License-Identifier: GPL-2.0+
/*
 * Copyright (C) 2013 Allied Telesis Labs NZ
 * Chris Packham, <judge.packham@gmail.com>
 *
 * Copyright (C) 2022 YADRO
 * Viacheslav Mitrofanov <v.v.mitrofanov@yadro.com>
 */

/* Neighbour Discovery for IPv6 */

#include <common.h>
#include <net.h>
#include <net6.h>
#include <ndisc.h>
#include <stdlib.h>
#include <linux/delay.h>

/* IPv6 destination address of packet waiting for ND */
struct in6_addr net_nd_sol_packet_ip6 = ZERO_IPV6_ADDR;
/* IPv6 address we are expecting ND advert from */
static struct in6_addr net_nd_rep_packet_ip6 = ZERO_IPV6_ADDR;
/* MAC destination address of packet waiting for ND */
uchar *net_nd_packet_mac;
/* pointer to packet waiting to be transmitted after ND is resolved */
uchar *net_nd_tx_packet;
static uchar net_nd_packet_buf[PKTSIZE_ALIGN + PKTALIGN];
/* size of packet waiting to be transmitted */
int net_nd_tx_packet_size;
/* the timer for ND resolution */
ulong net_nd_timer_start;
/* the number of requests we have sent so far */
int net_nd_try;
struct in6_addr all_routers = ALL_ROUTERS_MULT_ADDR;

#define MAX_RTR_SOLICITATIONS		3
/* The maximum time to delay sending the first router solicitation message. */
#define MAX_SOLICITATION_DELAY		1 // 1 second
/* The time to wait before sending the next router solicitation message. */
#define RTR_SOLICITATION_INTERVAL	4000 // 4 seconds

#define IP6_NDISC_OPT_SPACE(len) (((len) + 2 + 7) & ~7)

/**
 * ndisc_insert_option() - Insert an option into a neighbor discovery packet
 *
 * @opt:	pointer to the option element of the neighbor discovery packet
 * @type:	option type to insert
 * @data:	option data to insert
 * @len:	data length
 * Return: the number of bytes inserted (which may be >= len)
 */
static int ndisc_insert_option(__u8 *opt, int type, u8 *data, int len)
{
	int space = IP6_NDISC_OPT_SPACE(len);

	opt[0] = type;
	opt[1] = space >> 3;
	memcpy(&opt[2], data, len);
	len += 2;

	/* fill the remainder with 0 */
	if (space - len > 0)
		memset(&opt[len], '\0', space - len);

	return space;
}

/**
 * ndisc_extract_enetaddr() - Extract the Ethernet address from a ND packet
 *
 * Note that the link layer address could be anything but the only networking
 * media that u-boot supports is Ethernet so we assume we're extracting a 6
 * byte Ethernet MAC address.
 *
 * @ndisc:	pointer to ND packet
 * @enetaddr:	extracted MAC addr
 */
static void ndisc_extract_enetaddr(struct nd_msg *ndisc, uchar enetaddr[6])
{
	memcpy(enetaddr, &ndisc->opt[2], 6);
}

/**
 * ndisc_has_option() - Check if the ND packet has the specified option set
 *
 * @ip6:	pointer to IPv6 header
 * @type:	option type to check
 * Return: 1 if ND has that option, 0 therwise
 */
static int ndisc_has_option(struct ip6_hdr *ip6, __u8 type)
{
	struct nd_msg *ndisc = (struct nd_msg *)(((uchar *)ip6) + IP6_HDR_SIZE);

	if (ip6->payload_len <= sizeof(struct icmp6hdr))
		return 0;

	return ndisc->opt[0] == type;
}

static void ip6_send_ns(struct in6_addr *neigh_addr)
{
	struct in6_addr dst_adr;
	unsigned char enetaddr[6];
	struct nd_msg *msg;
	__u16 len;
	uchar *pkt;
	unsigned short csum;
	unsigned int pcsum;

	debug("sending neighbor solicitation for %pI6c our address %pI6c\n",
	      neigh_addr, &net_link_local_ip6);

	/* calculate src, dest IPv6 addr and dest Eth addr */
	ip6_make_snma(&dst_adr, neigh_addr);
	ip6_make_mult_ethdstaddr(enetaddr, &dst_adr);
	len = sizeof(struct icmp6hdr) + IN6ADDRSZ +
	    IP6_NDISC_OPT_SPACE(INETHADDRSZ);

	pkt = (uchar *)net_tx_packet;
	pkt += net_set_ether(pkt, enetaddr, PROT_IP6);
	pkt += ip6_add_hdr(pkt, &net_link_local_ip6, &dst_adr, PROT_ICMPV6,
			   IPV6_NDISC_HOPLIMIT, len);

	/* ICMPv6 - NS */
	msg = (struct nd_msg *)pkt;
	msg->icmph.icmp6_type = IPV6_NDISC_NEIGHBOUR_SOLICITATION;
	msg->icmph.icmp6_code = 0;
	memset(&msg->icmph.icmp6_cksum, 0, sizeof(__be16));
	memset(&msg->icmph.icmp6_unused, 0, sizeof(__be32));

	/* Set the target address and llsaddr option */
	net_copy_ip6(&msg->target, neigh_addr);
	ndisc_insert_option(msg->opt, ND_OPT_SOURCE_LL_ADDR, net_ethaddr,
			    INETHADDRSZ);

	/* checksum */
	pcsum = csum_partial((__u8 *)msg, len, 0);
	csum = csum_ipv6_magic(&net_link_local_ip6, &dst_adr,
			       len, PROT_ICMPV6, pcsum);
	msg->icmph.icmp6_cksum = csum;
	pkt += len;

	/* send it! */
	net_send_packet(net_tx_packet, (pkt - net_tx_packet));
}

/*
 * ip6_send_rs() - Send IPv6 Router Solicitation Message.
 *
 * A router solicitation is sent to discover a router. RS message creation is
 * based on RFC 4861 section 4.1. Router Solicitation Message Format.
 */
void ip6_send_rs(void)
{
	unsigned char enetaddr[6];
	struct rs_msg *msg;
	__u16 icmp_len;
	uchar *pkt;
	unsigned short csum;
	unsigned int pcsum;
	static unsigned int retry_count;

	if (!ip6_is_unspecified_addr(&net_gateway6) &&
	    net_prefix_length != 0) {
		net_set_state(NETLOOP_SUCCESS);
		return;
	} else if (retry_count >= MAX_RTR_SOLICITATIONS) {
		net_set_state(NETLOOP_FAIL);
		net_set_timeout_handler(0, NULL);
		retry_count = 0;
		return;
	}

	printf("ROUTER SOLICITATION %d\n", retry_count + 1);

	ip6_make_mult_ethdstaddr(enetaddr, &all_routers);
	/*
	 * ICMP length is the size of ICMP header (8) + one option (8) = 16.
	 * The option is 2 bytes of type and length + 6 bytes for MAC.
	 */
	icmp_len = sizeof(struct icmp6hdr) + IP6_NDISC_OPT_SPACE(INETHADDRSZ);

	pkt = (uchar *)net_tx_packet;
	pkt += net_set_ether(pkt, enetaddr, PROT_IP6);
	pkt += ip6_add_hdr(pkt, &net_link_local_ip6, &all_routers, PROT_ICMPV6,
			   IPV6_NDISC_HOPLIMIT, icmp_len);

	/* ICMPv6 - RS */
	msg = (struct rs_msg *)pkt;
	msg->icmph.icmp6_type = IPV6_NDISC_ROUTER_SOLICITATION;
	msg->icmph.icmp6_code = 0;
	memset(&msg->icmph.icmp6_cksum, 0, sizeof(__be16));
	memset(&msg->icmph.icmp6_unused, 0, sizeof(__be32));

	/* Set the llsaddr option */
	ndisc_insert_option(msg->opt, ND_OPT_SOURCE_LL_ADDR, net_ethaddr,
			    INETHADDRSZ);

	/* checksum */
	pcsum = csum_partial((__u8 *)msg, icmp_len, 0);
	csum = csum_ipv6_magic(&net_link_local_ip6, &all_routers,
			       icmp_len, PROT_ICMPV6, pcsum);
	msg->icmph.icmp6_cksum = csum;
	pkt += icmp_len;

	/* Wait up to 1 second if it is the first try to get the RA */
	if (retry_count == 0)
		udelay(((unsigned int)rand() % 1000000) * MAX_SOLICITATION_DELAY);

	/* send it! */
	net_send_packet(net_tx_packet, (pkt - net_tx_packet));

	retry_count++;
	net_set_timeout_handler(RTR_SOLICITATION_INTERVAL, ip6_send_rs);
}

static void
ip6_send_na(uchar *eth_dst_addr, struct in6_addr *neigh_addr,
	    struct in6_addr *target)
{
	struct nd_msg *msg;
	__u16 len;
	uchar *pkt;
	unsigned short csum;

	debug("sending neighbor advertisement for %pI6c to %pI6c (%pM)\n",
	      target, neigh_addr, eth_dst_addr);

	len = sizeof(struct icmp6hdr) + IN6ADDRSZ +
	    IP6_NDISC_OPT_SPACE(INETHADDRSZ);

	pkt = (uchar *)net_tx_packet;
	pkt += net_set_ether(pkt, eth_dst_addr, PROT_IP6);
	pkt += ip6_add_hdr(pkt, &net_link_local_ip6, neigh_addr,
			   PROT_ICMPV6, IPV6_NDISC_HOPLIMIT, len);

	/* ICMPv6 - NA */
	msg = (struct nd_msg *)pkt;
	msg->icmph.icmp6_type = IPV6_NDISC_NEIGHBOUR_ADVERTISEMENT;
	msg->icmph.icmp6_code = 0;
	memset(&msg->icmph.icmp6_cksum, 0, sizeof(__be16));
	memset(&msg->icmph.icmp6_unused, 0, sizeof(__be32));
	msg->icmph.icmp6_dataun.u_nd_advt.solicited = 1;
	msg->icmph.icmp6_dataun.u_nd_advt.override = 1;
	/* Set the target address and lltargetaddr option */
	net_copy_ip6(&msg->target, target);
	ndisc_insert_option(msg->opt, ND_OPT_TARGET_LL_ADDR, net_ethaddr,
			    INETHADDRSZ);

	/* checksum */
	csum = csum_ipv6_magic(&net_link_local_ip6,
			       neigh_addr, len, PROT_ICMPV6,
			       csum_partial((__u8 *)msg, len, 0));
	msg->icmph.icmp6_cksum = csum;
	pkt += len;

	/* send it! */
	net_send_packet(net_tx_packet, (pkt - net_tx_packet));
}

void ndisc_request(void)
{
	if (!ip6_addr_in_subnet(&net_ip6, &net_nd_sol_packet_ip6,
				net_prefix_length)) {
		if (ip6_is_unspecified_addr(&net_gateway6)) {
			puts("## Warning: gatewayip6 is needed but not set\n");
			net_nd_rep_packet_ip6 = net_nd_sol_packet_ip6;
		} else {
			net_nd_rep_packet_ip6 = net_gateway6;
		}
	} else {
		net_nd_rep_packet_ip6 = net_nd_sol_packet_ip6;
	}

	ip6_send_ns(&net_nd_rep_packet_ip6);
}

int ndisc_timeout_check(void)
{
	ulong t;

	if (ip6_is_unspecified_addr(&net_nd_sol_packet_ip6))
		return 0;

	t = get_timer(0);

	/* check for NDISC timeout */
	if ((t - net_nd_timer_start) > NDISC_TIMEOUT) {
		net_nd_try++;
		if (net_nd_try >= NDISC_TIMEOUT_COUNT) {
			puts("\nNeighbour discovery retry count exceeded; "
			     "starting again\n");
			net_nd_try = 0;
			net_set_state(NETLOOP_FAIL);
		} else {
			net_nd_timer_start = t;
			ndisc_request();
		}
	}
	return 1;
}

/*
 * ndisc_init() - Make initial steps for ND state machine.
 * Usually move variables into initial state.
 */
void ndisc_init(void)
{
	net_nd_packet_mac = NULL;
	net_nd_tx_packet = NULL;
	net_nd_sol_packet_ip6 = net_null_addr_ip6;
	net_nd_rep_packet_ip6 = net_null_addr_ip6;
	net_nd_tx_packet_size = 0;
	net_nd_tx_packet = &net_nd_packet_buf[0] + (PKTALIGN - 1);
	net_nd_tx_packet -= (ulong)net_nd_tx_packet % PKTALIGN;
}

/*
 * validate_ra() - Validate the router advertisement message.
 *
 * @ip6: Pointer to the router advertisement packet
 *
 * Check if the router advertisement message is valid. Conditions are
 * according to RFC 4861 section 6.1.2. Validation of Router Advertisement
 * Messages.
 *
 * Return: true if the message is valid and false if it is invalid.
 */
bool validate_ra(struct ip6_hdr *ip6)
{
	struct icmp6hdr *icmp = (struct icmp6hdr *)(ip6 + 1);

	/* ICMP length (derived from the IP length) should be 16 or more octets. */
	if (ip6->payload_len < 16)
		return false;

	/* Source IP Address should be a valid link-local address. */
	if ((ntohs(ip6->saddr.s6_addr16[0]) & IPV6_LINK_LOCAL_MASK) !=
	    IPV6_LINK_LOCAL_PREFIX)
		return false;

	/*
	 * The IP Hop Limit field should have a value of 255, i.e., the packet
	 * could not possibly have been forwarded by a router.
	 */
	if (ip6->hop_limit != 255)
		return false;

	/* ICMP checksum has already been checked in net_ip6_handler. */

	if (icmp->icmp6_code != 0)
		return false;

	return true;
}

/*
 * process_ra() - Process the router advertisement packet.
 *
 * @ip6: Pointer to the router advertisement packet
 * @len: Length of the router advertisement packet
 *
 * Process the received router advertisement message.
 * Although RFC 4861 requires retaining at least two router addresses, we only
 * keep one because of the U-Boot limitations and its goal of lightweight code.
 *
 * Return: 0 - RA is a default router and contains valid prefix information.
 * Non-zero - RA options are invalid or do not indicate it is a default router
 * or do not contain valid prefix information.
 */
int process_ra(struct ip6_hdr *ip6, int len)
{
	/* Pointer to the ICMP section of the packet */
	struct icmp6hdr *icmp = (struct icmp6hdr *)(ip6 + 1);
	struct ra_msg *msg = (struct ra_msg *)icmp;
	int remaining_option_len = len - IP6_HDR_SIZE - sizeof(struct ra_msg);
	unsigned short int option_len;	/* Length of each option */
	/* Pointer to the ICMPv6 message options */
	unsigned char *option = NULL;
	/* 8-bit identifier of the type of ICMPv6 option */
	unsigned char type = 0;
	struct icmp6_ra_prefix_info *prefix = NULL;

	/* Ignore the packet if router lifetime is 0. */
	if (!icmp->icmp6_rt_lifetime)
		return -EOPNOTSUPP;

	/* Processing the options */
	option = msg->opt;
	while (remaining_option_len > 0) {
		/* The 2nd byte of the option is its length. */
		option_len = option[1];
		/* All included options should have a positive length. */
		if (option_len == 0)
			return -EINVAL;

		type = option[0];
		/* All option types except Prefix Information are ignored. */
		switch (type) {
		case ND_OPT_SOURCE_LL_ADDR:
		case ND_OPT_TARGET_LL_ADDR:
		case ND_OPT_REDIRECT_HDR:
		case ND_OPT_MTU:
			break;
		case ND_OPT_PREFIX_INFO:
			prefix = (struct icmp6_ra_prefix_info *)option;
			/* The link-local prefix 0xfe80::/10 is ignored. */
			if ((ntohs(prefix->prefix.s6_addr16[0]) &
			     IPV6_LINK_LOCAL_MASK) == IPV6_LINK_LOCAL_PREFIX)
				break;
			if (prefix->on_link && ntohl(prefix->valid_lifetime)) {
				net_prefix_length = prefix->prefix_len;
				net_gateway6 = ip6->saddr;
				return 0;
			}
			break;
		default:
			debug("Unknown IPv6 Neighbor Discovery Option 0x%x\n",
			      type);
		}

		option_len <<= 3; /* Option length is a multiple of 8. */
		remaining_option_len -= option_len;
		option += option_len;
	}

	return -EADDRNOTAVAIL;
}

int ndisc_receive(struct ethernet_hdr *et, struct ip6_hdr *ip6, int len)
{
	struct icmp6hdr *icmp =
	    (struct icmp6hdr *)(((uchar *)ip6) + IP6_HDR_SIZE);
	struct nd_msg *ndisc = (struct nd_msg *)icmp;
	uchar neigh_eth_addr[6];
	int err = 0;	// The error code returned calling functions.

	switch (icmp->icmp6_type) {
	case IPV6_NDISC_NEIGHBOUR_SOLICITATION:
		debug("received neighbor solicitation for %pI6c from %pI6c\n",
		      &ndisc->target, &ip6->saddr);
		if (ip6_is_our_addr(&ndisc->target) &&
		    ndisc_has_option(ip6, ND_OPT_SOURCE_LL_ADDR)) {
			ndisc_extract_enetaddr(ndisc, neigh_eth_addr);
			ip6_send_na(neigh_eth_addr, &ip6->saddr,
				    &ndisc->target);
		}
		break;

	case IPV6_NDISC_NEIGHBOUR_ADVERTISEMENT:
		/* are we waiting for a reply ? */
		if (ip6_is_unspecified_addr(&net_nd_sol_packet_ip6))
			break;

		if ((memcmp(&ndisc->target, &net_nd_rep_packet_ip6,
			    sizeof(struct in6_addr)) == 0) &&
		    ndisc_has_option(ip6, ND_OPT_TARGET_LL_ADDR)) {
			ndisc_extract_enetaddr(ndisc, neigh_eth_addr);

			/* save address for later use */
			if (!net_nd_packet_mac)
				net_nd_packet_mac = neigh_eth_addr;

			/* modify header, and transmit it */
			memcpy(((struct ethernet_hdr *)net_nd_tx_packet)->et_dest,
			       neigh_eth_addr, 6);

			net_send_packet(net_nd_tx_packet,
					net_nd_tx_packet_size);

			/* no ND request pending now */
			net_nd_sol_packet_ip6 = net_null_addr_ip6;
			net_nd_tx_packet_size = 0;
			net_nd_packet_mac = NULL;
		}
		break;
	case IPV6_NDISC_ROUTER_SOLICITATION:
		break;
	case IPV6_NDISC_ROUTER_ADVERTISEMENT:
		debug("Received router advertisement for %pI6c from %pI6c\n",
		      &ip6->daddr, &ip6->saddr);
		/*
		 * If gateway and prefix are set, the RA packet is ignored. The
		 * reason is that the U-Boot code is supposed to be as compact
		 * as possible and does not need to take care of multiple
		 * routers. In addition to that, U-Boot does not want to handle
		 * scenarios like a router setting its lifetime to zero to
		 * indicate it is not routing anymore. U-Boot program has a
		 * short life when the system boots up and does not need such
		 * sophistication.
		 */
		if (!ip6_is_unspecified_addr(&net_gateway6) &&
		    net_prefix_length != 0) {
			break;
		}
		if (!validate_ra(ip6)) {
			debug("Invalid router advertisement message.\n");
			break;
		}
		err = process_ra(ip6, len);
		if (err)
			debug("Ignored router advertisement. Error: %d\n", err);
		else
			printf("Set gatewayip6: %pI6c, prefix_length: %d\n",
			       &net_gateway6, net_prefix_length);
		break;
	default:
		debug("Unexpected ICMPv6 type 0x%x\n", icmp->icmp6_type);
		return -1;
	}

	return 0;
}
Commit	Line	Data
c6610e1d VM	1	// SPDX-License-Identifier: GPL-2.0+
	2	/*
	3	* Copyright (C) 2013 Allied Telesis Labs NZ
	4	* Chris Packham, <judge.packham@gmail.com>
	5	*
	6	* Copyright (C) 2022 YADRO
	7	* Viacheslav Mitrofanov <v.v.mitrofanov@yadro.com>
	8	*/
	9
	10	/* Neighbour Discovery for IPv6 */
	11
	12	#include <common.h>
	13	#include <net.h>
	14	#include <net6.h>
	15	#include <ndisc.h>
6de98b60 EM	16	#include <stdlib.h>
6de98b60 EM	17	#include <linux/delay.h>
c6610e1d VM	18
	19	/* IPv6 destination address of packet waiting for ND */
	20	struct in6_addr net_nd_sol_packet_ip6 = ZERO_IPV6_ADDR;
	21	/* IPv6 address we are expecting ND advert from */
	22	static struct in6_addr net_nd_rep_packet_ip6 = ZERO_IPV6_ADDR;
	23	/* MAC destination address of packet waiting for ND */
	24	uchar *net_nd_packet_mac;
	25	/* pointer to packet waiting to be transmitted after ND is resolved */
	26	uchar *net_nd_tx_packet;
	27	static uchar net_nd_packet_buf[PKTSIZE_ALIGN + PKTALIGN];
	28	/* size of packet waiting to be transmitted */
	29	int net_nd_tx_packet_size;
	30	/* the timer for ND resolution */
	31	ulong net_nd_timer_start;
	32	/* the number of requests we have sent so far */
	33	int net_nd_try;
6de98b60 EM	34	struct in6_addr all_routers = ALL_ROUTERS_MULT_ADDR;
	35
	36	#define MAX_RTR_SOLICITATIONS 3
	37	/* The maximum time to delay sending the first router solicitation message. */
	38	#define MAX_SOLICITATION_DELAY 1 // 1 second
	39	/* The time to wait before sending the next router solicitation message. */
	40	#define RTR_SOLICITATION_INTERVAL 4000 // 4 seconds
c6610e1d VM	41
	42	#define IP6_NDISC_OPT_SPACE(len) (((len) + 2 + 7) & ~7)
	43
	44	/**
	45	* ndisc_insert_option() - Insert an option into a neighbor discovery packet
	46	*
6de98b60	47	* @opt: pointer to the option element of the neighbor discovery packet
c6610e1d VM	48	* @type: option type to insert
	49	* @data: option data to insert
	50	* @len: data length
	51	* Return: the number of bytes inserted (which may be >= len)
	52	*/
6de98b60	53	static int ndisc_insert_option(__u8 opt, int type, u8 data, int len)
c6610e1d VM	54	{
	55	int space = IP6_NDISC_OPT_SPACE(len);
	56
6de98b60 EM	57	opt[0] = type;
	58	opt[1] = space >> 3;
	59	memcpy(&opt[2], data, len);
c6610e1d VM	60	len += 2;
	61
	62	/* fill the remainder with 0 */
	63	if (space - len > 0)
6de98b60	64	memset(&opt[len], '\0', space - len);
c6610e1d VM	65
	66	return space;
	67	}
	68
	69	/**
	70	* ndisc_extract_enetaddr() - Extract the Ethernet address from a ND packet
	71	*
	72	* Note that the link layer address could be anything but the only networking
	73	* media that u-boot supports is Ethernet so we assume we're extracting a 6
	74	* byte Ethernet MAC address.
	75	*
	76	* @ndisc: pointer to ND packet
	77	* @enetaddr: extracted MAC addr
	78	*/
	79	static void ndisc_extract_enetaddr(struct nd_msg *ndisc, uchar enetaddr[6])
	80	{
	81	memcpy(enetaddr, &ndisc->opt[2], 6);
	82	}
	83
	84	/**
	85	* ndisc_has_option() - Check if the ND packet has the specified option set
	86	*
	87	* @ip6: pointer to IPv6 header
	88	* @type: option type to check
	89	* Return: 1 if ND has that option, 0 therwise
	90	*/
	91	static int ndisc_has_option(struct ip6_hdr *ip6, __u8 type)
	92	{
	93	struct nd_msg ndisc = (struct nd_msg )(((uchar *)ip6) + IP6_HDR_SIZE);
	94
	95	if (ip6->payload_len <= sizeof(struct icmp6hdr))
	96	return 0;
	97
	98	return ndisc->opt[0] == type;
	99	}
	100
	101	static void ip6_send_ns(struct in6_addr *neigh_addr)
	102	{
	103	struct in6_addr dst_adr;
	104	unsigned char enetaddr[6];
	105	struct nd_msg *msg;
	106	__u16 len;
	107	uchar *pkt;
	108	unsigned short csum;
	109	unsigned int pcsum;
	110
	111	debug("sending neighbor solicitation for %pI6c our address %pI6c\n",
	112	neigh_addr, &net_link_local_ip6);
	113
	114	/* calculate src, dest IPv6 addr and dest Eth addr */
	115	ip6_make_snma(&dst_adr, neigh_addr);
	116	ip6_make_mult_ethdstaddr(enetaddr, &dst_adr);
	117	len = sizeof(struct icmp6hdr) + IN6ADDRSZ +
	118	IP6_NDISC_OPT_SPACE(INETHADDRSZ);
	119
	120	pkt = (uchar *)net_tx_packet;
	121	pkt += net_set_ether(pkt, enetaddr, PROT_IP6);
	122	pkt += ip6_add_hdr(pkt, &net_link_local_ip6, &dst_adr, PROT_ICMPV6,
	123	IPV6_NDISC_HOPLIMIT, len);
	124
	125	/* ICMPv6 - NS */
	126	msg = (struct nd_msg *)pkt;
	127	msg->icmph.icmp6_type = IPV6_NDISC_NEIGHBOUR_SOLICITATION;
	128	msg->icmph.icmp6_code = 0;
129	memset(&msg->icmph.icmp6_cksum, 0, sizeof(__be16));
130	memset(&msg->icmph.icmp6_unused, 0, sizeof(__be32));
131
132	/* Set the target address and llsaddr option */
133	net_copy_ip6(&msg->target, neigh_addr);
6de98b60	134	ndisc_insert_option(msg->opt, ND_OPT_SOURCE_LL_ADDR, net_ethaddr,
c6610e1d VM	135	INETHADDRSZ);
	136
	137	/* checksum */
	138	pcsum = csum_partial((__u8 *)msg, len, 0);
	139	csum = csum_ipv6_magic(&net_link_local_ip6, &dst_adr,
	140	len, PROT_ICMPV6, pcsum);
	141	msg->icmph.icmp6_cksum = csum;
	142	pkt += len;
	143
	144	/* send it! */
	145	net_send_packet(net_tx_packet, (pkt - net_tx_packet));
	146	}
	147
6de98b60 EM	148	/*
	149	* ip6_send_rs() - Send IPv6 Router Solicitation Message.
	150	*
	151	* A router solicitation is sent to discover a router. RS message creation is
	152	* based on RFC 4861 section 4.1. Router Solicitation Message Format.
	153	*/
	154	void ip6_send_rs(void)
	155	{
	156	unsigned char enetaddr[6];
	157	struct rs_msg *msg;
	158	__u16 icmp_len;
	159	uchar *pkt;
	160	unsigned short csum;
	161	unsigned int pcsum;
	162	static unsigned int retry_count;
	163
	164	if (!ip6_is_unspecified_addr(&net_gateway6) &&
	165	net_prefix_length != 0) {
	166	net_set_state(NETLOOP_SUCCESS);
	167	return;
	168	} else if (retry_count >= MAX_RTR_SOLICITATIONS) {
	169	net_set_state(NETLOOP_FAIL);
	170	net_set_timeout_handler(0, NULL);
	171	retry_count = 0;
	172	return;
	173	}
	174
	175	printf("ROUTER SOLICITATION %d\n", retry_count + 1);
	176
	177	ip6_make_mult_ethdstaddr(enetaddr, &all_routers);
	178	/*
	179	* ICMP length is the size of ICMP header (8) + one option (8) = 16.
	180	* The option is 2 bytes of type and length + 6 bytes for MAC.
	181	*/
	182	icmp_len = sizeof(struct icmp6hdr) + IP6_NDISC_OPT_SPACE(INETHADDRSZ);
	183
	184	pkt = (uchar *)net_tx_packet;
	185	pkt += net_set_ether(pkt, enetaddr, PROT_IP6);
	186	pkt += ip6_add_hdr(pkt, &net_link_local_ip6, &all_routers, PROT_ICMPV6,
	187	IPV6_NDISC_HOPLIMIT, icmp_len);
	188
	189	/* ICMPv6 - RS */
	190	msg = (struct rs_msg *)pkt;
	191	msg->icmph.icmp6_type = IPV6_NDISC_ROUTER_SOLICITATION;
	192	msg->icmph.icmp6_code = 0;
	193	memset(&msg->icmph.icmp6_cksum, 0, sizeof(__be16));
	194	memset(&msg->icmph.icmp6_unused, 0, sizeof(__be32));
	195
	196	/* Set the llsaddr option */
	197	ndisc_insert_option(msg->opt, ND_OPT_SOURCE_LL_ADDR, net_ethaddr,
	198	INETHADDRSZ);
	199
	200	/* checksum */
	201	pcsum = csum_partial((__u8 *)msg, icmp_len, 0);
	202	csum = csum_ipv6_magic(&net_link_local_ip6, &all_routers,
	203	icmp_len, PROT_ICMPV6, pcsum);
	204	msg->icmph.icmp6_cksum = csum;
	205	pkt += icmp_len;
	206
	207	/* Wait up to 1 second if it is the first try to get the RA */
	208	if (retry_count == 0)
	209	udelay(((unsigned int)rand() % 1000000) * MAX_SOLICITATION_DELAY);
	210
	211	/* send it! */
212	net_send_packet(net_tx_packet, (pkt - net_tx_packet));
213
214	retry_count++;
215	net_set_timeout_handler(RTR_SOLICITATION_INTERVAL, ip6_send_rs);
216	}
217
c6610e1d VM	218	static void
	219	ip6_send_na(uchar eth_dst_addr, struct in6_addr neigh_addr,
	220	struct in6_addr *target)
	221	{
	222	struct nd_msg *msg;
	223	__u16 len;
	224	uchar *pkt;
	225	unsigned short csum;
	226
	227	debug("sending neighbor advertisement for %pI6c to %pI6c (%pM)\n",
	228	target, neigh_addr, eth_dst_addr);
	229
	230	len = sizeof(struct icmp6hdr) + IN6ADDRSZ +
	231	IP6_NDISC_OPT_SPACE(INETHADDRSZ);
	232
	233	pkt = (uchar *)net_tx_packet;
	234	pkt += net_set_ether(pkt, eth_dst_addr, PROT_IP6);
	235	pkt += ip6_add_hdr(pkt, &net_link_local_ip6, neigh_addr,
	236	PROT_ICMPV6, IPV6_NDISC_HOPLIMIT, len);
	237
	238	/* ICMPv6 - NA */
	239	msg = (struct nd_msg *)pkt;
	240	msg->icmph.icmp6_type = IPV6_NDISC_NEIGHBOUR_ADVERTISEMENT;
	241	msg->icmph.icmp6_code = 0;
	242	memset(&msg->icmph.icmp6_cksum, 0, sizeof(__be16));
	243	memset(&msg->icmph.icmp6_unused, 0, sizeof(__be32));
	244	msg->icmph.icmp6_dataun.u_nd_advt.solicited = 1;
	245	msg->icmph.icmp6_dataun.u_nd_advt.override = 1;
	246	/* Set the target address and lltargetaddr option */
	247	net_copy_ip6(&msg->target, target);
6de98b60	248	ndisc_insert_option(msg->opt, ND_OPT_TARGET_LL_ADDR, net_ethaddr,
c6610e1d VM	249	INETHADDRSZ);
	250
	251	/* checksum */
	252	csum = csum_ipv6_magic(&net_link_local_ip6,
	253	neigh_addr, len, PROT_ICMPV6,
	254	csum_partial((__u8 *)msg, len, 0));
	255	msg->icmph.icmp6_cksum = csum;
	256	pkt += len;
	257
	258	/* send it! */
	259	net_send_packet(net_tx_packet, (pkt - net_tx_packet));
	260	}
	261
	262	void ndisc_request(void)
	263	{
	264	if (!ip6_addr_in_subnet(&net_ip6, &net_nd_sol_packet_ip6,
	265	net_prefix_length)) {
	266	if (ip6_is_unspecified_addr(&net_gateway6)) {
	267	puts("## Warning: gatewayip6 is needed but not set\n");
	268	net_nd_rep_packet_ip6 = net_nd_sol_packet_ip6;
	269	} else {
	270	net_nd_rep_packet_ip6 = net_gateway6;
	271	}
	272	} else {
	273	net_nd_rep_packet_ip6 = net_nd_sol_packet_ip6;
	274	}
	275
	276	ip6_send_ns(&net_nd_rep_packet_ip6);
	277	}
	278
	279	int ndisc_timeout_check(void)
	280	{
	281	ulong t;
	282
	283	if (ip6_is_unspecified_addr(&net_nd_sol_packet_ip6))
	284	return 0;
	285
	286	t = get_timer(0);
	287
	288	/* check for NDISC timeout */
	289	if ((t - net_nd_timer_start) > NDISC_TIMEOUT) {
	290	net_nd_try++;
	291	if (net_nd_try >= NDISC_TIMEOUT_COUNT) {
	292	puts("\nNeighbour discovery retry count exceeded; "
	293	"starting again\n");
	294	net_nd_try = 0;
	295	net_set_state(NETLOOP_FAIL);
	296	} else {
	297	net_nd_timer_start = t;
	298	ndisc_request();
	299	}
	300	}
	301	return 1;
	302	}
	303
6de98b60 EM	304	/*
	305	* ndisc_init() - Make initial steps for ND state machine.
	306	* Usually move variables into initial state.
	307	*/
c6610e1d VM	308	void ndisc_init(void)
	309	{
	310	net_nd_packet_mac = NULL;
	311	net_nd_tx_packet = NULL;
	312	net_nd_sol_packet_ip6 = net_null_addr_ip6;
	313	net_nd_rep_packet_ip6 = net_null_addr_ip6;
	314	net_nd_tx_packet_size = 0;
	315	net_nd_tx_packet = &net_nd_packet_buf[0] + (PKTALIGN - 1);
	316	net_nd_tx_packet -= (ulong)net_nd_tx_packet % PKTALIGN;
	317	}
	318
6de98b60 EM	319	/*
	320	* validate_ra() - Validate the router advertisement message.
	321	*
	322	* @ip6: Pointer to the router advertisement packet
	323	*
	324	* Check if the router advertisement message is valid. Conditions are
	325	* according to RFC 4861 section 6.1.2. Validation of Router Advertisement
	326	* Messages.
	327	*
	328	* Return: true if the message is valid and false if it is invalid.
	329	*/
	330	bool validate_ra(struct ip6_hdr *ip6)
	331	{
	332	struct icmp6hdr icmp = (struct icmp6hdr )(ip6 + 1);
	333
	334	/* ICMP length (derived from the IP length) should be 16 or more octets. */
	335	if (ip6->payload_len < 16)
	336	return false;
	337
	338	/* Source IP Address should be a valid link-local address. */
	339	if ((ntohs(ip6->saddr.s6_addr16[0]) & IPV6_LINK_LOCAL_MASK) !=
	340	IPV6_LINK_LOCAL_PREFIX)
	341	return false;
	342
	343	/*
	344	* The IP Hop Limit field should have a value of 255, i.e., the packet
	345	* could not possibly have been forwarded by a router.
	346	*/
	347	if (ip6->hop_limit != 255)
	348	return false;
	349
	350	/* ICMP checksum has already been checked in net_ip6_handler. */
	351
	352	if (icmp->icmp6_code != 0)
	353	return false;
	354
	355	return true;
	356	}
	357
	358	/*
	359	* process_ra() - Process the router advertisement packet.
	360	*
	361	* @ip6: Pointer to the router advertisement packet
	362	* @len: Length of the router advertisement packet
	363	*
	364	* Process the received router advertisement message.
	365	* Although RFC 4861 requires retaining at least two router addresses, we only
	366	* keep one because of the U-Boot limitations and its goal of lightweight code.
	367	*
	368	* Return: 0 - RA is a default router and contains valid prefix information.
	369	* Non-zero - RA options are invalid or do not indicate it is a default router
	370	* or do not contain valid prefix information.
	371	*/
	372	int process_ra(struct ip6_hdr *ip6, int len)
	373	{
	374	/* Pointer to the ICMP section of the packet */
	375	struct icmp6hdr icmp = (struct icmp6hdr )(ip6 + 1);
	376	struct ra_msg msg = (struct ra_msg )icmp;
	377	int remaining_option_len = len - IP6_HDR_SIZE - sizeof(struct ra_msg);
	378	unsigned short int option_len; /* Length of each option */
	379	/* Pointer to the ICMPv6 message options */
	380	unsigned char *option = NULL;
	381	/* 8-bit identifier of the type of ICMPv6 option */
	382	unsigned char type = 0;
383	struct icmp6_ra_prefix_info *prefix = NULL;
384
385	/* Ignore the packet if router lifetime is 0. */
386	if (!icmp->icmp6_rt_lifetime)
387	return -EOPNOTSUPP;
388
389	/* Processing the options */
390	option = msg->opt;
391	while (remaining_option_len > 0) {
392	/* The 2nd byte of the option is its length. */
393	option_len = option[1];
394	/* All included options should have a positive length. */
395	if (option_len == 0)
396	return -EINVAL;
397
398	type = option[0];
399	/* All option types except Prefix Information are ignored. */
400	switch (type) {
401	case ND_OPT_SOURCE_LL_ADDR:
402	case ND_OPT_TARGET_LL_ADDR:
403	case ND_OPT_REDIRECT_HDR:
404	case ND_OPT_MTU:
405	break;
406	case ND_OPT_PREFIX_INFO:
407	prefix = (struct icmp6_ra_prefix_info *)option;
408	/* The link-local prefix 0xfe80::/10 is ignored. */
409	if ((ntohs(prefix->prefix.s6_addr16[0]) &
410	IPV6_LINK_LOCAL_MASK) == IPV6_LINK_LOCAL_PREFIX)
411	break;
412	if (prefix->on_link && ntohl(prefix->valid_lifetime)) {
413	net_prefix_length = prefix->prefix_len;
414	net_gateway6 = ip6->saddr;
415	return 0;
416	}
417	break;
418	default:
419	debug("Unknown IPv6 Neighbor Discovery Option 0x%x\n",
420	type);
421	}
422
423	option_len <<= 3; /* Option length is a multiple of 8. */
424	remaining_option_len -= option_len;
425	option += option_len;
426	}
427
428	return -EADDRNOTAVAIL;
429	}
430
c6610e1d VM	431	int ndisc_receive(struct ethernet_hdr et, struct ip6_hdr ip6, int len)
	432	{
	433	struct icmp6hdr *icmp =
	434	(struct icmp6hdr )(((uchar )ip6) + IP6_HDR_SIZE);
	435	struct nd_msg ndisc = (struct nd_msg )icmp;
	436	uchar neigh_eth_addr[6];
6de98b60	437	int err = 0; // The error code returned calling functions.
c6610e1d VM	438
	439	switch (icmp->icmp6_type) {
	440	case IPV6_NDISC_NEIGHBOUR_SOLICITATION:
	441	debug("received neighbor solicitation for %pI6c from %pI6c\n",
	442	&ndisc->target, &ip6->saddr);
	443	if (ip6_is_our_addr(&ndisc->target) &&
	444	ndisc_has_option(ip6, ND_OPT_SOURCE_LL_ADDR)) {
	445	ndisc_extract_enetaddr(ndisc, neigh_eth_addr);
	446	ip6_send_na(neigh_eth_addr, &ip6->saddr,
	447	&ndisc->target);
	448	}
	449	break;
	450
	451	case IPV6_NDISC_NEIGHBOUR_ADVERTISEMENT:
	452	/* are we waiting for a reply ? */
	453	if (ip6_is_unspecified_addr(&net_nd_sol_packet_ip6))
	454	break;
	455
	456	if ((memcmp(&ndisc->target, &net_nd_rep_packet_ip6,
	457	sizeof(struct in6_addr)) == 0) &&
	458	ndisc_has_option(ip6, ND_OPT_TARGET_LL_ADDR)) {
	459	ndisc_extract_enetaddr(ndisc, neigh_eth_addr);
	460
	461	/* save address for later use */
	462	if (!net_nd_packet_mac)
56e3b147	463	net_nd_packet_mac = neigh_eth_addr;
c6610e1d VM	464
	465	/* modify header, and transmit it */
	466	memcpy(((struct ethernet_hdr *)net_nd_tx_packet)->et_dest,
	467	neigh_eth_addr, 6);
	468
	469	net_send_packet(net_nd_tx_packet,
	470	net_nd_tx_packet_size);
	471
	472	/* no ND request pending now */
	473	net_nd_sol_packet_ip6 = net_null_addr_ip6;
	474	net_nd_tx_packet_size = 0;
	475	net_nd_packet_mac = NULL;
	476	}
	477	break;
6de98b60 EM	478	case IPV6_NDISC_ROUTER_SOLICITATION:
	479	break;
	480	case IPV6_NDISC_ROUTER_ADVERTISEMENT:
	481	debug("Received router advertisement for %pI6c from %pI6c\n",
	482	&ip6->daddr, &ip6->saddr);
	483	/*
	484	* If gateway and prefix are set, the RA packet is ignored. The
	485	* reason is that the U-Boot code is supposed to be as compact
	486	* as possible and does not need to take care of multiple
	487	* routers. In addition to that, U-Boot does not want to handle
	488	* scenarios like a router setting its lifetime to zero to
	489	* indicate it is not routing anymore. U-Boot program has a
	490	* short life when the system boots up and does not need such
	491	* sophistication.
	492	*/
	493	if (!ip6_is_unspecified_addr(&net_gateway6) &&
	494	net_prefix_length != 0) {
	495	break;
	496	}
	497	if (!validate_ra(ip6)) {
	498	debug("Invalid router advertisement message.\n");
	499	break;
	500	}
	501	err = process_ra(ip6, len);
	502	if (err)
	503	debug("Ignored router advertisement. Error: %d\n", err);
	504	else
	505	printf("Set gatewayip6: %pI6c, prefix_length: %d\n",
	506	&net_gateway6, net_prefix_length);
	507	break;
c6610e1d VM	508	default:
	509	debug("Unexpected ICMPv6 type 0x%x\n", icmp->icmp6_type);
	510	return -1;
	511	}
	512
	513	return 0;
	514	}