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