[people/ms/u-boot.git] / net / link_local.c

/*
 * 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 <net.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 IPaddr_t 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 IPaddr_t pick(void)
{
	unsigned tmp;

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

/**
 * 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);

	NetSetTimeout(timeout_ms, link_local_timeout);
}

void link_local_start(void)
{
	ip = getenv_IPaddr("llipaddr");
	if (ip != 0 && (ip & IN_CLASSB_NET) != LINKLOCAL_ADDR) {
		puts("invalid link address");
		net_set_state(NETLOOP_FAIL);
		return;
	}
	NetOurSubnetMask = IN_CLASSB_NET;

	seed = seed_mac();
	if (ip == 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) {
			nprobes++;
			debug_cond(DEBUG_LL_STATE, "probe/%u %s@%pI4\n",
					nprobes, eth_get_name(), &ip);
			arp_raw_request(0, NetEtherNullAddr, 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, NetOurEther, 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, NetOurEther, 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, NetOurEther, ip);
			timeout_ms = ANNOUNCE_INTERVAL * 1000;
		} else {
			/* Switch to monitor state */
			state = MONITOR;
			printf("Successfully assigned %pI4\n", &ip);
			NetCopyIP(&NetOurIP, &ip);
			ready = 1;
			conflicts = 0;
			timeout_ms = -1;
			/* Never timeout in the monitor state */
			NetSetTimeout(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;

	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 */
		}
	}
