1 /** 2 * @file 3 * AutoIP Automatic LinkLocal IP Configuration 4 * 5 * This is a AutoIP implementation for the lwIP TCP/IP stack. It aims to conform 6 * with RFC 3927. 7 * 8 * @defgroup autoip AUTOIP 9 * @ingroup ip4 10 * AUTOIP related functions 11 * USAGE: 12 * 13 * define @ref LWIP_AUTOIP 1 in your lwipopts.h 14 * Options: 15 * AUTOIP_TMR_INTERVAL msecs, 16 * I recommend a value of 100. The value must divide 1000 with a remainder almost 0. 17 * Possible values are 1000, 500, 333, 250, 200, 166, 142, 125, 111, 100 .... 18 * 19 * Without DHCP: 20 * - Call autoip_start() after netif_add(). 21 * 22 * With DHCP: 23 * - define @ref LWIP_DHCP_AUTOIP_COOP 1 in your lwipopts.h. 24 * - Configure your DHCP Client. 25 * 26 * @see netifapi_autoip 27 */ 28 29 /* 30 * 31 * Copyright (c) 2007 Dominik Spies <kontakt@dspies.de> 32 * All rights reserved. 33 * 34 * Redistribution and use in source and binary forms, with or without modification, 35 * are permitted provided that the following conditions are met: 36 * 37 * 1. Redistributions of source code must retain the above copyright notice, 38 * this list of conditions and the following disclaimer. 39 * 2. Redistributions in binary form must reproduce the above copyright notice, 40 * this list of conditions and the following disclaimer in the documentation 41 * and/or other materials provided with the distribution. 42 * 3. The name of the author may not be used to endorse or promote products 43 * derived from this software without specific prior written permission. 44 * 45 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED 46 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF 47 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT 48 * SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, 49 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT 50 * OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 51 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 52 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING 53 * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY 54 * OF SUCH DAMAGE. 55 * 56 * Author: Dominik Spies <kontakt@dspies.de> 57 */ 58 59 #include "lwip/opt.h" 60 61 #if LWIP_IPV4 && LWIP_AUTOIP /* don't build if not configured for use in lwipopts.h */ 62 63 #include "lwip/mem.h" 64 /* #include "lwip/udp.h" */ 65 #include "lwip/ip_addr.h" 66 #include "lwip/netif.h" 67 #include "lwip/autoip.h" 68 #include "lwip/etharp.h" 69 #include "lwip/prot/autoip.h" 70 71 #include <string.h> 72 73 /** Pseudo random macro based on netif informations. 74 * You could use "rand()" from the C Library if you define LWIP_AUTOIP_RAND in lwipopts.h */ 75 #ifndef LWIP_AUTOIP_RAND 76 #define LWIP_AUTOIP_RAND(netif) ( (((u32_t)((netif->hwaddr[5]) & 0xff) << 24) | \ 77 ((u32_t)((netif->hwaddr[3]) & 0xff) << 16) | \ 78 ((u32_t)((netif->hwaddr[2]) & 0xff) << 8) | \ 79 ((u32_t)((netif->hwaddr[4]) & 0xff))) + \ 80 (netif_autoip_data(netif)? netif_autoip_data(netif)->tried_llipaddr : 0)) 81 #endif /* LWIP_AUTOIP_RAND */ 82 83 /** 84 * Macro that generates the initial IP address to be tried by AUTOIP. 85 * If you want to override this, define it to something else in lwipopts.h. 86 */ 87 #ifndef LWIP_AUTOIP_CREATE_SEED_ADDR 88 #define LWIP_AUTOIP_CREATE_SEED_ADDR(netif) \ 89 lwip_htonl(AUTOIP_RANGE_START + ((u32_t)(((u8_t)(netif->hwaddr[4])) | \ 90 ((u32_t)((u8_t)(netif->hwaddr[5]))) << 8))) 91 #endif /* LWIP_AUTOIP_CREATE_SEED_ADDR */ 92 93 /* static functions */ 94 static err_t autoip_arp_announce(struct netif *netif); 95 static void autoip_start_probing(struct netif *netif); 96 97 /** 98 * @ingroup autoip 99 * Set a statically allocated struct autoip to work with. 100 * Using this prevents autoip_start to allocate it using mem_malloc. 101 * 102 * @param netif the netif for which to set the struct autoip 103 * @param autoip (uninitialised) autoip struct allocated by the application 104 */ 105 void 106 autoip_set_struct(struct netif *netif, struct autoip *autoip) 107 { 108 LWIP_ASSERT("netif != NULL", netif != NULL); 109 LWIP_ASSERT("autoip != NULL", autoip != NULL); 110 LWIP_ASSERT("netif already has a struct autoip set", 111 netif_autoip_data(netif) == NULL); 112 113 /* clear data structure */ 114 memset(autoip, 0, sizeof(struct autoip)); 115 /* autoip->state = AUTOIP_STATE_OFF; */ 116 netif_set_client_data(netif, LWIP_NETIF_CLIENT_DATA_INDEX_AUTOIP, autoip); 117 } 118 119 /** Restart AutoIP client and check the next address (conflict detected) 120 * 121 * @param netif The netif under AutoIP control 122 */ 123 static void 124 autoip_restart(struct netif *netif) 125 { 126 struct autoip* autoip = netif_autoip_data(netif); 127 autoip->tried_llipaddr++; 128 autoip_start(netif); 129 } 130 131 /** 132 * Handle a IP address conflict after an ARP conflict detection 133 */ 134 static void 135 autoip_handle_arp_conflict(struct netif *netif) 136 { 137 struct autoip* autoip = netif_autoip_data(netif); 138 139 /* RFC3927, 2.5 "Conflict Detection and Defense" allows two options where 140 a) means retreat on the first conflict and 141 b) allows to keep an already configured address when having only one 142 conflict in 10 seconds 143 We use option b) since it helps to improve the chance that one of the two 144 conflicting hosts may be able to retain its address. */ 145 146 if (autoip->lastconflict > 0) { 147 /* retreat, there was a conflicting ARP in the last DEFEND_INTERVAL seconds */ 148 LWIP_DEBUGF(AUTOIP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE, 149 ("autoip_handle_arp_conflict(): we are defending, but in DEFEND_INTERVAL, retreating\n")); 150 151 /* Active TCP sessions are aborted when removing the ip addresss */ 152 autoip_restart(netif); 153 } else { 154 LWIP_DEBUGF(AUTOIP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE, 155 ("autoip_handle_arp_conflict(): we are defend, send ARP Announce\n")); 156 autoip_arp_announce(netif); 157 autoip->lastconflict = DEFEND_INTERVAL * AUTOIP_TICKS_PER_SECOND; 158 } 159 } 160 161 /** 162 * Create an IP-Address out of range 169.254.1.0 to 169.254.254.255 163 * 164 * @param netif network interface on which create the IP-Address 165 * @param ipaddr ip address to initialize 166 */ 167 static void 168 autoip_create_addr(struct netif *netif, ip4_addr_t *ipaddr) 169 { 170 struct autoip* autoip = netif_autoip_data(netif); 171 172 /* Here we create an IP-Address out of range 169.254.1.0 to 169.254.254.255 173 * compliant to RFC 3927 Section 2.1 174 * We have 254 * 256 possibilities */ 175 176 u32_t addr = lwip_ntohl(LWIP_AUTOIP_CREATE_SEED_ADDR(netif)); 177 addr += autoip->tried_llipaddr; 178 addr = AUTOIP_NET | (addr & 0xffff); 179 /* Now, 169.254.0.0 <= addr <= 169.254.255.255 */ 180 181 if (addr < AUTOIP_RANGE_START) { 182 addr += AUTOIP_RANGE_END - AUTOIP_RANGE_START + 1; 183 } 184 if (addr > AUTOIP_RANGE_END) { 185 addr -= AUTOIP_RANGE_END - AUTOIP_RANGE_START + 1; 186 } 187 LWIP_ASSERT("AUTOIP address not in range", (addr >= AUTOIP_RANGE_START) && 188 (addr <= AUTOIP_RANGE_END)); 189 ip4_addr_set_u32(ipaddr, lwip_htonl(addr)); 190 191 LWIP_DEBUGF(AUTOIP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE, 192 ("autoip_create_addr(): tried_llipaddr=%"U16_F", %"U16_F".%"U16_F".%"U16_F".%"U16_F"\n", 193 (u16_t)(autoip->tried_llipaddr), ip4_addr1_16(ipaddr), ip4_addr2_16(ipaddr), 194 ip4_addr3_16(ipaddr), ip4_addr4_16(ipaddr))); 195 } 196 197 /** 198 * Sends an ARP probe from a network interface 199 * 200 * @param netif network interface used to send the probe 201 */ 202 static err_t 203 autoip_arp_probe(struct netif *netif) 204 { 205 struct autoip* autoip = netif_autoip_data(netif); 206 /* this works because netif->ip_addr is ANY */ 207 return etharp_request(netif, &autoip->llipaddr); 208 } 209 210 /** 211 * Sends an ARP announce from a network interface 212 * 213 * @param netif network interface used to send the announce 214 */ 215 static err_t 216 autoip_arp_announce(struct netif *netif) 217 { 218 return etharp_gratuitous(netif); 219 } 220 221 /** 222 * Configure interface for use with current LL IP-Address 223 * 224 * @param netif network interface to configure with current LL IP-Address 225 */ 226 static err_t 227 autoip_bind(struct netif *netif) 228 { 229 struct autoip* autoip = netif_autoip_data(netif); 230 ip4_addr_t sn_mask, gw_addr; 231 232 LWIP_DEBUGF(AUTOIP_DEBUG | LWIP_DBG_TRACE, 233 ("autoip_bind(netif=%p) %c%c%"U16_F" %"U16_F".%"U16_F".%"U16_F".%"U16_F"\n", 234 (void*)netif, netif->name[0], netif->name[1], (u16_t)netif->num, 235 ip4_addr1_16(&autoip->llipaddr), ip4_addr2_16(&autoip->llipaddr), 236 ip4_addr3_16(&autoip->llipaddr), ip4_addr4_16(&autoip->llipaddr))); 237 238 IP4_ADDR(&sn_mask, 255, 255, 0, 0); 239 IP4_ADDR(&gw_addr, 0, 0, 0, 0); 240 241 netif_set_addr(netif, &autoip->llipaddr, &sn_mask, &gw_addr); 242 /* interface is used by routing now that an address is set */ 243 244 return ERR_OK; 245 } 246 247 /** 248 * @ingroup autoip 249 * Start AutoIP client 250 * 251 * @param netif network interface on which start the AutoIP client 252 */ 253 err_t 254 autoip_start(struct netif *netif) 255 { 256 struct autoip* autoip = netif_autoip_data(netif); 257 err_t result = ERR_OK; 258 259 LWIP_ERROR("netif is not up, old style port?", netif_is_up(netif), return ERR_ARG;); 260 261 /* Set IP-Address, Netmask and Gateway to 0 to make sure that 262 * ARP Packets are formed correctly 263 */ 264 netif_set_addr(netif, IP4_ADDR_ANY4, IP4_ADDR_ANY4, IP4_ADDR_ANY4); 265 266 LWIP_DEBUGF(AUTOIP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE, 267 ("autoip_start(netif=%p) %c%c%"U16_F"\n", (void*)netif, netif->name[0], 268 netif->name[1], (u16_t)netif->num)); 269 if (autoip == NULL) { 270 /* no AutoIP client attached yet? */ 271 LWIP_DEBUGF(AUTOIP_DEBUG | LWIP_DBG_TRACE, 272 ("autoip_start(): starting new AUTOIP client\n")); 273 autoip = (struct autoip *)mem_malloc(sizeof(struct autoip)); 274 if (autoip == NULL) { 275 LWIP_DEBUGF(AUTOIP_DEBUG | LWIP_DBG_TRACE, 276 ("autoip_start(): could not allocate autoip\n")); 277 return ERR_MEM; 278 } 279 memset(autoip, 0, sizeof(struct autoip)); 280 /* store this AutoIP client in the netif */ 281 netif_set_client_data(netif, LWIP_NETIF_CLIENT_DATA_INDEX_AUTOIP, autoip); 282 LWIP_DEBUGF(AUTOIP_DEBUG | LWIP_DBG_TRACE, ("autoip_start(): allocated autoip")); 283 } else { 284 autoip->state = AUTOIP_STATE_OFF; 285 autoip->ttw = 0; 286 autoip->sent_num = 0; 287 ip4_addr_set_zero(&autoip->llipaddr); 288 autoip->lastconflict = 0; 289 } 290 291 autoip_create_addr(netif, &(autoip->llipaddr)); 292 autoip_start_probing(netif); 293 294 return result; 295 } 296 297 static void 298 autoip_start_probing(struct netif *netif) 299 { 300 struct autoip* autoip = netif_autoip_data(netif); 301 302 autoip->state = AUTOIP_STATE_PROBING; 303 autoip->sent_num = 0; 304 LWIP_DEBUGF(AUTOIP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE, 305 ("autoip_start_probing(): changing state to PROBING: %"U16_F".%"U16_F".%"U16_F".%"U16_F"\n", 306 ip4_addr1_16(&autoip->llipaddr), ip4_addr2_16(&autoip->llipaddr), 307 ip4_addr3_16(&autoip->llipaddr), ip4_addr4_16(&autoip->llipaddr))); 308 309 /* time to wait to first probe, this is randomly 310 * chosen out of 0 to PROBE_WAIT seconds. 311 * compliant to RFC 3927 Section 2.2.1 312 */ 313 autoip->ttw = (u16_t)(LWIP_AUTOIP_RAND(netif) % (PROBE_WAIT * AUTOIP_TICKS_PER_SECOND)); 314 315 /* 316 * if we tried more then MAX_CONFLICTS we must limit our rate for 317 * acquiring and probing address 318 * compliant to RFC 3927 Section 2.2.1 319 */ 320 if (autoip->tried_llipaddr > MAX_CONFLICTS) { 321 autoip->ttw = RATE_LIMIT_INTERVAL * AUTOIP_TICKS_PER_SECOND; 322 } 323 } 324 325 /** 326 * Handle a possible change in the network configuration. 327 * 328 * If there is an AutoIP address configured, take the interface down 329 * and begin probing with the same address. 330 */ 331 void 332 autoip_network_changed(struct netif *netif) 333 { 334 struct autoip* autoip = netif_autoip_data(netif); 335 336 if (autoip && (autoip->state != AUTOIP_STATE_OFF)) { 337 autoip_start_probing(netif); 338 } 339 } 340 341 /** 342 * @ingroup autoip 343 * Stop AutoIP client 344 * 345 * @param netif network interface on which stop the AutoIP client 346 */ 347 err_t 348 autoip_stop(struct netif *netif) 349 { 350 struct autoip* autoip = netif_autoip_data(netif); 351 352 if (autoip != NULL) { 353 autoip->state = AUTOIP_STATE_OFF; 354 if (ip4_addr_islinklocal(netif_ip4_addr(netif))) { 355 netif_set_addr(netif, IP4_ADDR_ANY4, IP4_ADDR_ANY4, IP4_ADDR_ANY4); 356 } 357 } 358 return ERR_OK; 359 } 360 361 /** 362 * Has to be called in loop every AUTOIP_TMR_INTERVAL milliseconds 363 */ 364 void 365 autoip_tmr(void) 366 { 367 struct netif *netif; 368 /* loop through netif's */ 369 NETIF_FOREACH(netif) { 370 struct autoip* autoip = netif_autoip_data(netif); 371 /* only act on AutoIP configured interfaces */ 372 if (autoip != NULL) { 373 if (autoip->lastconflict > 0) { 374 autoip->lastconflict--; 375 } 376 377 LWIP_DEBUGF(AUTOIP_DEBUG | LWIP_DBG_TRACE, 378 ("autoip_tmr() AutoIP-State: %"U16_F", ttw=%"U16_F"\n", 379 (u16_t)(autoip->state), autoip->ttw)); 380 381 if (autoip->ttw > 0) { 382 autoip->ttw--; 383 } 384 385 switch(autoip->state) { 386 case AUTOIP_STATE_PROBING: 387 if (autoip->ttw == 0) { 388 if (autoip->sent_num >= PROBE_NUM) { 389 /* Switch to ANNOUNCING: now we can bind to an IP address and use it */ 390 autoip->state = AUTOIP_STATE_ANNOUNCING; 391 autoip_bind(netif); 392 /* autoip_bind() calls netif_set_addr(): this triggers a gratuitous ARP 393 which counts as an announcement */ 394 autoip->sent_num = 1; 395 autoip->ttw = ANNOUNCE_WAIT * AUTOIP_TICKS_PER_SECOND; 396 LWIP_DEBUGF(AUTOIP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE, 397 ("autoip_tmr(): changing state to ANNOUNCING: %"U16_F".%"U16_F".%"U16_F".%"U16_F"\n", 398 ip4_addr1_16(&autoip->llipaddr), ip4_addr2_16(&autoip->llipaddr), 399 ip4_addr3_16(&autoip->llipaddr), ip4_addr4_16(&autoip->llipaddr))); 400 } else { 401 autoip_arp_probe(netif); 402 LWIP_DEBUGF(AUTOIP_DEBUG | LWIP_DBG_TRACE, ("autoip_tmr() PROBING Sent Probe\n")); 403 autoip->sent_num++; 404 if (autoip->sent_num == PROBE_NUM) { 405 /* calculate time to wait to for announce */ 406 autoip->ttw = ANNOUNCE_WAIT * AUTOIP_TICKS_PER_SECOND; 407 } else { 408 /* calculate time to wait to next probe */ 409 autoip->ttw = (u16_t)((LWIP_AUTOIP_RAND(netif) % 410 ((PROBE_MAX - PROBE_MIN) * AUTOIP_TICKS_PER_SECOND) ) + 411 PROBE_MIN * AUTOIP_TICKS_PER_SECOND); 412 } 413 } 414 } 415 break; 416 417 case AUTOIP_STATE_ANNOUNCING: 418 if (autoip->ttw == 0) { 419 autoip_arp_announce(netif); 420 LWIP_DEBUGF(AUTOIP_DEBUG | LWIP_DBG_TRACE, ("autoip_tmr() ANNOUNCING Sent Announce\n")); 421 autoip->ttw = ANNOUNCE_INTERVAL * AUTOIP_TICKS_PER_SECOND; 422 autoip->sent_num++; 423 424 if (autoip->sent_num >= ANNOUNCE_NUM) { 425 autoip->state = AUTOIP_STATE_BOUND; 426 autoip->sent_num = 0; 427 autoip->ttw = 0; 428 LWIP_DEBUGF(AUTOIP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE, 429 ("autoip_tmr(): changing state to BOUND: %"U16_F".%"U16_F".%"U16_F".%"U16_F"\n", 430 ip4_addr1_16(&autoip->llipaddr), ip4_addr2_16(&autoip->llipaddr), 431 ip4_addr3_16(&autoip->llipaddr), ip4_addr4_16(&autoip->llipaddr))); 432 } 433 } 434 break; 435 436 default: 437 /* nothing to do in other states */ 438 break; 439 } 440 } 441 } 442 } 443 444 /** 445 * Handles every incoming ARP Packet, called by etharp_input(). 446 * 447 * @param netif network interface to use for autoip processing 448 * @param hdr Incoming ARP packet 449 */ 450 void 451 autoip_arp_reply(struct netif *netif, struct etharp_hdr *hdr) 452 { 453 struct autoip* autoip = netif_autoip_data(netif); 454 455 LWIP_DEBUGF(AUTOIP_DEBUG | LWIP_DBG_TRACE, ("autoip_arp_reply()\n")); 456 if ((autoip != NULL) && (autoip->state != AUTOIP_STATE_OFF)) { 457 /* when ip.src == llipaddr && hw.src != netif->hwaddr 458 * 459 * when probing ip.dst == llipaddr && hw.src != netif->hwaddr 460 * we have a conflict and must solve it 461 */ 462 ip4_addr_t sipaddr, dipaddr; 463 struct eth_addr netifaddr; 464 ETHADDR16_COPY(netifaddr.addr, netif->hwaddr); 465 466 /* Copy struct ip4_addr_wordaligned to aligned ip4_addr, to support compilers without 467 * structure packing (not using structure copy which breaks strict-aliasing rules). 468 */ 469 IPADDR_WORDALIGNED_COPY_TO_IP4_ADDR_T(&sipaddr, &hdr->sipaddr); 470 IPADDR_WORDALIGNED_COPY_TO_IP4_ADDR_T(&dipaddr, &hdr->dipaddr); 471 472 if (autoip->state == AUTOIP_STATE_PROBING) { 473 /* RFC 3927 Section 2.2.1: 474 * from beginning to after ANNOUNCE_WAIT 475 * seconds we have a conflict if 476 * ip.src == llipaddr OR 477 * ip.dst == llipaddr && hw.src != own hwaddr 478 */ 479 if ((ip4_addr_cmp(&sipaddr, &autoip->llipaddr)) || 480 (ip4_addr_isany_val(sipaddr) && 481 ip4_addr_cmp(&dipaddr, &autoip->llipaddr) && 482 !eth_addr_cmp(&netifaddr, &hdr->shwaddr))) { 483 LWIP_DEBUGF(AUTOIP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE | LWIP_DBG_LEVEL_WARNING, 484 ("autoip_arp_reply(): Probe Conflict detected\n")); 485 autoip_restart(netif); 486 } 487 } else { 488 /* RFC 3927 Section 2.5: 489 * in any state we have a conflict if 490 * ip.src == llipaddr && hw.src != own hwaddr 491 */ 492 if (ip4_addr_cmp(&sipaddr, &autoip->llipaddr) && 493 !eth_addr_cmp(&netifaddr, &hdr->shwaddr)) { 494 LWIP_DEBUGF(AUTOIP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE | LWIP_DBG_LEVEL_WARNING, 495 ("autoip_arp_reply(): Conflicting ARP-Packet detected\n")); 496 autoip_handle_arp_conflict(netif); 497 } 498 } 499 } 500 } 501 502 /** check if AutoIP supplied netif->ip_addr 503 * 504 * @param netif the netif to check 505 * @return 1 if AutoIP supplied netif->ip_addr (state BOUND or ANNOUNCING), 506 * 0 otherwise 507 */ 508 u8_t 509 autoip_supplied_address(const struct netif *netif) 510 { 511 if ((netif != NULL) && (netif_autoip_data(netif) != NULL)) { 512 struct autoip* autoip = netif_autoip_data(netif); 513 return (autoip->state == AUTOIP_STATE_BOUND) || (autoip->state == AUTOIP_STATE_ANNOUNCING); 514 } 515 return 0; 516 } 517 518 u8_t 519 autoip_accept_packet(struct netif *netif, const ip4_addr_t *addr) 520 { 521 struct autoip* autoip = netif_autoip_data(netif); 522 return (autoip != NULL) && ip4_addr_cmp(addr, &(autoip->llipaddr)); 523 } 524 525 #endif /* LWIP_IPV4 && LWIP_AUTOIP */ 526