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 <stdlib.h>
72 #include <string.h>
73
74 /** Pseudo random macro based on netif informations.
75 * You could use "rand()" from the C Library if you define LWIP_AUTOIP_RAND in lwipopts.h */
76 #ifndef LWIP_AUTOIP_RAND
77 #define LWIP_AUTOIP_RAND(netif) ( (((u32_t)((netif->hwaddr[5]) & 0xff) << 24) | \
78 ((u32_t)((netif->hwaddr[3]) & 0xff) << 16) | \
79 ((u32_t)((netif->hwaddr[2]) & 0xff) << 8) | \
80 ((u32_t)((netif->hwaddr[4]) & 0xff))) + \
81 (netif_autoip_data(netif)? netif_autoip_data(netif)->tried_llipaddr : 0))
82 #endif /* LWIP_AUTOIP_RAND */
83
84 /**
85 * Macro that generates the initial IP address to be tried by AUTOIP.
86 * If you want to override this, define it to something else in lwipopts.h.
87 */
88 #ifndef LWIP_AUTOIP_CREATE_SEED_ADDR
89 #define LWIP_AUTOIP_CREATE_SEED_ADDR(netif) \
90 lwip_htonl(AUTOIP_RANGE_START + ((u32_t)(((u8_t)(netif->hwaddr[4])) | \
91 ((u32_t)((u8_t)(netif->hwaddr[5]))) << 8)))
92 #endif /* LWIP_AUTOIP_CREATE_SEED_ADDR */
93
94 /* static functions */
95 static err_t autoip_arp_announce(struct netif *netif);
96 static void autoip_start_probing(struct netif *netif);
97
98 #define netif_autoip_data(netif) ((struct autoip*)netif_get_client_data(netif, LWIP_NETIF_CLIENT_DATA_INDEX_AUTOIP))
99
100 /**
101 * @ingroup autoip
102 * Set a statically allocated struct autoip to work with.
103 * Using this prevents autoip_start to allocate it using mem_malloc.
104 *
105 * @param netif the netif for which to set the struct autoip
106 * @param autoip (uninitialised) autoip struct allocated by the application
107 */
108 void
autoip_set_struct(struct netif * netif,struct autoip * autoip)109 autoip_set_struct(struct netif *netif, struct autoip *autoip)
110 {
111 LWIP_ASSERT("netif != NULL", netif != NULL);
112 LWIP_ASSERT("autoip != NULL", autoip != NULL);
113 LWIP_ASSERT("netif already has a struct autoip set",
114 netif_autoip_data(netif) == NULL);
115
116 /* clear data structure */
117 memset(autoip, 0, sizeof(struct autoip));
118 /* autoip->state = AUTOIP_STATE_OFF; */
119 netif_set_client_data(netif, LWIP_NETIF_CLIENT_DATA_INDEX_AUTOIP, autoip);
120 }
121
122 /** Restart AutoIP client and check the next address (conflict detected)
123 *
124 * @param netif The netif under AutoIP control
125 */
126 static void
autoip_restart(struct netif * netif)127 autoip_restart(struct netif *netif)
128 {
129 struct autoip* autoip = netif_autoip_data(netif);
130 autoip->tried_llipaddr++;
131 autoip_start(netif);
132 }
133
134 /**
135 * Handle a IP address conflict after an ARP conflict detection
136 */
137 static void
autoip_handle_arp_conflict(struct netif * netif)138 autoip_handle_arp_conflict(struct netif *netif)
139 {
140 struct autoip* autoip = netif_autoip_data(netif);
141
142 /* RFC3927, 2.5 "Conflict Detection and Defense" allows two options where
143 a) means retreat on the first conflict and
144 b) allows to keep an already configured address when having only one
145 conflict in 10 seconds
146 We use option b) since it helps to improve the chance that one of the two
147 conflicting hosts may be able to retain its address. */
148
149 if (autoip->lastconflict > 0) {
150 /* retreat, there was a conflicting ARP in the last DEFEND_INTERVAL seconds */
151 LWIP_DEBUGF(AUTOIP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE,
152 ("autoip_handle_arp_conflict(): we are defending, but in DEFEND_INTERVAL, retreating\n"));
153
154 /* Active TCP sessions are aborted when removing the ip addresss */
155 autoip_restart(netif);
156 } else {
157 LWIP_DEBUGF(AUTOIP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE,
158 ("autoip_handle_arp_conflict(): we are defend, send ARP Announce\n"));
159 autoip_arp_announce(netif);
160 autoip->lastconflict = DEFEND_INTERVAL * AUTOIP_TICKS_PER_SECOND;
161 }
162 }
163
164 /**
165 * Create an IP-Address out of range 169.254.1.0 to 169.254.254.255
166 *
167 * @param netif network interface on which create the IP-Address
168 * @param ipaddr ip address to initialize
169 */
170 static void
autoip_create_addr(struct netif * netif,ip4_addr_t * ipaddr)171 autoip_create_addr(struct netif *netif, ip4_addr_t *ipaddr)
172 {
173 struct autoip* autoip = netif_autoip_data(netif);
174
175 /* Here we create an IP-Address out of range 169.254.1.0 to 169.254.254.255
176 * compliant to RFC 3927 Section 2.1
177 * We have 254 * 256 possibilities */
178
179 u32_t addr = lwip_ntohl(LWIP_AUTOIP_CREATE_SEED_ADDR(netif));
180 addr += autoip->tried_llipaddr;
181 addr = AUTOIP_NET | (addr & 0xffff);
182 /* Now, 169.254.0.0 <= addr <= 169.254.255.255 */
183
184 if (addr < AUTOIP_RANGE_START) {
185 addr += AUTOIP_RANGE_END - AUTOIP_RANGE_START + 1;
186 }
187 if (addr > AUTOIP_RANGE_END) {
188 addr -= AUTOIP_RANGE_END - AUTOIP_RANGE_START + 1;
189 }
190 LWIP_ASSERT("AUTOIP address not in range", (addr >= AUTOIP_RANGE_START) &&
191 (addr <= AUTOIP_RANGE_END));
192 ip4_addr_set_u32(ipaddr, lwip_htonl(addr));
193
194 LWIP_DEBUGF(AUTOIP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE,
195 ("autoip_create_addr(): tried_llipaddr=%"U16_F", %"U16_F".%"U16_F".%"U16_F".%"U16_F"\n",
196 (u16_t)(autoip->tried_llipaddr), ip4_addr1_16(ipaddr), ip4_addr2_16(ipaddr),
197 ip4_addr3_16(ipaddr), ip4_addr4_16(ipaddr)));
198 }
199
200 /**
201 * Sends an ARP probe from a network interface
202 *
203 * @param netif network interface used to send the probe
204 */
205 static err_t
autoip_arp_probe(struct netif * netif)206 autoip_arp_probe(struct netif *netif)
207 {
208 struct autoip* autoip = netif_autoip_data(netif);
209 /* this works because netif->ip_addr is ANY */
210 return etharp_request(netif, &autoip->llipaddr);
211 }
212
213 /**
214 * Sends an ARP announce from a network interface
215 *
216 * @param netif network interface used to send the announce
217 */
218 static err_t
autoip_arp_announce(struct netif * netif)219 autoip_arp_announce(struct netif *netif)
220 {
221 return etharp_gratuitous(netif);
222 }
223
224 /**
225 * Configure interface for use with current LL IP-Address
226 *
227 * @param netif network interface to configure with current LL IP-Address
228 */
229 static err_t
autoip_bind(struct netif * netif)230 autoip_bind(struct netif *netif)
231 {
232 struct autoip* autoip = netif_autoip_data(netif);
233 ip4_addr_t sn_mask, gw_addr;
234
235 LWIP_DEBUGF(AUTOIP_DEBUG | LWIP_DBG_TRACE,
236 ("autoip_bind(netif=%p) %c%c%"U16_F" %"U16_F".%"U16_F".%"U16_F".%"U16_F"\n",
237 (void*)netif, netif->name[0], netif->name[1], (u16_t)netif->num,
238 ip4_addr1_16(&autoip->llipaddr), ip4_addr2_16(&autoip->llipaddr),
239 ip4_addr3_16(&autoip->llipaddr), ip4_addr4_16(&autoip->llipaddr)));
240
241 IP4_ADDR(&sn_mask, 255, 255, 0, 0);
242 IP4_ADDR(&gw_addr, 0, 0, 0, 0);
243
244 netif_set_addr(netif, &autoip->llipaddr, &sn_mask, &gw_addr);
245 /* interface is used by routing now that an address is set */
246
247 return ERR_OK;
248 }
249
250 /**
251 * @ingroup autoip
252 * Start AutoIP client
253 *
254 * @param netif network interface on which start the AutoIP client
255 */
256 err_t
autoip_start(struct netif * netif)257 autoip_start(struct netif *netif)
258 {
259 struct autoip* autoip = netif_autoip_data(netif);
260 err_t result = ERR_OK;
261
262 LWIP_ERROR("netif is not up, old style port?", netif_is_up(netif), return ERR_ARG;);
263
264 /* Set IP-Address, Netmask and Gateway to 0 to make sure that
265 * ARP Packets are formed correctly
266 */
267 netif_set_addr(netif, IP4_ADDR_ANY4, IP4_ADDR_ANY4, IP4_ADDR_ANY4);
268
269 LWIP_DEBUGF(AUTOIP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE,
270 ("autoip_start(netif=%p) %c%c%"U16_F"\n", (void*)netif, netif->name[0],
271 netif->name[1], (u16_t)netif->num));
272 if (autoip == NULL) {
273 /* no AutoIP client attached yet? */
274 LWIP_DEBUGF(AUTOIP_DEBUG | LWIP_DBG_TRACE,
275 ("autoip_start(): starting new AUTOIP client\n"));
276 autoip = (struct autoip *)mem_malloc(sizeof(struct autoip));
277 if (autoip == NULL) {
278 LWIP_DEBUGF(AUTOIP_DEBUG | LWIP_DBG_TRACE,
279 ("autoip_start(): could not allocate autoip\n"));
280 return ERR_MEM;
281 }
282 memset(autoip, 0, sizeof(struct autoip));
283 /* store this AutoIP client in the netif */
284 netif_set_client_data(netif, LWIP_NETIF_CLIENT_DATA_INDEX_AUTOIP, autoip);
285 LWIP_DEBUGF(AUTOIP_DEBUG | LWIP_DBG_TRACE, ("autoip_start(): allocated autoip"));
286 } else {
287 autoip->state = AUTOIP_STATE_OFF;
288 autoip->ttw = 0;
289 autoip->sent_num = 0;
290 ip4_addr_set_zero(&autoip->llipaddr);
291 autoip->lastconflict = 0;
292 }
293
294 autoip_create_addr(netif, &(autoip->llipaddr));
295 autoip_start_probing(netif);
296
297 return result;
298 }
299
300 static void
autoip_start_probing(struct netif * netif)301 autoip_start_probing(struct netif *netif)
302 {
303 struct autoip* autoip = netif_autoip_data(netif);
304
305 autoip->state = AUTOIP_STATE_PROBING;
306 autoip->sent_num = 0;
307 LWIP_DEBUGF(AUTOIP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE,
308 ("autoip_start_probing(): changing state to PROBING: %"U16_F".%"U16_F".%"U16_F".%"U16_F"\n",
309 ip4_addr1_16(&autoip->llipaddr), ip4_addr2_16(&autoip->llipaddr),
310 ip4_addr3_16(&autoip->llipaddr), ip4_addr4_16(&autoip->llipaddr)));
311
312 /* time to wait to first probe, this is randomly
313 * chosen out of 0 to PROBE_WAIT seconds.
314 * compliant to RFC 3927 Section 2.2.1
315 */
316 autoip->ttw = (u16_t)(LWIP_AUTOIP_RAND(netif) % (PROBE_WAIT * AUTOIP_TICKS_PER_SECOND));
317
318 /*
319 * if we tried more then MAX_CONFLICTS we must limit our rate for
320 * acquiring and probing address
321 * compliant to RFC 3927 Section 2.2.1
322 */
323 if (autoip->tried_llipaddr > MAX_CONFLICTS) {
324 autoip->ttw = RATE_LIMIT_INTERVAL * AUTOIP_TICKS_PER_SECOND;
325 }
326 }
327
328 /**
329 * Handle a possible change in the network configuration.
330 *
331 * If there is an AutoIP address configured, take the interface down
332 * and begin probing with the same address.
333 */
334 void
autoip_network_changed(struct netif * netif)335 autoip_network_changed(struct netif *netif)
336 {
337 struct autoip* autoip = netif_autoip_data(netif);
338
339 if (autoip && (autoip->state != AUTOIP_STATE_OFF)) {
340 autoip_start_probing(netif);
341 }
342 }
343
344 /**
345 * @ingroup autoip
346 * Stop AutoIP client
347 *
348 * @param netif network interface on which stop the AutoIP client
349 */
350 err_t
autoip_stop(struct netif * netif)351 autoip_stop(struct netif *netif)
352 {
353 struct autoip* autoip = netif_autoip_data(netif);
354
355 if (autoip != NULL) {
356 autoip->state = AUTOIP_STATE_OFF;
357 if (ip4_addr_islinklocal(netif_ip4_addr(netif))) {
358 netif_set_addr(netif, IP4_ADDR_ANY4, IP4_ADDR_ANY4, IP4_ADDR_ANY4);
359 }
360 }
361 return ERR_OK;
362 }
363
364 /**
365 * Has to be called in loop every AUTOIP_TMR_INTERVAL milliseconds
366 */
367 void
autoip_tmr(void)368 autoip_tmr(void)
369 {
370 struct netif *netif = netif_list;
371 /* loop through netif's */
372 while (netif != NULL) {
373 struct autoip* autoip = netif_autoip_data(netif);
374 /* only act on AutoIP configured interfaces */
375 if (autoip != NULL) {
376 if (autoip->lastconflict > 0) {
377 autoip->lastconflict--;
378 }
379
380 LWIP_DEBUGF(AUTOIP_DEBUG | LWIP_DBG_TRACE,
381 ("autoip_tmr() AutoIP-State: %"U16_F", ttw=%"U16_F"\n",
382 (u16_t)(autoip->state), autoip->ttw));
383
384 if (autoip->ttw > 0) {
385 autoip->ttw--;
386 }
387
388 switch(autoip->state) {
389 case AUTOIP_STATE_PROBING:
390 if (autoip->ttw == 0) {
391 if (autoip->sent_num >= PROBE_NUM) {
392 /* Switch to ANNOUNCING: now we can bind to an IP address and use it */
393 autoip->state = AUTOIP_STATE_ANNOUNCING;
394 autoip_bind(netif);
395 /* autoip_bind() calls netif_set_addr(): this triggers a gratuitous ARP
396 which counts as an announcement */
397 autoip->sent_num = 1;
398 autoip->ttw = ANNOUNCE_WAIT * AUTOIP_TICKS_PER_SECOND;
399 LWIP_DEBUGF(AUTOIP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE,
400 ("autoip_tmr(): changing state to ANNOUNCING: %"U16_F".%"U16_F".%"U16_F".%"U16_F"\n",
401 ip4_addr1_16(&autoip->llipaddr), ip4_addr2_16(&autoip->llipaddr),
402 ip4_addr3_16(&autoip->llipaddr), ip4_addr4_16(&autoip->llipaddr)));
403 } else {
404 autoip_arp_probe(netif);
405 LWIP_DEBUGF(AUTOIP_DEBUG | LWIP_DBG_TRACE, ("autoip_tmr() PROBING Sent Probe\n"));
406 autoip->sent_num++;
407 if (autoip->sent_num == PROBE_NUM) {
408 /* calculate time to wait to for announce */
409 autoip->ttw = ANNOUNCE_WAIT * AUTOIP_TICKS_PER_SECOND;
410 } else {
411 /* calculate time to wait to next probe */
412 autoip->ttw = (u16_t)((LWIP_AUTOIP_RAND(netif) %
413 ((PROBE_MAX - PROBE_MIN) * AUTOIP_TICKS_PER_SECOND) ) +
414 PROBE_MIN * AUTOIP_TICKS_PER_SECOND);
415 }
416 }
417 }
418 break;
419
420 case AUTOIP_STATE_ANNOUNCING:
421 if (autoip->ttw == 0) {
422 autoip_arp_announce(netif);
423 LWIP_DEBUGF(AUTOIP_DEBUG | LWIP_DBG_TRACE, ("autoip_tmr() ANNOUNCING Sent Announce\n"));
424 autoip->ttw = ANNOUNCE_INTERVAL * AUTOIP_TICKS_PER_SECOND;
425 autoip->sent_num++;
426
427 if (autoip->sent_num >= ANNOUNCE_NUM) {
428 autoip->state = AUTOIP_STATE_BOUND;
429 autoip->sent_num = 0;
430 autoip->ttw = 0;
431 LWIP_DEBUGF(AUTOIP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE,
432 ("autoip_tmr(): changing state to BOUND: %"U16_F".%"U16_F".%"U16_F".%"U16_F"\n",
433 ip4_addr1_16(&autoip->llipaddr), ip4_addr2_16(&autoip->llipaddr),
434 ip4_addr3_16(&autoip->llipaddr), ip4_addr4_16(&autoip->llipaddr)));
435 }
436 }
437 break;
438
439 default:
440 /* nothing to do in other states */
441 break;
442 }
443 }
444 /* proceed to next network interface */
445 netif = netif->next;
446 }
447 }
448
449 /**
450 * Handles every incoming ARP Packet, called by etharp_input().
451 *
452 * @param netif network interface to use for autoip processing
453 * @param hdr Incoming ARP packet
454 */
455 void
autoip_arp_reply(struct netif * netif,struct etharp_hdr * hdr)456 autoip_arp_reply(struct netif *netif, struct etharp_hdr *hdr)
457 {
458 struct autoip* autoip = netif_autoip_data(netif);
459
460 LWIP_DEBUGF(AUTOIP_DEBUG | LWIP_DBG_TRACE, ("autoip_arp_reply()\n"));
461 if ((autoip != NULL) && (autoip->state != AUTOIP_STATE_OFF)) {
462 /* when ip.src == llipaddr && hw.src != netif->hwaddr
463 *
464 * when probing ip.dst == llipaddr && hw.src != netif->hwaddr
465 * we have a conflict and must solve it
466 */
467 ip4_addr_t sipaddr, dipaddr;
468 struct eth_addr netifaddr;
469 ETHADDR16_COPY(netifaddr.addr, netif->hwaddr);
470
471 /* Copy struct ip4_addr2 to aligned ip4_addr, to support compilers without
472 * structure packing (not using structure copy which breaks strict-aliasing rules).
473 */
474 IPADDR2_COPY(&sipaddr, &hdr->sipaddr);
475 IPADDR2_COPY(&dipaddr, &hdr->dipaddr);
476
477 if (autoip->state == AUTOIP_STATE_PROBING) {
478 /* RFC 3927 Section 2.2.1:
479 * from beginning to after ANNOUNCE_WAIT
480 * seconds we have a conflict if
481 * ip.src == llipaddr OR
482 * ip.dst == llipaddr && hw.src != own hwaddr
483 */
484 if ((ip4_addr_cmp(&sipaddr, &autoip->llipaddr)) ||
485 (ip4_addr_cmp(&dipaddr, &autoip->llipaddr) &&
486 !eth_addr_cmp(&netifaddr, &hdr->shwaddr))) {
487 LWIP_DEBUGF(AUTOIP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE | LWIP_DBG_LEVEL_WARNING,
488 ("autoip_arp_reply(): Probe Conflict detected\n"));
489 autoip_restart(netif);
490 }
491 } else {
492 /* RFC 3927 Section 2.5:
493 * in any state we have a conflict if
494 * ip.src == llipaddr && hw.src != own hwaddr
495 */
496 if (ip4_addr_cmp(&sipaddr, &autoip->llipaddr) &&
497 !eth_addr_cmp(&netifaddr, &hdr->shwaddr)) {
498 LWIP_DEBUGF(AUTOIP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE | LWIP_DBG_LEVEL_WARNING,
499 ("autoip_arp_reply(): Conflicting ARP-Packet detected\n"));
500 autoip_handle_arp_conflict(netif);
501 }
502 }
503 }
504 }
505
506 /** check if AutoIP supplied netif->ip_addr
507 *
508 * @param netif the netif to check
509 * @return 1 if AutoIP supplied netif->ip_addr (state BOUND or ANNOUNCING),
510 * 0 otherwise
511 */
512 u8_t
autoip_supplied_address(const struct netif * netif)513 autoip_supplied_address(const struct netif *netif)
514 {
515 if ((netif != NULL) && (netif_autoip_data(netif) != NULL)) {
516 struct autoip* autoip = netif_autoip_data(netif);
517 return (autoip->state == AUTOIP_STATE_BOUND) || (autoip->state == AUTOIP_STATE_ANNOUNCING);
518 }
519 return 0;
520 }
521
522 u8_t
autoip_accept_packet(struct netif * netif,const ip4_addr_t * addr)523 autoip_accept_packet(struct netif *netif, const ip4_addr_t *addr)
524 {
525 struct autoip* autoip = netif_autoip_data(netif);
526 return (autoip != NULL) && ip4_addr_cmp(addr, &(autoip->llipaddr));
527 }
528
529 #endif /* LWIP_IPV4 && LWIP_AUTOIP */
530