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