link_local.c 8.5 KB

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