third_party/lwip/repo/lwip/src/core/ipv4/autoip.c

   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_CORE_LOCKED();
 109   LWIP_ASSERT("netif != NULL", netif != NULL);
 110   LWIP_ASSERT("autoip != NULL", autoip != NULL);
 111   LWIP_ASSERT("netif already has a struct autoip set",
 112               netif_autoip_data(netif) == NULL);
 113
 114   /* clear data structure */
 115   memset(autoip, 0, sizeof(struct autoip));
 116   /* autoip->state = AUTOIP_STATE_OFF; */
 117   netif_set_client_data(netif, LWIP_NETIF_CLIENT_DATA_INDEX_AUTOIP, autoip);
 118 }
 119
 120 /** Restart AutoIP client and check the next address (conflict detected)
 121  *
 122  * @param netif The netif under AutoIP control
 123  */
 124 static void
 125 autoip_restart(struct netif *netif)
 126 {
 127   struct autoip* autoip = netif_autoip_data(netif);
 128   autoip->tried_llipaddr++;
 129   autoip_start(netif);
 130 }
 131
 132 /**
 133  * Handle a IP address conflict after an ARP conflict detection
 134  */
 135 static void
 136 autoip_handle_arp_conflict(struct netif *netif)
 137 {
 138   struct autoip* autoip = netif_autoip_data(netif);
 139
 140   /* RFC3927, 2.5 "Conflict Detection and Defense" allows two options where
 141      a) means retreat on the first conflict and
 142      b) allows to keep an already configured address when having only one
 143         conflict in 10 seconds
 144      We use option b) since it helps to improve the chance that one of the two
 145      conflicting hosts may be able to retain its address. */
 146
 147   if (autoip->lastconflict > 0) {
 148     /* retreat, there was a conflicting ARP in the last DEFEND_INTERVAL seconds */
 149     LWIP_DEBUGF(AUTOIP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE,
 150       ("autoip_handle_arp_conflict(): we are defending, but in DEFEND_INTERVAL, retreating\n"));
 151
 152     /* Active TCP sessions are aborted when removing the ip addresss */
 153     autoip_restart(netif);
 154   } else {
 155     LWIP_DEBUGF(AUTOIP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE,
 156       ("autoip_handle_arp_conflict(): we are defend, send ARP Announce\n"));
 157     autoip_arp_announce(netif);
 158     autoip->lastconflict = DEFEND_INTERVAL * AUTOIP_TICKS_PER_SECOND;
 159   }
 160 }
 161
 162 /**
 163  * Create an IP-Address out of range 169.254.1.0 to 169.254.254.255
 164  *
 165  * @param netif network interface on which create the IP-Address
 166  * @param ipaddr ip address to initialize
 167  */
 168 static void
 169 autoip_create_addr(struct netif *netif, ip4_addr_t *ipaddr)
 170 {
 171   struct autoip* autoip = netif_autoip_data(netif);
 172
 173   /* Here we create an IP-Address out of range 169.254.1.0 to 169.254.254.255
 174    * compliant to RFC 3927 Section 2.1
 175    * We have 254 * 256 possibilities */
 176
 177   u32_t addr = lwip_ntohl(LWIP_AUTOIP_CREATE_SEED_ADDR(netif));
 178   addr += autoip->tried_llipaddr;
 179   addr = AUTOIP_NET | (addr & 0xffff);
 180   /* Now, 169.254.0.0 <= addr <= 169.254.255.255 */
 181
 182   if (addr < AUTOIP_RANGE_START) {
 183     addr += AUTOIP_RANGE_END - AUTOIP_RANGE_START + 1;
 184   }
 185   if (addr > AUTOIP_RANGE_END) {
 186     addr -= AUTOIP_RANGE_END - AUTOIP_RANGE_START + 1;
 187   }
 188   LWIP_ASSERT("AUTOIP address not in range", (addr >= AUTOIP_RANGE_START) &&
 189     (addr <= AUTOIP_RANGE_END));
 190   ip4_addr_set_u32(ipaddr, lwip_htonl(addr));
 191
 192   LWIP_DEBUGF(AUTOIP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE,
 193     ("autoip_create_addr(): tried_llipaddr=%"U16_F", %"U16_F".%"U16_F".%"U16_F".%"U16_F"\n",
 194     (u16_t)(autoip->tried_llipaddr), ip4_addr1_16(ipaddr), ip4_addr2_16(ipaddr),
 195     ip4_addr3_16(ipaddr), ip4_addr4_16(ipaddr)));
 196 }
 197
 198 /**
 199  * Sends an ARP probe from a network interface
 200  *
 201  * @param netif network interface used to send the probe
 202  */
 203 static err_t
 204 autoip_arp_probe(struct netif *netif)
 205 {
 206   struct autoip* autoip = netif_autoip_data(netif);
 207   /* this works because netif->ip_addr is ANY */
 208   return etharp_request(netif, &autoip->llipaddr);
 209 }
 210
 211 /**
 212  * Sends an ARP announce from a network interface
 213  *
 214  * @param netif network interface used to send the announce
 215  */
 216 static err_t
 217 autoip_arp_announce(struct netif *netif)
 218 {
 219   return etharp_gratuitous(netif);
 220 }
 221
 222 /**
 223  * Configure interface for use with current LL IP-Address
 224  *
 225  * @param netif network interface to configure with current LL IP-Address
 226  */
 227 static err_t
 228 autoip_bind(struct netif *netif)
 229 {
 230   struct autoip* autoip = netif_autoip_data(netif);
 231   ip4_addr_t sn_mask, gw_addr;
 232
 233   LWIP_DEBUGF(AUTOIP_DEBUG | LWIP_DBG_TRACE,
 234     ("autoip_bind(netif=%p) %c%c%"U16_F" %"U16_F".%"U16_F".%"U16_F".%"U16_F"\n",
 235     (void*)netif, netif->name[0], netif->name[1], (u16_t)netif->num,
 236     ip4_addr1_16(&autoip->llipaddr), ip4_addr2_16(&autoip->llipaddr),
 237     ip4_addr3_16(&autoip->llipaddr), ip4_addr4_16(&autoip->llipaddr)));
 238
 239   IP4_ADDR(&sn_mask, 255, 255, 0, 0);
 240   IP4_ADDR(&gw_addr, 0, 0, 0, 0);
 241
 242   netif_set_addr(netif, &autoip->llipaddr, &sn_mask, &gw_addr);
 243   /* interface is used by routing now that an address is set */
 244
 245   return ERR_OK;
 246 }
 247
 248 /**
 249  * @ingroup autoip
 250  * Start AutoIP client
 251  *
 252  * @param netif network interface on which start the AutoIP client
 253  */
 254 err_t
 255 autoip_start(struct netif *netif)
 256 {
 257   struct autoip* autoip = netif_autoip_data(netif);
 258   err_t result = ERR_OK;
 259
 260   LWIP_ASSERT_CORE_LOCKED();
 261   LWIP_ERROR("netif is not up, old style port?", netif_is_up(netif), return ERR_ARG;);
 262
 263   /* Set IP-Address, Netmask and Gateway to 0 to make sure that
 264    * ARP Packets are formed correctly
 265    */
 266   netif_set_addr(netif, IP4_ADDR_ANY4, IP4_ADDR_ANY4, IP4_ADDR_ANY4);
 267
 268   LWIP_DEBUGF(AUTOIP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE,
 269     ("autoip_start(netif=%p) %c%c%"U16_F"\n", (void*)netif, netif->name[0],
 270     netif->name[1], (u16_t)netif->num));
 271   if (autoip == NULL) {
 272     /* no AutoIP client attached yet? */
 273     LWIP_DEBUGF(AUTOIP_DEBUG | LWIP_DBG_TRACE,
 274       ("autoip_start(): starting new AUTOIP client\n"));
 275     autoip = (struct autoip *)mem_malloc(sizeof(struct autoip));
 276     if (autoip == NULL) {
 277       LWIP_DEBUGF(AUTOIP_DEBUG | LWIP_DBG_TRACE,
 278         ("autoip_start(): could not allocate autoip\n"));
 279       return ERR_MEM;
 280     }
 281     memset(autoip, 0, sizeof(struct autoip));
 282     /* store this AutoIP client in the netif */
 283     netif_set_client_data(netif, LWIP_NETIF_CLIENT_DATA_INDEX_AUTOIP, autoip);
 284     LWIP_DEBUGF(AUTOIP_DEBUG | LWIP_DBG_TRACE, ("autoip_start(): allocated autoip"));
 285   } else {
 286     autoip->state = AUTOIP_STATE_OFF;
 287     autoip->ttw = 0;
 288     autoip->sent_num = 0;
 289     ip4_addr_set_zero(&autoip->llipaddr);
 290     autoip->lastconflict = 0;
 291   }
 292
 293   autoip_create_addr(netif, &(autoip->llipaddr));
 294   autoip_start_probing(netif);
 295
 296   return result;
 297 }
 298
 299 static void
 300 autoip_start_probing(struct netif *netif)
 301 {
 302   struct autoip* autoip = netif_autoip_data(netif);
 303
 304   autoip->state = AUTOIP_STATE_PROBING;
 305   autoip->sent_num = 0;
 306   LWIP_DEBUGF(AUTOIP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE,
 307      ("autoip_start_probing(): changing state to PROBING: %"U16_F".%"U16_F".%"U16_F".%"U16_F"\n",
 308       ip4_addr1_16(&autoip->llipaddr), ip4_addr2_16(&autoip->llipaddr),
 309       ip4_addr3_16(&autoip->llipaddr), ip4_addr4_16(&autoip->llipaddr)));
 310
 311   /* time to wait to first probe, this is randomly
 312    * chosen out of 0 to PROBE_WAIT seconds.
 313    * compliant to RFC 3927 Section 2.2.1
 314    */
 315   autoip->ttw = (u16_t)(LWIP_AUTOIP_RAND(netif) % (PROBE_WAIT * AUTOIP_TICKS_PER_SECOND));
 316
 317   /*
 318    * if we tried more then MAX_CONFLICTS we must limit our rate for
 319    * acquiring and probing address
 320    * compliant to RFC 3927 Section 2.2.1
 321    */
 322   if (autoip->tried_llipaddr > MAX_CONFLICTS) {
 323     autoip->ttw = RATE_LIMIT_INTERVAL * AUTOIP_TICKS_PER_SECOND;
 324   }
 325 }
 326
 327 /**
 328  * Handle a possible change in the network configuration.
 329  *
 330  * If there is an AutoIP address configured, take the interface down
 331  * and begin probing with the same address.
 332  */
 333 void
 334 autoip_network_changed(struct netif *netif)
 335 {
 336   struct autoip* autoip = netif_autoip_data(netif);
 337
 338   if (autoip && (autoip->state != AUTOIP_STATE_OFF)) {
 339     autoip_start_probing(netif);
 340   }
 341 }
 342
 343 /**
 344  * @ingroup autoip
 345  * Stop AutoIP client
 346  *
 347  * @param netif network interface on which stop the AutoIP client
 348  */
 349 err_t
 350 autoip_stop(struct netif *netif)
 351 {
 352   struct autoip* autoip = netif_autoip_data(netif);
 353
 354   LWIP_ASSERT_CORE_LOCKED();
 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
 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
 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_isany_val(sipaddr) &&
 486            ip4_addr_cmp(&dipaddr, &autoip->llipaddr) &&
 487            !eth_addr_cmp(&netifaddr, &hdr->shwaddr))) {
 488         LWIP_DEBUGF(AUTOIP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE | LWIP_DBG_LEVEL_WARNING,
 489           ("autoip_arp_reply(): Probe Conflict detected\n"));
 490         autoip_restart(netif);
 491       }
 492     } else {
 493      /* RFC 3927 Section 2.5:
 494       * in any state we have a conflict if
 495       * ip.src == llipaddr && hw.src != own hwaddr
 496       */
 497       if (ip4_addr_cmp(&sipaddr, &autoip->llipaddr) &&
 498           !eth_addr_cmp(&netifaddr, &hdr->shwaddr)) {
 499         LWIP_DEBUGF(AUTOIP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE | LWIP_DBG_LEVEL_WARNING,
 500           ("autoip_arp_reply(): Conflicting ARP-Packet detected\n"));
 501         autoip_handle_arp_conflict(netif);
 502       }
 503     }
 504   }
 505 }
 506
 507 /** check if AutoIP supplied netif->ip_addr
 508  *
 509  * @param netif the netif to check
 510  * @return 1 if AutoIP supplied netif->ip_addr (state BOUND or ANNOUNCING),
 511  *         0 otherwise
 512  */
 513 u8_t
 514 autoip_supplied_address(const struct netif *netif)
 515 {
 516   if ((netif != NULL) && (netif_autoip_data(netif) != NULL)) {
 517     struct autoip* autoip = netif_autoip_data(netif);
 518     return (autoip->state == AUTOIP_STATE_BOUND) || (autoip->state == AUTOIP_STATE_ANNOUNCING);
 519   }
 520   return 0;
 521 }
 522
 523 u8_t
 524 autoip_accept_packet(struct netif *netif, const ip4_addr_t *addr)
 525 {
 526   struct autoip* autoip = netif_autoip_data(netif);
 527   return (autoip != NULL) && ip4_addr_cmp(addr, &(autoip->llipaddr));
 528 }
 529
 530 #endif /* LWIP_IPV4 && LWIP_AUTOIP */