link_local.c 8.5 KB

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