]> git.karo-electronics.de Git - karo-tx-uboot.git/blob - net/link_local.c
Merge remote-tracking branch 'remotes/origin/tx28-bugfix'
[karo-tx-uboot.git] / net / link_local.c
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;
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 IPaddr_t pick(void)
68 {
69         unsigned tmp;
70
71         do {
72                 tmp = rand_r(&seed) & IN_CLASSB_HOST;
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 {
82         return rand_r(&seed) % (secs * 1000);
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
97         debug_cond(DEBUG_DEV_PKT, "...wait %d %s nprobes=%u, nclaims=%u\n",
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 && (ntohl(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
113         seed = seed_mac();
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++;
135                         debug_cond(DEBUG_LL_STATE, "probe/%u %s@%pI4\n",
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;
144                         debug_cond(DEBUG_LL_STATE, "announce/%u %s@%pI4\n",
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;
156                 debug_cond(DEBUG_LL_STATE, "announce/%u %s@%pI4\n",
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++;
167                         debug_cond(DEBUG_LL_STATE, "announce/%u %s@%pI4\n",
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         IPaddr_t null_ip = 0;
210
211         if (state == DISABLED)
212                 return;
213
214         /* We need to adjust the timeout in case we didn't receive a
215            conflicting packet. */
216         if (timeout_ms > 0) {
217                 unsigned diff = deadline_ms - MONOTONIC_MS();
218                 if ((int)(diff) < 0) {
219                         /* Current time is greater than the expected timeout
220                            time. This should never happen */
221                         debug_cond(DEBUG_LL_STATE,
222                                 "missed an expected timeout\n");
223                         timeout_ms = 0;
224                 } else {
225                         debug_cond(DEBUG_INT_STATE, "adjusting timeout\n");
226                         timeout_ms = diff | 1; /* never 0 */
227                 }
228         }
229 #if 0
230  /* XXX Don't bother with ethernet link just yet */
231         if ((fds[0].revents & POLLIN) == 0) {
232                 if (fds[0].revents & POLLERR) {
233                         /*
234                          * FIXME: links routinely go down;
235                          */
236                         bb_error_msg("iface %s is down", eth_get_name());
237                         if (ready) {
238                                 run(argv, "deconfig", &ip);
239                         }
240                         return EXIT_FAILURE;
241                 }
242                 continue;
243         }
244 #endif
245
246         debug_cond(DEBUG_INT_STATE, "%s recv arp type=%d, op=%d,\n",
247                 eth_get_name(), ntohs(arp->ar_pro),
248                 ntohs(arp->ar_op));
249         debug_cond(DEBUG_INT_STATE, "\tsource=%pM %pI4\n",
250                 &arp->ar_sha,
251                 &arp->ar_spa);
252         debug_cond(DEBUG_INT_STATE, "\ttarget=%pM %pI4\n",
253                 &arp->ar_tha,
254                 &arp->ar_tpa);
255
256         if (arp->ar_op != htons(ARPOP_REQUEST)
257          && arp->ar_op != htons(ARPOP_REPLY)
258         ) {
259                 configure_wait();
260                 return;
261         }
262
263         source_ip_conflict = 0;
264         target_ip_conflict = 0;
265
266         if (memcmp(&arp->ar_spa, &ip, ARP_PLEN) == 0
267          && memcmp(&arp->ar_sha, NetOurEther, ARP_HLEN) != 0
268         ) {
269                 source_ip_conflict = 1;
270         }
271
272         /*
273          * According to RFC 3927, section 2.2.1:
274          * Check if packet is an ARP probe by checking for a null source IP
275          * then check that target IP is equal to ours and source hw addr
276          * is not equal to ours. This condition should cause a conflict only
277          * during probe.
278          */
279         if (arp->ar_op == htons(ARPOP_REQUEST) &&
280             memcmp(&arp->ar_spa, &null_ip, ARP_PLEN) == 0 &&
281             memcmp(&arp->ar_tpa, &ip, ARP_PLEN) == 0 &&
282             memcmp(&arp->ar_sha, NetOurEther, ARP_HLEN) != 0) {
283                 target_ip_conflict = 1;
284         }
285
286         debug_cond(DEBUG_NET_PKT,
287                 "state = %d, source ip conflict = %d, target ip conflict = "
288                 "%d\n", state, source_ip_conflict, target_ip_conflict);
289         switch (state) {
290         case PROBE:
291         case ANNOUNCE:
292                 /* When probing or announcing, check for source IP conflicts
293                    and other hosts doing ARP probes (target IP conflicts). */
294                 if (source_ip_conflict || target_ip_conflict) {
295                         conflicts++;
296                         state = PROBE;
297                         if (conflicts >= MAX_CONFLICTS) {
298                                 debug("%s ratelimit\n", eth_get_name());
299                                 timeout_ms = RATE_LIMIT_INTERVAL * 1000;
300                                 state = RATE_LIMIT_PROBE;
301                         }
302
303                         /* restart the whole protocol */
304                         ip = pick();
305                         timeout_ms = 0;
306                         nprobes = 0;
307                         nclaims = 0;
308                 }
309                 break;
310         case MONITOR:
311                 /* If a conflict, we try to defend with a single ARP probe */
312                 if (source_ip_conflict) {
313                         debug("monitor conflict -- defending\n");
314                         state = DEFEND;
315                         timeout_ms = DEFEND_INTERVAL * 1000;
316                         arp_raw_request(ip, NetOurEther, ip);
317                 }
318                 break;
319         case DEFEND:
320                 /* Well, we tried.  Start over (on conflict) */
321                 if (source_ip_conflict) {
322                         state = PROBE;
323                         debug("defend conflict -- starting over\n");
324                         ready = 0;
325                         NetOurIP = 0;
326
327                         /* restart the whole protocol */
328                         ip = pick();
329                         timeout_ms = 0;
330                         nprobes = 0;
331                         nclaims = 0;
332                 }
333                 break;
334         default:
335                 /* Invalid, should never happen.  Restart the whole protocol */
336                 debug("invalid state -- starting over\n");
337                 state = PROBE;
338                 ip = pick();
339                 timeout_ms = 0;
340                 nprobes = 0;
341                 nclaims = 0;
342                 break;
343         }
344         configure_wait();
345 }