net/link_local.c - platform/external/u-boot - Gitiles

 /*
  * RFC3927 ZeroConf IPv4 Link-Local addressing
  * (see <http://www.zeroconf.org/>)
  *
  * Copied from BusyBox - networking/zcip.c
  *
  * Copyright (C) 2003 by Arthur van Hoff (avh@strangeberry.com)
  * Copyright (C) 2004 by David Brownell
  * Copyright (C) 2010 by Joe Hershberger
  *
  * Licensed under the GPL v2 or later
  */

 #include <common.h>
 #include <env.h>
 #include <log.h>
 #include <net.h>
 #include <rand.h>
 #include "arp.h"
 #include "net_rand.h"

 /* We don't need more than 32 bits of the counter */
 #define MONOTONIC_MS() ((unsigned)get_timer(0) * (1000 / CONFIG_SYS_HZ))

 enum {
 /* 169.254.0.0 */
 	LINKLOCAL_ADDR = 0xa9fe0000,

 	IN_CLASSB_NET = 0xffff0000,
 	IN_CLASSB_HOST = 0x0000ffff,

 /* protocol timeout parameters, specified in seconds */
 	PROBE_WAIT = 1,
 	PROBE_MIN = 1,
 	PROBE_MAX = 2,
 	PROBE_NUM = 3,
 	MAX_CONFLICTS = 10,
 	RATE_LIMIT_INTERVAL = 60,
 	ANNOUNCE_WAIT = 2,
 	ANNOUNCE_NUM = 2,
 	ANNOUNCE_INTERVAL = 2,
 	DEFEND_INTERVAL = 10
 };

 /* States during the configuration process. */
 static enum ll_state_t {
 	PROBE = 0,
 	RATE_LIMIT_PROBE,
 	ANNOUNCE,
 	MONITOR,
 	DEFEND,
 	DISABLED
 } state = DISABLED;

 static struct in_addr ip;
 static int timeout_ms = -1;
 static unsigned deadline_ms;
 static unsigned conflicts;
 static unsigned nprobes;
 static unsigned nclaims;
 static int ready;
 static unsigned int seed;

 static void link_local_timeout(void);

 /**
  * Pick a random link local IP address on 169.254/16, except that
  * the first and last 256 addresses are reserved.
  */
 static struct in_addr pick(void)
 {
 	unsigned tmp;
 	struct in_addr ip;

 	do {
 		tmp = rand_r(&seed) & IN_CLASSB_HOST;
 	} while (tmp > (IN_CLASSB_HOST - 0x0200));
 	ip.s_addr = htonl((LINKLOCAL_ADDR + 0x0100) + tmp);
 	return ip;
 }

 /**
  * Return milliseconds of random delay, up to "secs" seconds.
  */
 static inline unsigned random_delay_ms(unsigned secs)
 {
 	return rand_r(&seed) % (secs * 1000);
 }

 static void configure_wait(void)
 {
 	if (timeout_ms == -1)
 		return;

 	/* poll, being ready to adjust current timeout */
 	if (!timeout_ms)
 		timeout_ms = random_delay_ms(PROBE_WAIT);

 	/* set deadline_ms to the point in time when we timeout */
 	deadline_ms = MONOTONIC_MS() + timeout_ms;

 	debug_cond(DEBUG_DEV_PKT, "...wait %d %s nprobes=%u, nclaims=%u\n",
 		   timeout_ms, eth_get_name(), nprobes, nclaims);

 	net_set_timeout_handler(timeout_ms, link_local_timeout);
 }

 void link_local_start(void)
 {
 	ip = env_get_ip("llipaddr");
 	if (ip.s_addr != 0 &&
 	    (ntohl(ip.s_addr) & IN_CLASSB_NET) != LINKLOCAL_ADDR) {
 		puts("invalid link address");
 		net_set_state(NETLOOP_FAIL);
 		return;
 	}
 	net_netmask.s_addr = htonl(IN_CLASSB_NET);

 	seed = seed_mac();
 	if (ip.s_addr == 0)
 		ip = pick();

 	state = PROBE;
 	timeout_ms = 0;
 	conflicts = 0;
 	nprobes = 0;
 	nclaims = 0;
 	ready = 0;

 	configure_wait();
 }

 static void link_local_timeout(void)
 {
 	switch (state) {
 	case PROBE:
 		/* timeouts in the PROBE state mean no conflicting ARP packets
 		   have been received, so we can progress through the states */
 		if (nprobes < PROBE_NUM) {
 			struct in_addr zero_ip = {.s_addr = 0};

 			nprobes++;
 			debug_cond(DEBUG_LL_STATE, "probe/%u %s@%pI4\n",
 				   nprobes, eth_get_name(), &ip);
 			arp_raw_request(zero_ip, net_null_ethaddr, ip);
 			timeout_ms = PROBE_MIN * 1000;
 			timeout_ms += random_delay_ms(PROBE_MAX - PROBE_MIN);
 		} else {
 			/* Switch to announce state */
 			state = ANNOUNCE;
 			nclaims = 0;
 			debug_cond(DEBUG_LL_STATE, "announce/%u %s@%pI4\n",
 				   nclaims, eth_get_name(), &ip);
 			arp_raw_request(ip, net_ethaddr, ip);
 			timeout_ms = ANNOUNCE_INTERVAL * 1000;
 		}
 		break;
 	case RATE_LIMIT_PROBE:
 		/* timeouts in the RATE_LIMIT_PROBE state mean no conflicting
 		   ARP packets have been received, so we can move immediately
 		   to the announce state */
 		state = ANNOUNCE;
 		nclaims = 0;
 		debug_cond(DEBUG_LL_STATE, "announce/%u %s@%pI4\n",
 			   nclaims, eth_get_name(), &ip);
 		arp_raw_request(ip, net_ethaddr, ip);
 		timeout_ms = ANNOUNCE_INTERVAL * 1000;
 		break;
 	case ANNOUNCE:
 		/* timeouts in the ANNOUNCE state mean no conflicting ARP
 		   packets have been received, so we can progress through
 		   the states */
 		if (nclaims < ANNOUNCE_NUM) {
 			nclaims++;
 			debug_cond(DEBUG_LL_STATE, "announce/%u %s@%pI4\n",
 				   nclaims, eth_get_name(), &ip);
 			arp_raw_request(ip, net_ethaddr, ip);
 			timeout_ms = ANNOUNCE_INTERVAL * 1000;
 		} else {
 			/* Switch to monitor state */
 			state = MONITOR;
 			printf("Successfully assigned %pI4\n", &ip);
 			net_copy_ip(&net_ip, &ip);
 			ready = 1;
 			conflicts = 0;
 			timeout_ms = -1;
 			/* Never timeout in the monitor state */
 			net_set_timeout_handler(0, NULL);

 			/* NOTE: all other exit paths should deconfig ... */
 			net_set_state(NETLOOP_SUCCESS);
 			return;
 		}
 		break;
 	case DEFEND:
 		/* We won!  No ARP replies, so just go back to monitor */
 		state = MONITOR;
 		timeout_ms = -1;
 		conflicts = 0;
 		break;
 	default:
 		/* Invalid, should never happen.  Restart the whole protocol */
 		state = PROBE;
 		ip = pick();
 		timeout_ms = 0;
 		nprobes = 0;
 		nclaims = 0;
 		break;
 	}
 	configure_wait();
 }

 void link_local_receive_arp(struct arp_hdr *arp, int len)
 {
 	int source_ip_conflict;
 	int target_ip_conflict;
 	struct in_addr null_ip = {.s_addr = 0};

 	if (state == DISABLED)
 		return;

 	/* We need to adjust the timeout in case we didn't receive a
 	   conflicting packet. */
 	if (timeout_ms > 0) {
 		unsigned diff = deadline_ms - MONOTONIC_MS();
 		if ((int)(diff) < 0) {
 			/* Current time is greater than the expected timeout
 			   time. This should never happen */
 			debug_cond(DEBUG_LL_STATE,
 				   "missed an expected timeout\n");
 			timeout_ms = 0;
 		} else {
 			debug_cond(DEBUG_INT_STATE, "adjusting timeout\n");
 			timeout_ms = diff | 1; /* never 0 */
 		}
 	}
 #if 0
  /* XXX Don't bother with ethernet link just yet */
 	if ((fds[0].revents & POLLIN) == 0) {
 		if (fds[0].revents & POLLERR) {
 			/*
 			 * FIXME: links routinely go down;
 			 */
 			bb_error_msg("iface %s is down", eth_get_name());
 			if (ready)
 				run(argv, "deconfig", &ip);
 			return EXIT_FAILURE;
 		}
 		continue;
 	}
 #endif

 	debug_cond(DEBUG_INT_STATE, "%s recv arp type=%d, op=%d,\n",
 		   eth_get_name(), ntohs(arp->ar_pro),
 		   ntohs(arp->ar_op));
 	debug_cond(DEBUG_INT_STATE, "\tsource=%pM %pI4\n",
 		   &arp->ar_sha,
 		   &arp->ar_spa);
 	debug_cond(DEBUG_INT_STATE, "\ttarget=%pM %pI4\n",
 		   &arp->ar_tha,
 		   &arp->ar_tpa);

 	if (arp->ar_op != htons(ARPOP_REQUEST) &&
 	    arp->ar_op != htons(ARPOP_REPLY)) {
 		configure_wait();
 		return;
 	}

 	source_ip_conflict = 0;
 	target_ip_conflict = 0;

 	if (memcmp(&arp->ar_spa, &ip, ARP_PLEN) == 0 &&
 	    memcmp(&arp->ar_sha, net_ethaddr, ARP_HLEN) != 0)
 		source_ip_conflict = 1;

 	/*
 	 * According to RFC 3927, section 2.2.1:
 	 * Check if packet is an ARP probe by checking for a null source IP
 	 * then check that target IP is equal to ours and source hw addr
 	 * is not equal to ours. This condition should cause a conflict only
 	 * during probe.
 	 */
 	if (arp->ar_op == htons(ARPOP_REQUEST) &&
 	    memcmp(&arp->ar_spa, &null_ip, ARP_PLEN) == 0 &&
 	    memcmp(&arp->ar_tpa, &ip, ARP_PLEN) == 0 &&
 	    memcmp(&arp->ar_sha, net_ethaddr, ARP_HLEN) != 0) {
 		target_ip_conflict = 1;
 	}

 	debug_cond(DEBUG_NET_PKT,
 		   "state = %d, source ip conflict = %d, target ip conflict = "
 		   "%d\n", state, source_ip_conflict, target_ip_conflict);
 	switch (state) {
 	case PROBE:
 	case ANNOUNCE:
 		/* When probing or announcing, check for source IP conflicts
 		   and other hosts doing ARP probes (target IP conflicts). */
 		if (source_ip_conflict || target_ip_conflict) {
 			conflicts++;
 			state = PROBE;
 			if (conflicts >= MAX_CONFLICTS) {
 				debug("%s ratelimit\n", eth_get_name());
 				timeout_ms = RATE_LIMIT_INTERVAL * 1000;
 				state = RATE_LIMIT_PROBE;
 			}

 			/* restart the whole protocol */
 			ip = pick();
 			timeout_ms = 0;
 			nprobes = 0;
 			nclaims = 0;
 		}
 		break;
 	case MONITOR:
 		/* If a conflict, we try to defend with a single ARP probe */
 		if (source_ip_conflict) {
 			debug("monitor conflict -- defending\n");
 			state = DEFEND;
 			timeout_ms = DEFEND_INTERVAL * 1000;
 			arp_raw_request(ip, net_ethaddr, ip);
 		}
 		break;
 	case DEFEND:
 		/* Well, we tried.  Start over (on conflict) */
 		if (source_ip_conflict) {
 			state = PROBE;
 			debug("defend conflict -- starting over\n");
 			ready = 0;
 			net_ip.s_addr = 0;

 			/* restart the whole protocol */
 			ip = pick();
 			timeout_ms = 0;
 			nprobes = 0;
 			nclaims = 0;
 		}
 		break;
 	default:
 		/* Invalid, should never happen.  Restart the whole protocol */
 		debug("invalid state -- starting over\n");
 		state = PROBE;
 		ip = pick();
 		timeout_ms = 0;
 		nprobes = 0;
 		nclaims = 0;
 		break;
 	}
 	configure_wait();
 }
	/*
	* RFC3927 ZeroConf IPv4 Link-Local addressing
	* (see <http://www.zeroconf.org/>)
	*
	* Copied from BusyBox - networking/zcip.c
	*
	* Copyright (C) 2003 by Arthur van Hoff (avh@strangeberry.com)
	* Copyright (C) 2004 by David Brownell
	* Copyright (C) 2010 by Joe Hershberger
	*
	* Licensed under the GPL v2 or later
	*/

	#include <common.h>
	#include <env.h>
	#include <log.h>
	#include <net.h>
	#include <rand.h>
	#include "arp.h"
	#include "net_rand.h"

	/* We don't need more than 32 bits of the counter */
	#define MONOTONIC_MS() ((unsigned)get_timer(0) * (1000 / CONFIG_SYS_HZ))

	enum {
	/* 169.254.0.0 */
	LINKLOCAL_ADDR = 0xa9fe0000,

	IN_CLASSB_NET = 0xffff0000,
	IN_CLASSB_HOST = 0x0000ffff,

	/* protocol timeout parameters, specified in seconds */
	PROBE_WAIT = 1,
	PROBE_MIN = 1,
	PROBE_MAX = 2,
	PROBE_NUM = 3,
	MAX_CONFLICTS = 10,
	RATE_LIMIT_INTERVAL = 60,
	ANNOUNCE_WAIT = 2,
	ANNOUNCE_NUM = 2,
	ANNOUNCE_INTERVAL = 2,
	DEFEND_INTERVAL = 10
	};

	/* States during the configuration process. */
	static enum ll_state_t {
	PROBE = 0,
	RATE_LIMIT_PROBE,
	ANNOUNCE,
	MONITOR,
	DEFEND,
	DISABLED
	} state = DISABLED;

	static struct in_addr ip;
	static int timeout_ms = -1;
	static unsigned deadline_ms;
	static unsigned conflicts;
	static unsigned nprobes;
	static unsigned nclaims;
	static int ready;
	static unsigned int seed;

	static void link_local_timeout(void);

	/**
	* Pick a random link local IP address on 169.254/16, except that
	* the first and last 256 addresses are reserved.
	*/
	static struct in_addr pick(void)
	{
	unsigned tmp;
	struct in_addr ip;

	do {
	tmp = rand_r(&seed) & IN_CLASSB_HOST;
	} while (tmp > (IN_CLASSB_HOST - 0x0200));
	ip.s_addr = htonl((LINKLOCAL_ADDR + 0x0100) + tmp);
	return ip;
	}

	/**
	* Return milliseconds of random delay, up to "secs" seconds.
	*/
	static inline unsigned random_delay_ms(unsigned secs)
	{
	return rand_r(&seed) % (secs * 1000);
	}

	static void configure_wait(void)
	{
	if (timeout_ms == -1)
	return;

	/* poll, being ready to adjust current timeout */
	if (!timeout_ms)
	timeout_ms = random_delay_ms(PROBE_WAIT);

	/* set deadline_ms to the point in time when we timeout */
	deadline_ms = MONOTONIC_MS() + timeout_ms;

	debug_cond(DEBUG_DEV_PKT, "...wait %d %s nprobes=%u, nclaims=%u\n",
	timeout_ms, eth_get_name(), nprobes, nclaims);

	net_set_timeout_handler(timeout_ms, link_local_timeout);
	}

	void link_local_start(void)
	{
	ip = env_get_ip("llipaddr");
	if (ip.s_addr != 0 &&
	(ntohl(ip.s_addr) & IN_CLASSB_NET) != LINKLOCAL_ADDR) {
	puts("invalid link address");
	net_set_state(NETLOOP_FAIL);
	return;
	}
	net_netmask.s_addr = htonl(IN_CLASSB_NET);

	seed = seed_mac();
	if (ip.s_addr == 0)
	ip = pick();

	state = PROBE;
	timeout_ms = 0;
	conflicts = 0;
	nprobes = 0;
	nclaims = 0;
	ready = 0;

	configure_wait();
	}

	static void link_local_timeout(void)
	{
	switch (state) {
	case PROBE:
	/* timeouts in the PROBE state mean no conflicting ARP packets
	have been received, so we can progress through the states */
	if (nprobes < PROBE_NUM) {
	struct in_addr zero_ip = {.s_addr = 0};

	nprobes++;
	debug_cond(DEBUG_LL_STATE, "probe/%u %s@%pI4\n",
	nprobes, eth_get_name(), &ip);
	arp_raw_request(zero_ip, net_null_ethaddr, ip);
	timeout_ms = PROBE_MIN * 1000;
	timeout_ms += random_delay_ms(PROBE_MAX - PROBE_MIN);
	} else {
	/* Switch to announce state */
	state = ANNOUNCE;
	nclaims = 0;
	debug_cond(DEBUG_LL_STATE, "announce/%u %s@%pI4\n",
	nclaims, eth_get_name(), &ip);
	arp_raw_request(ip, net_ethaddr, ip);
	timeout_ms = ANNOUNCE_INTERVAL * 1000;
	}
	break;
	case RATE_LIMIT_PROBE:
	/* timeouts in the RATE_LIMIT_PROBE state mean no conflicting
	ARP packets have been received, so we can move immediately
	to the announce state */
	state = ANNOUNCE;
	nclaims = 0;
	debug_cond(DEBUG_LL_STATE, "announce/%u %s@%pI4\n",
	nclaims, eth_get_name(), &ip);
	arp_raw_request(ip, net_ethaddr, ip);
	timeout_ms = ANNOUNCE_INTERVAL * 1000;
	break;
	case ANNOUNCE:
	/* timeouts in the ANNOUNCE state mean no conflicting ARP
	packets have been received, so we can progress through
	the states */
	if (nclaims < ANNOUNCE_NUM) {
	nclaims++;
	debug_cond(DEBUG_LL_STATE, "announce/%u %s@%pI4\n",
	nclaims, eth_get_name(), &ip);
	arp_raw_request(ip, net_ethaddr, ip);
	timeout_ms = ANNOUNCE_INTERVAL * 1000;
	} else {
	/* Switch to monitor state */
	state = MONITOR;
	printf("Successfully assigned %pI4\n", &ip);
	net_copy_ip(&net_ip, &ip);
	ready = 1;
	conflicts = 0;
	timeout_ms = -1;
	/* Never timeout in the monitor state */
	net_set_timeout_handler(0, NULL);

	/* NOTE: all other exit paths should deconfig ... */
	net_set_state(NETLOOP_SUCCESS);
	return;
	}
	break;
	case DEFEND:
	/* We won! No ARP replies, so just go back to monitor */
	state = MONITOR;
	timeout_ms = -1;
	conflicts = 0;
	break;
	default:
	/* Invalid, should never happen. Restart the whole protocol */
	state = PROBE;
	ip = pick();
	timeout_ms = 0;
	nprobes = 0;
	nclaims = 0;
	break;
	}
	configure_wait();
	}

	void link_local_receive_arp(struct arp_hdr *arp, int len)
	{
	int source_ip_conflict;
	int target_ip_conflict;
	struct in_addr null_ip = {.s_addr = 0};

	if (state == DISABLED)
	return;

	/* We need to adjust the timeout in case we didn't receive a
	conflicting packet. */
	if (timeout_ms > 0) {
	unsigned diff = deadline_ms - MONOTONIC_MS();
	if ((int)(diff) < 0) {
	/* Current time is greater than the expected timeout
	time. This should never happen */
	debug_cond(DEBUG_LL_STATE,
	"missed an expected timeout\n");
	timeout_ms = 0;
	} else {
	debug_cond(DEBUG_INT_STATE, "adjusting timeout\n");
	timeout_ms = diff \| 1; /* never 0 */
	}
	}
	#if 0
	/* XXX Don't bother with ethernet link just yet */
	if ((fds[0].revents & POLLIN) == 0) {
	if (fds[0].revents & POLLERR) {
	/*
	* FIXME: links routinely go down;
	*/
	bb_error_msg("iface %s is down", eth_get_name());
	if (ready)
	run(argv, "deconfig", &ip);
	return EXIT_FAILURE;
	}
	continue;
	}
	#endif

	debug_cond(DEBUG_INT_STATE, "%s recv arp type=%d, op=%d,\n",
	eth_get_name(), ntohs(arp->ar_pro),
	ntohs(arp->ar_op));
	debug_cond(DEBUG_INT_STATE, "\tsource=%pM %pI4\n",
	&arp->ar_sha,
	&arp->ar_spa);
	debug_cond(DEBUG_INT_STATE, "\ttarget=%pM %pI4\n",
	&arp->ar_tha,
	&arp->ar_tpa);

	if (arp->ar_op != htons(ARPOP_REQUEST) &&
	arp->ar_op != htons(ARPOP_REPLY)) {
	configure_wait();
	return;
	}

	source_ip_conflict = 0;
	target_ip_conflict = 0;

	if (memcmp(&arp->ar_spa, &ip, ARP_PLEN) == 0 &&
	memcmp(&arp->ar_sha, net_ethaddr, ARP_HLEN) != 0)
	source_ip_conflict = 1;

	/*
	* According to RFC 3927, section 2.2.1:
	* Check if packet is an ARP probe by checking for a null source IP
	* then check that target IP is equal to ours and source hw addr
	* is not equal to ours. This condition should cause a conflict only
	* during probe.
	*/
	if (arp->ar_op == htons(ARPOP_REQUEST) &&
	memcmp(&arp->ar_spa, &null_ip, ARP_PLEN) == 0 &&
	memcmp(&arp->ar_tpa, &ip, ARP_PLEN) == 0 &&
	memcmp(&arp->ar_sha, net_ethaddr, ARP_HLEN) != 0) {
	target_ip_conflict = 1;
	}

	debug_cond(DEBUG_NET_PKT,
	"state = %d, source ip conflict = %d, target ip conflict = "
	"%d\n", state, source_ip_conflict, target_ip_conflict);
	switch (state) {
	case PROBE:
	case ANNOUNCE:
	/* When probing or announcing, check for source IP conflicts
	and other hosts doing ARP probes (target IP conflicts). */
	if (source_ip_conflict \|\| target_ip_conflict) {
	conflicts++;
	state = PROBE;
	if (conflicts >= MAX_CONFLICTS) {
	debug("%s ratelimit\n", eth_get_name());
	timeout_ms = RATE_LIMIT_INTERVAL * 1000;
	state = RATE_LIMIT_PROBE;
	}

	/* restart the whole protocol */
	ip = pick();
	timeout_ms = 0;
	nprobes = 0;
	nclaims = 0;
	}
	break;
	case MONITOR:
	/* If a conflict, we try to defend with a single ARP probe */
	if (source_ip_conflict) {
	debug("monitor conflict -- defending\n");
	state = DEFEND;
	timeout_ms = DEFEND_INTERVAL * 1000;
	arp_raw_request(ip, net_ethaddr, ip);
	}
	break;
	case DEFEND:
	/* Well, we tried. Start over (on conflict) */
	if (source_ip_conflict) {
	state = PROBE;
	debug("defend conflict -- starting over\n");
	ready = 0;
	net_ip.s_addr = 0;

	/* restart the whole protocol */
	ip = pick();
	timeout_ms = 0;
	nprobes = 0;
	nclaims = 0;
	}
	break;
	default:
	/* Invalid, should never happen. Restart the whole protocol */
	debug("invalid state -- starting over\n");
	state = PROBE;
	ip = pick();
	timeout_ms = 0;
	nprobes = 0;
	nclaims = 0;
	break;
	}
	configure_wait();
	}