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