/*
 * 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;
			// this shouldn't necessarily exit.
			bb_error_msg("iface %s is down", eth_get_name());
			if (ready) {
				run(argv, "deconfig", &ip);
			}
			return EXIT_FAILURE;
		}
		continue;
	}
*/

	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, NetOurEther, ARP_HLEN) != 0
	) {
		source_ip_conflict = 1;
	}
	if (arp->ar_op == htons(ARPOP_REQUEST)
	 && memcmp(&arp->ar_tpa, &ip, ARP_PLEN) == 0
	 && memcmp(&arp->ar_tha, NetOurEther, 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, NetOurEther, 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;
			NetOurIP = 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();
}
Commit	Line	Data
d22c338e JH	1	/*
	2	* RFC3927 ZeroConf IPv4 Link-Local addressing
	3	* (see <http://www.zeroconf.org/>)
	4	*
	5	* Copied from BusyBox - networking/zcip.c
	6	*
	7	* Copyright (C) 2003 by Arthur van Hoff (avh@strangeberry.com)
	8	* Copyright (C) 2004 by David Brownell
	9	* Copyright (C) 2010 by Joe Hershberger
	10	*
	11	* Licensed under the GPL v2 or later
	12	*/
	13
	14	#include <common.h>
	15	#include <net.h>
	16	#include "arp.h"
	17	#include "net_rand.h"
	18
	19	/* We don't need more than 32 bits of the counter */
	20	#define MONOTONIC_MS() ((unsigned)get_timer(0) * (1000 / CONFIG_SYS_HZ))
	21
	22	enum {
	23	/* 169.254.0.0 */
	24	LINKLOCAL_ADDR = 0xa9fe0000,
	25
	26	IN_CLASSB_NET = 0xffff0000,
	27	IN_CLASSB_HOST = 0x0000ffff,
	28
	29	/* protocol timeout parameters, specified in seconds */
	30	PROBE_WAIT = 1,
	31	PROBE_MIN = 1,
	32	PROBE_MAX = 2,
	33	PROBE_NUM = 3,
	34	MAX_CONFLICTS = 10,
	35	RATE_LIMIT_INTERVAL = 60,
	36	ANNOUNCE_WAIT = 2,
	37	ANNOUNCE_NUM = 2,
	38	ANNOUNCE_INTERVAL = 2,
	39	DEFEND_INTERVAL = 10
	40	};
	41
	42	/* States during the configuration process. */
	43	static enum ll_state_t {
	44	PROBE = 0,
	45	RATE_LIMIT_PROBE,
	46	ANNOUNCE,
	47	MONITOR,
	48	DEFEND,
	49	DISABLED
	50	} state = DISABLED;
	51
	52	static IPaddr_t ip;
	53	static int timeout_ms = -1;
	54	static unsigned deadline_ms;
	55	static unsigned conflicts;
	56	static unsigned nprobes;
	57	static unsigned nclaims;
	58	static int ready;
99e139d5	59	static unsigned int seed;
d22c338e JH	60
	61	static void link_local_timeout(void);
	62
	63	/**
	64	* Pick a random link local IP address on 169.254/16, except that
	65	* the first and last 256 addresses are reserved.
	66	*/
	67	static IPaddr_t pick(void)
	68	{
	69	unsigned tmp;
	70
	71	do {
99e139d5	72	tmp = rand_r(&seed) & IN_CLASSB_HOST;
d22c338e JH	73	} while (tmp > (IN_CLASSB_HOST - 0x0200));
	74	return (IPaddr_t) htonl((LINKLOCAL_ADDR + 0x0100) + tmp);
	75	}
	76
	77	/**
	78	* Return milliseconds of random delay, up to "secs" seconds.
	79	*/
	80	static inline unsigned random_delay_ms(unsigned secs)
	81	{
99e139d5	82	return rand_r(&seed) % (secs * 1000);
d22c338e JH	83	}
	84
	85	static void configure_wait(void)
	86	{
	87	if (timeout_ms == -1)
	88	return;
	89
	90	/* poll, being ready to adjust current timeout */
	91	if (!timeout_ms)
	92	timeout_ms = random_delay_ms(PROBE_WAIT);
	93
	94	/* set deadline_ms to the point in time when we timeout */
	95	deadline_ms = MONOTONIC_MS() + timeout_ms;
	96
4ef8d53c	97	debug_cond(DEBUG_DEV_PKT, "...wait %d %s nprobes=%u, nclaims=%u\n",
d22c338e JH	98	timeout_ms, eth_get_name(), nprobes, nclaims);
	99
	100	NetSetTimeout(timeout_ms, link_local_timeout);
	101	}
	102
	103	void link_local_start(void)
	104	{
	105	ip = getenv_IPaddr("llipaddr");
	106	if (ip != 0 && (ip & IN_CLASSB_NET) != LINKLOCAL_ADDR) {
	107	puts("invalid link address");
	108	net_set_state(NETLOOP_FAIL);
	109	return;
	110	}
	111	NetOurSubnetMask = IN_CLASSB_NET;
	112
99e139d5	113	seed = seed_mac();
d22c338e JH	114	if (ip == 0)
	115	ip = pick();
	116
	117	state = PROBE;
	118	timeout_ms = 0;
	119	conflicts = 0;
	120	nprobes = 0;
	121	nclaims = 0;
	122	ready = 0;
	123
	124	configure_wait();
	125	}
	126
	127	static void link_local_timeout(void)
	128	{
	129	switch (state) {
	130	case PROBE:
	131	/* timeouts in the PROBE state mean no conflicting ARP packets
	132	have been received, so we can progress through the states */
	133	if (nprobes < PROBE_NUM) {
	134	nprobes++;
4ef8d53c	135	debug_cond(DEBUG_LL_STATE, "probe/%u %s@%pI4\n",
d22c338e JH	136	nprobes, eth_get_name(), &ip);
	137	arp_raw_request(0, NetEtherNullAddr, ip);
	138	timeout_ms = PROBE_MIN * 1000;
	139	timeout_ms += random_delay_ms(PROBE_MAX - PROBE_MIN);
	140	} else {
	141	/* Switch to announce state */
	142	state = ANNOUNCE;
	143	nclaims = 0;
4ef8d53c	144	debug_cond(DEBUG_LL_STATE, "announce/%u %s@%pI4\n",
d22c338e JH	145	nclaims, eth_get_name(), &ip);
	146	arp_raw_request(ip, NetOurEther, ip);
	147	timeout_ms = ANNOUNCE_INTERVAL * 1000;
	148	}
	149	break;
	150	case RATE_LIMIT_PROBE:
	151	/* timeouts in the RATE_LIMIT_PROBE state mean no conflicting
	152	ARP packets have been received, so we can move immediately
	153	to the announce state */
	154	state = ANNOUNCE;
	155	nclaims = 0;
4ef8d53c	156	debug_cond(DEBUG_LL_STATE, "announce/%u %s@%pI4\n",
d22c338e JH	157	nclaims, eth_get_name(), &ip);
	158	arp_raw_request(ip, NetOurEther, ip);
	159	timeout_ms = ANNOUNCE_INTERVAL * 1000;
	160	break;
	161	case ANNOUNCE:
	162	/* timeouts in the ANNOUNCE state mean no conflicting ARP
	163	packets have been received, so we can progress through
	164	the states */
	165	if (nclaims < ANNOUNCE_NUM) {
	166	nclaims++;
4ef8d53c	167	debug_cond(DEBUG_LL_STATE, "announce/%u %s@%pI4\n",
d22c338e JH	168	nclaims, eth_get_name(), &ip);
	169	arp_raw_request(ip, NetOurEther, ip);
	170	timeout_ms = ANNOUNCE_INTERVAL * 1000;
	171	} else {
	172	/* Switch to monitor state */
	173	state = MONITOR;
	174	printf("Successfully assigned %pI4\n", &ip);
	175	NetCopyIP(&NetOurIP, &ip);
	176	ready = 1;
	177	conflicts = 0;
	178	timeout_ms = -1;
	179	/* Never timeout in the monitor state */
	180	NetSetTimeout(0, NULL);
	181
	182	/* NOTE: all other exit paths should deconfig ... */
	183	net_set_state(NETLOOP_SUCCESS);
	184	return;
	185	}
	186	break;
	187	case DEFEND:
	188	/* We won! No ARP replies, so just go back to monitor */
	189	state = MONITOR;
	190	timeout_ms = -1;
	191	conflicts = 0;
	192	break;
	193	default:
	194	/* Invalid, should never happen. Restart the whole protocol */
	195	state = PROBE;
	196	ip = pick();
	197	timeout_ms = 0;
	198	nprobes = 0;
	199	nclaims = 0;
	200	break;
	201	}
	202	configure_wait();
	203	}
	204
	205	void link_local_receive_arp(struct arp_hdr *arp, int len)
	206	{
	207	int source_ip_conflict;
	208	int target_ip_conflict;
	209
	210	if (state == DISABLED)
	211	return;
	212
	213	/* We need to adjust the timeout in case we didn't receive a
	214	conflicting packet. */
	215	if (timeout_ms > 0) {
	216	unsigned diff = deadline_ms - MONOTONIC_MS();
	217	if ((int)(diff) < 0) {
	218	/* Current time is greater than the expected timeout
	219	time. This should never happen */
4ef8d53c JH	220	debug_cond(DEBUG_LL_STATE,
4ef8d53c JH	221	"missed an expected timeout\n");
d22c338e JH	222	timeout_ms = 0;
d22c338e JH	223	} else {
4ef8d53c	224	debug_cond(DEBUG_INT_STATE, "adjusting timeout\n");
d22c338e JH	225	timeout_ms = diff \| 1; /* never 0 */
	226	}
	227	}
	228	/*
	229	* XXX Don't bother with ethernet link just yet
	230	if ((fds[0].revents & POLLIN) == 0) {
	231	if (fds[0].revents & POLLERR) {
	232	// FIXME: links routinely go down;
	233	// this shouldn't necessarily exit.
	234	bb_error_msg("iface %s is down", eth_get_name());
	235	if (ready) {
	236	run(argv, "deconfig", &ip);
	237	}
	238	return EXIT_FAILURE;
	239	}
	240	continue;
	241	}
	242	*/
	243
4ef8d53c	244	debug_cond(DEBUG_INT_STATE, "%s recv arp type=%d, op=%d,\n",
d22c338e JH	245	eth_get_name(), ntohs(arp->ar_pro),
d22c338e JH	246	ntohs(arp->ar_op));
4ef8d53c	247	debug_cond(DEBUG_INT_STATE, "\tsource=%pM %pI4\n",
d22c338e JH	248	&arp->ar_sha,
d22c338e JH	249	&arp->ar_spa);
4ef8d53c	250	debug_cond(DEBUG_INT_STATE, "\ttarget=%pM %pI4\n",
d22c338e JH	251	&arp->ar_tha,
	252	&arp->ar_tpa);
	253
	254	if (arp->ar_op != htons(ARPOP_REQUEST)
	255	&& arp->ar_op != htons(ARPOP_REPLY)
	256	) {
	257	configure_wait();
	258	return;
	259	}
	260
	261	source_ip_conflict = 0;
	262	target_ip_conflict = 0;
	263
	264	if (memcmp(&arp->ar_spa, &ip, ARP_PLEN) == 0
	265	&& memcmp(&arp->ar_sha, NetOurEther, ARP_HLEN) != 0
	266	) {
	267	source_ip_conflict = 1;
	268	}
	269	if (arp->ar_op == htons(ARPOP_REQUEST)
	270	&& memcmp(&arp->ar_tpa, &ip, ARP_PLEN) == 0
	271	&& memcmp(&arp->ar_tha, NetOurEther, ARP_HLEN) != 0
	272	) {
	273	target_ip_conflict = 1;
	274	}
	275
4ef8d53c JH	276	debug_cond(DEBUG_NET_PKT,
	277	"state = %d, source ip conflict = %d, target ip conflict = "
	278	"%d\n", state, source_ip_conflict, target_ip_conflict);
d22c338e JH	279	switch (state) {
	280	case PROBE:
	281	case ANNOUNCE:
	282	/* When probing or announcing, check for source IP conflicts
	283	and other hosts doing ARP probes (target IP conflicts). */
	284	if (source_ip_conflict \|\| target_ip_conflict) {
	285	conflicts++;
	286	state = PROBE;
	287	if (conflicts >= MAX_CONFLICTS) {
	288	debug("%s ratelimit\n", eth_get_name());
	289	timeout_ms = RATE_LIMIT_INTERVAL * 1000;
	290	state = RATE_LIMIT_PROBE;
	291	}
	292
	293	/* restart the whole protocol */
	294	ip = pick();
	295	timeout_ms = 0;
	296	nprobes = 0;
	297	nclaims = 0;
	298	}
	299	break;
	300	case MONITOR:
	301	/* If a conflict, we try to defend with a single ARP probe */
	302	if (source_ip_conflict) {
	303	debug("monitor conflict -- defending\n");
	304	state = DEFEND;
	305	timeout_ms = DEFEND_INTERVAL * 1000;
	306	arp_raw_request(ip, NetOurEther, ip);
	307	}
	308	break;
	309	case DEFEND:
	310	/* Well, we tried. Start over (on conflict) */
	311	if (source_ip_conflict) {
	312	state = PROBE;
	313	debug("defend conflict -- starting over\n");
	314	ready = 0;
	315	NetOurIP = 0;
	316
	317	/* restart the whole protocol */
	318	ip = pick();
	319	timeout_ms = 0;
	320	nprobes = 0;
	321	nclaims = 0;
	322	}
	323	break;
	324	default:
	325	/* Invalid, should never happen. Restart the whole protocol */
	326	debug("invalid state -- starting over\n");
	327	state = PROBE;
	328	ip = pick();
	329	timeout_ms = 0;
	330	nprobes = 0;
	331	nclaims = 0;
	332	break;
	333	}
	334	configure_wait();
	335	}