00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030
00031
00032
00033
00034
00035
00036
00037
00038
00039
00040
00041
00042
00043
00044
00045
00046
00047
00048
00049
00050
00051
00052
00053
00054
00055
00056
00057
00058
00059
00060
00061
00062
00063
00064
00065 #include "lwip/opt.h"
00066
00067 #if LWIP_AUTOIP
00068
00069 #include "lwip/mem.h"
00070 #include "lwip/udp.h"
00071 #include "lwip/ip_addr.h"
00072 #include "lwip/netif.h"
00073 #include "lwip/autoip.h"
00074 #include "netif/etharp.h"
00075
00076 #include <stdlib.h>
00077 #include <string.h>
00078
00079
00080 #define AUTOIP_NET 0xA9FE0000
00081
00082 #define AUTOIP_RANGE_START (AUTOIP_NET | 0x0100)
00083
00084 #define AUTOIP_RANGE_END (AUTOIP_NET | 0xFEFF)
00085
00086
00087
00088
00089 #ifndef LWIP_AUTOIP_RAND
00090 #define LWIP_AUTOIP_RAND(netif) ( (((u32_t)((netif->hwaddr[5]) & 0xff) << 24) | \
00091 ((u32_t)((netif->hwaddr[3]) & 0xff) << 16) | \
00092 ((u32_t)((netif->hwaddr[2]) & 0xff) << 8) | \
00093 ((u32_t)((netif->hwaddr[4]) & 0xff))) + \
00094 (netif->autoip?netif->autoip->tried_llipaddr:0))
00095 #endif
00096
00097
00098
00099
00100
00101 #ifndef LWIP_AUTOIP_CREATE_SEED_ADDR
00102 #define LWIP_AUTOIP_CREATE_SEED_ADDR(netif) \
00103 htonl(AUTOIP_RANGE_START + ((u32_t)(((u8_t)(netif->hwaddr[4])) | \
00104 ((u32_t)((u8_t)(netif->hwaddr[5]))) << 8)))
00105 #endif
00106
00107
00108 static void autoip_handle_arp_conflict(struct netif *netif);
00109
00110
00111 static void autoip_create_addr(struct netif *netif, struct ip_addr *ipaddr);
00112
00113
00114 static err_t autoip_arp_probe(struct netif *netif);
00115
00116
00117 static err_t autoip_arp_announce(struct netif *netif);
00118
00119
00120 static err_t autoip_bind(struct netif *netif);
00121
00122
00123 static void autoip_start_probing(struct netif *netif);
00124
00125
00126
00127
00128 void
00129 autoip_init(void)
00130 {
00131 LWIP_DEBUGF(AUTOIP_DEBUG | LWIP_DBG_TRACE, ("autoip_init()\n"));
00132 }
00133
00134
00135
00136
00137 static void
00138 autoip_handle_arp_conflict(struct netif *netif)
00139 {
00140
00141 unsigned char defend = 1;
00142
00143 if(defend) {
00144 if(netif->autoip->lastconflict > 0) {
00145
00146
00147
00148 LWIP_DEBUGF(AUTOIP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE,
00149 ("autoip_handle_arp_conflict(): we are defending, but in DEFEND_INTERVAL, retreating\n"));
00150
00151
00152 autoip_start(netif);
00153 } else {
00154 LWIP_DEBUGF(AUTOIP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE,
00155 ("autoip_handle_arp_conflict(): we are defend, send ARP Announce\n"));
00156 autoip_arp_announce(netif);
00157 netif->autoip->lastconflict = DEFEND_INTERVAL * AUTOIP_TICKS_PER_SECOND;
00158 }
00159 } else {
00160 LWIP_DEBUGF(AUTOIP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE,
00161 ("autoip_handle_arp_conflict(): we do not defend, retreating\n"));
00162
00163 autoip_start(netif);
00164 }
00165 }
00166
00167
00168
00169
00170
00171
00172
00173 static void
00174 autoip_create_addr(struct netif *netif, struct ip_addr *ipaddr)
00175 {
00176
00177
00178
00179
00180 u32_t addr = ntohl(LWIP_AUTOIP_CREATE_SEED_ADDR(netif));
00181 addr += netif->autoip->tried_llipaddr;
00182 addr = AUTOIP_NET | (addr & 0xffff);
00183
00184
00185 if (addr < AUTOIP_RANGE_START) {
00186 addr += AUTOIP_RANGE_END - AUTOIP_RANGE_START + 1;
00187 }
00188 if (addr > AUTOIP_RANGE_END) {
00189 addr -= AUTOIP_RANGE_END - AUTOIP_RANGE_START + 1;
00190 }
00191 LWIP_ASSERT("AUTOIP address not in range", (addr >= AUTOIP_RANGE_START) &&
00192 (addr <= AUTOIP_RANGE_END));
00193 ipaddr->addr = htonl(addr);
00194
00195 LWIP_DEBUGF(AUTOIP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE,
00196 ("autoip_create_addr(): tried_llipaddr=%"U16_F", 0x%08"X32_F"\n",
00197 (u16_t)(netif->autoip->tried_llipaddr), (u32_t)(ipaddr->addr)));
00198 }
00199
00200
00201
00202
00203
00204
00205 static err_t
00206 autoip_arp_probe(struct netif *netif)
00207 {
00208 return etharp_raw(netif, (struct eth_addr *)netif->hwaddr, ðbroadcast,
00209 (struct eth_addr *)netif->hwaddr, IP_ADDR_ANY, ðzero,
00210 &netif->autoip->llipaddr, ARP_REQUEST);
00211 }
00212
00213
00214
00215
00216
00217
00218 static err_t
00219 autoip_arp_announce(struct netif *netif)
00220 {
00221 return etharp_raw(netif, (struct eth_addr *)netif->hwaddr, ðbroadcast,
00222 (struct eth_addr *)netif->hwaddr, &netif->autoip->llipaddr, ðzero,
00223 &netif->autoip->llipaddr, ARP_REQUEST);
00224 }
00225
00226
00227
00228
00229
00230
00231 static err_t
00232 autoip_bind(struct netif *netif)
00233 {
00234 struct autoip *autoip = netif->autoip;
00235 struct ip_addr sn_mask, gw_addr;
00236
00237 LWIP_DEBUGF(AUTOIP_DEBUG | LWIP_DBG_TRACE,
00238 ("autoip_bind(netif=%p) %c%c%"U16_F" 0x%08"X32_F"\n",
00239 (void*)netif, netif->name[0], netif->name[1], (u16_t)netif->num, autoip->llipaddr.addr));
00240
00241 IP4_ADDR(&sn_mask, 255, 255, 0, 0);
00242 IP4_ADDR(&gw_addr, 0, 0, 0, 0);
00243
00244 netif_set_ipaddr(netif, &autoip->llipaddr);
00245 netif_set_netmask(netif, &sn_mask);
00246 netif_set_gw(netif, &gw_addr);
00247
00248
00249 netif_set_up(netif);
00250
00251 return ERR_OK;
00252 }
00253
00254
00255
00256
00257
00258
00259 err_t
00260 autoip_start(struct netif *netif)
00261 {
00262 struct autoip *autoip = netif->autoip;
00263 err_t result = ERR_OK;
00264
00265 if(netif_is_up(netif)) {
00266 netif_set_down(netif);
00267 }
00268
00269
00270
00271
00272 netif->ip_addr.addr = 0;
00273 netif->netmask.addr = 0;
00274 netif->gw.addr = 0;
00275
00276 LWIP_DEBUGF(AUTOIP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE,
00277 ("autoip_start(netif=%p) %c%c%"U16_F"\n", (void*)netif, netif->name[0],
00278 netif->name[1], (u16_t)netif->num));
00279 if(autoip == NULL) {
00280
00281 LWIP_DEBUGF(AUTOIP_DEBUG | LWIP_DBG_TRACE,
00282 ("autoip_start(): starting new AUTOIP client\n"));
00283 autoip = mem_malloc(sizeof(struct autoip));
00284 if(autoip == NULL) {
00285 LWIP_DEBUGF(AUTOIP_DEBUG | LWIP_DBG_TRACE,
00286 ("autoip_start(): could not allocate autoip\n"));
00287 return ERR_MEM;
00288 }
00289 memset( autoip, 0, sizeof(struct autoip));
00290
00291 netif->autoip = autoip;
00292 LWIP_DEBUGF(AUTOIP_DEBUG | LWIP_DBG_TRACE, ("autoip_start(): allocated autoip"));
00293 } else {
00294 autoip->state = AUTOIP_STATE_OFF;
00295 autoip->ttw = 0;
00296 autoip->sent_num = 0;
00297 memset(&autoip->llipaddr, 0, sizeof(struct ip_addr));
00298 autoip->lastconflict = 0;
00299 }
00300
00301 autoip_create_addr(netif, &(autoip->llipaddr));
00302 autoip->tried_llipaddr++;
00303 autoip_start_probing(netif);
00304
00305 return result;
00306 }
00307
00308 static void
00309 autoip_start_probing(struct netif *netif)
00310 {
00311 struct autoip *autoip = netif->autoip;
00312
00313 autoip->state = AUTOIP_STATE_PROBING;
00314 autoip->sent_num = 0;
00315
00316
00317
00318
00319
00320 autoip->ttw = (u16_t)(LWIP_AUTOIP_RAND(netif) % (PROBE_WAIT * AUTOIP_TICKS_PER_SECOND));
00321
00322
00323
00324
00325
00326
00327 if(autoip->tried_llipaddr > MAX_CONFLICTS) {
00328 autoip->ttw = RATE_LIMIT_INTERVAL * AUTOIP_TICKS_PER_SECOND;
00329 }
00330 }
00331
00332
00333
00334
00335
00336
00337
00338 void
00339 autoip_network_changed(struct netif *netif)
00340 {
00341 if (netif->autoip && netif->autoip->state != AUTOIP_STATE_OFF) {
00342 netif_set_down(netif);
00343 autoip_start_probing(netif);
00344 }
00345 }
00346
00347
00348
00349
00350
00351
00352 err_t
00353 autoip_stop(struct netif *netif)
00354 {
00355 netif->autoip->state = AUTOIP_STATE_OFF;
00356 netif_set_down(netif);
00357 return ERR_OK;
00358 }
00359
00360
00361
00362
00363 void
00364 autoip_tmr()
00365 {
00366 struct netif *netif = netif_list;
00367
00368 while (netif != NULL) {
00369
00370 if (netif->autoip != NULL) {
00371 if(netif->autoip->lastconflict > 0) {
00372 netif->autoip->lastconflict--;
00373 }
00374
00375 LWIP_DEBUGF(AUTOIP_DEBUG | LWIP_DBG_TRACE,
00376 ("autoip_tmr() AutoIP-State: %"U16_F", ttw=%"U16_F"\n",
00377 (u16_t)(netif->autoip->state), netif->autoip->ttw));
00378
00379 switch(netif->autoip->state) {
00380 case AUTOIP_STATE_PROBING:
00381 if(netif->autoip->ttw > 0) {
00382 netif->autoip->ttw--;
00383 } else {
00384 if(netif->autoip->sent_num >= PROBE_NUM) {
00385 netif->autoip->state = AUTOIP_STATE_ANNOUNCING;
00386 netif->autoip->sent_num = 0;
00387 netif->autoip->ttw = ANNOUNCE_WAIT * AUTOIP_TICKS_PER_SECOND;
00388 } else {
00389 autoip_arp_probe(netif);
00390 LWIP_DEBUGF(AUTOIP_DEBUG | LWIP_DBG_TRACE,
00391 ("autoip_tmr() PROBING Sent Probe\n"));
00392 netif->autoip->sent_num++;
00393
00394 netif->autoip->ttw = (u16_t)((LWIP_AUTOIP_RAND(netif) %
00395 ((PROBE_MAX - PROBE_MIN) * AUTOIP_TICKS_PER_SECOND) ) +
00396 PROBE_MIN * AUTOIP_TICKS_PER_SECOND);
00397 }
00398 }
00399 break;
00400
00401 case AUTOIP_STATE_ANNOUNCING:
00402 if(netif->autoip->ttw > 0) {
00403 netif->autoip->ttw--;
00404 } else {
00405 if(netif->autoip->sent_num == 0) {
00406
00407
00408
00409
00410
00411
00412 autoip_bind(netif);
00413 } else {
00414 autoip_arp_announce(netif);
00415 LWIP_DEBUGF(AUTOIP_DEBUG | LWIP_DBG_TRACE,
00416 ("autoip_tmr() ANNOUNCING Sent Announce\n"));
00417 }
00418 netif->autoip->ttw = ANNOUNCE_INTERVAL * AUTOIP_TICKS_PER_SECOND;
00419 netif->autoip->sent_num++;
00420
00421 if(netif->autoip->sent_num >= ANNOUNCE_NUM) {
00422 netif->autoip->state = AUTOIP_STATE_BOUND;
00423 netif->autoip->sent_num = 0;
00424 netif->autoip->ttw = 0;
00425 }
00426 }
00427 break;
00428 }
00429 }
00430
00431 netif = netif->next;
00432 }
00433 }
00434
00435
00436
00437
00438
00439
00440
00441 void
00442 autoip_arp_reply(struct netif *netif, struct etharp_hdr *hdr)
00443 {
00444 LWIP_DEBUGF(AUTOIP_DEBUG | LWIP_DBG_TRACE, ("autoip_arp_reply()\n"));
00445 if ((netif->autoip != NULL) && (netif->autoip->state != AUTOIP_STATE_OFF)) {
00446
00447
00448
00449
00450
00451 struct ip_addr sipaddr, dipaddr;
00452 struct eth_addr netifaddr;
00453 netifaddr.addr[0] = netif->hwaddr[0];
00454 netifaddr.addr[1] = netif->hwaddr[1];
00455 netifaddr.addr[2] = netif->hwaddr[2];
00456 netifaddr.addr[3] = netif->hwaddr[3];
00457 netifaddr.addr[4] = netif->hwaddr[4];
00458 netifaddr.addr[5] = netif->hwaddr[5];
00459
00460
00461
00462
00463 SMEMCPY(&sipaddr, &hdr->sipaddr, sizeof(sipaddr));
00464 SMEMCPY(&dipaddr, &hdr->dipaddr, sizeof(dipaddr));
00465
00466 if ((netif->autoip->state == AUTOIP_STATE_PROBING) ||
00467 ((netif->autoip->state == AUTOIP_STATE_ANNOUNCING) &&
00468 (netif->autoip->sent_num == 0))) {
00469
00470
00471
00472
00473
00474
00475 if ((ip_addr_cmp(&sipaddr, &netif->autoip->llipaddr)) ||
00476 (ip_addr_cmp(&dipaddr, &netif->autoip->llipaddr) &&
00477 !eth_addr_cmp(&netifaddr, &hdr->shwaddr))) {
00478 LWIP_DEBUGF(AUTOIP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE | LWIP_DBG_LEVEL_WARNING,
00479 ("autoip_arp_reply(): Probe Conflict detected\n"));
00480 autoip_start(netif);
00481 }
00482 } else {
00483
00484
00485
00486
00487 if (ip_addr_cmp(&sipaddr, &netif->autoip->llipaddr) &&
00488 !eth_addr_cmp(&netifaddr, &hdr->shwaddr)) {
00489 LWIP_DEBUGF(AUTOIP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE | LWIP_DBG_LEVEL_WARNING,
00490 ("autoip_arp_reply(): Conflicting ARP-Packet detected\n"));
00491 autoip_handle_arp_conflict(netif);
00492 }
00493 }
00494 }
00495 }
00496
00497 #endif