src/core/netif.c

   1 /**
   2  * @file
   3  * lwIP network interface abstraction
   4  *
   5  */
   6
   7 /*
   8  * Copyright (c) 2001-2004 Swedish Institute of Computer Science.
   9  * All rights reserved.
  10  *
  11  * Redistribution and use in source and binary forms, with or without modification,
  12  * are permitted provided that the following conditions are met:
  13  *
  14  * 1. Redistributions of source code must retain the above copyright notice,
  15  *    this list of conditions and the following disclaimer.
  16  * 2. Redistributions in binary form must reproduce the above copyright notice,
  17  *    this list of conditions and the following disclaimer in the documentation
  18  *    and/or other materials provided with the distribution.
  19  * 3. The name of the author may not be used to endorse or promote products
  20  *    derived from this software without specific prior written permission.
  21  *
  22  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
  23  * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
  24  * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT
  25  * SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  26  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
  27  * OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  28  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  29  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
  30  * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
  31  * OF SUCH DAMAGE.
  32  *
  33  * This file is part of the lwIP TCP/IP stack.
  34  *
  35  * Author: Adam Dunkels <adam@sics.se>
  36  *
  37  */
  38
  39 #include "lwip/opt.h"
  40
  41 #include "lwip/def.h"
  42 #include "lwip/ip_addr.h"
  43 #include "lwip/netif.h"
  44 #include "lwip/tcp_impl.h"
  45 #include "lwip/snmp.h"
  46 #include "lwip/igmp.h"
  47 #include "netif/etharp.h"
  48 #include "lwip/stats.h"
  49 #if ENABLE_LOOPBACK
  50 #include "lwip/sys.h"
  51 #if LWIP_NETIF_LOOPBACK_MULTITHREADING
  52 #include "lwip/tcpip.h"
  53 #endif /* LWIP_NETIF_LOOPBACK_MULTITHREADING */
  54 #endif /* ENABLE_LOOPBACK */
  55
  56 #if LWIP_AUTOIP
  57 #include "lwip/autoip.h"
  58 #endif /* LWIP_AUTOIP */
  59 #if LWIP_DHCP
  60 #include "lwip/dhcp.h"
  61 #endif /* LWIP_DHCP */
  62
  63 #if LWIP_NETIF_STATUS_CALLBACK
  64 #define NETIF_STATUS_CALLBACK(n) do{ if (n->status_callback) { (n->status_callback)(n); }}while(0)
  65 #else
  66 #define NETIF_STATUS_CALLBACK(n)
  67 #endif /* LWIP_NETIF_STATUS_CALLBACK */
  68
  69 #if LWIP_NETIF_LINK_CALLBACK
  70 #define NETIF_LINK_CALLBACK(n) do{ if (n->link_callback) { (n->link_callback)(n); }}while(0)
  71 #else
  72 #define NETIF_LINK_CALLBACK(n)
  73 #endif /* LWIP_NETIF_LINK_CALLBACK */
  74
  75 struct netif *netif_list;
  76 struct netif *netif_default;
  77
  78 #if LWIP_HAVE_LOOPIF
  79 static struct netif loop_netif;
  80
  81 /**
  82  * Initialize a lwip network interface structure for a loopback interface
  83  *
  84  * @param netif the lwip network interface structure for this loopif
  85  * @return ERR_OK if the loopif is initialized
  86  *         ERR_MEM if private data couldn't be allocated
  87  */
  88 static err_t
  89 netif_loopif_init(struct netif *netif)
  90 {
  91   /* initialize the snmp variables and counters inside the struct netif
  92    * ifSpeed: no assumption can be made!
  93    */
  94   NETIF_INIT_SNMP(netif, snmp_ifType_softwareLoopback, 0);
  95
  96   netif->name[0] = 'l';
  97   netif->name[1] = 'o';
  98   netif->output = netif_loop_output;
  99   return ERR_OK;
 100 }
 101 #endif /* LWIP_HAVE_LOOPIF */
 102
 103 void
 104 netif_init(void)
 105 {
 106 #if LWIP_HAVE_LOOPIF
 107   ip_addr_t loop_ipaddr, loop_netmask, loop_gw;
 108   IP4_ADDR(&loop_gw, 127,0,0,1);
 109   IP4_ADDR(&loop_ipaddr, 127,0,0,1);
 110   IP4_ADDR(&loop_netmask, 255,0,0,0);
 111
 112 #if NO_SYS
 113   netif_add(&loop_netif, &loop_ipaddr, &loop_netmask, &loop_gw, NULL, netif_loopif_init, ip_input);
 114 #else  /* NO_SYS */
 115   netif_add(&loop_netif, &loop_ipaddr, &loop_netmask, &loop_gw, NULL, netif_loopif_init, tcpip_input);
 116 #endif /* NO_SYS */
 117   netif_set_up(&loop_netif);
 118
 119 #endif /* LWIP_HAVE_LOOPIF */
 120 }
 121
 122 /**
 123  * Add a network interface to the list of lwIP netifs.
 124  *
 125  * @param netif a pre-allocated netif structure
 126  * @param ipaddr IP address for the new netif
 127  * @param netmask network mask for the new netif
 128  * @param gw default gateway IP address for the new netif
 129  * @param state opaque data passed to the new netif
 130  * @param init callback function that initializes the interface
 131  * @param input callback function that is called to pass
 132  * ingress packets up in the protocol layer stack.
 133  *
 134  * @return netif, or NULL if failed.
 135  */
 136 struct netif *
 137 netif_add(struct netif *netif, ip_addr_t *ipaddr, ip_addr_t *netmask,
 138   ip_addr_t *gw, void *state, netif_init_fn init, netif_input_fn input)
 139 {
 140   static u8_t netifnum = 0;
 141
 142   LWIP_ASSERT("No init function given", init != NULL);
 143
 144   /* reset new interface configuration state */
 145   ip_addr_set_zero(&netif->ip_addr);
 146   ip_addr_set_zero(&netif->netmask);
 147   ip_addr_set_zero(&netif->gw);
 148   netif->flags = 0;
 149 #if LWIP_DHCP
 150   /* netif not under DHCP control by default */
 151   netif->dhcp = NULL;
 152 #endif /* LWIP_DHCP */
 153 #if LWIP_AUTOIP
 154   /* netif not under AutoIP control by default */
 155   netif->autoip = NULL;
 156 #endif /* LWIP_AUTOIP */
 157 #if LWIP_NETIF_STATUS_CALLBACK
 158   netif->status_callback = NULL;
 159 #endif /* LWIP_NETIF_STATUS_CALLBACK */
 160 #if LWIP_NETIF_LINK_CALLBACK
 161   netif->link_callback = NULL;
 162 #endif /* LWIP_NETIF_LINK_CALLBACK */
 163 #if LWIP_IGMP
 164   netif->igmp_mac_filter = NULL;
 165 #endif /* LWIP_IGMP */
 166 #if ENABLE_LOOPBACK
 167   netif->loop_first = NULL;
 168   netif->loop_last = NULL;
 169 #endif /* ENABLE_LOOPBACK */
 170
 171   /* remember netif specific state information data */
 172   netif->state = state;
 173   netif->num = netifnum++;
 174   netif->input = input;
 175 #if LWIP_NETIF_HWADDRHINT
 176   netif->addr_hint = NULL;
 177 #endif /* LWIP_NETIF_HWADDRHINT*/
 178 #if ENABLE_LOOPBACK && LWIP_LOOPBACK_MAX_PBUFS
 179   netif->loop_cnt_current = 0;
 180 #endif /* ENABLE_LOOPBACK && LWIP_LOOPBACK_MAX_PBUFS */
 181
 182   netif_set_addr(netif, ipaddr, netmask, gw);
 183
 184   /* call user specified initialization function for netif */
 185   if (init(netif) != ERR_OK) {
 186     return NULL;
 187   }
 188
 189   /* add this netif to the list */
 190   netif->next = netif_list;
 191   netif_list = netif;
 192   snmp_inc_iflist();
 193
 194 #if LWIP_IGMP
 195   /* start IGMP processing */
 196   if (netif->flags & NETIF_FLAG_IGMP) {
 197     igmp_start(netif);
 198   }
 199 #endif /* LWIP_IGMP */
 200
 201   LWIP_DEBUGF(NETIF_DEBUG, ("netif: added interface %c%c IP addr ",
 202     netif->name[0], netif->name[1]));
 203   ip_addr_debug_print(NETIF_DEBUG, ipaddr);
 204   LWIP_DEBUGF(NETIF_DEBUG, (" netmask "));
 205   ip_addr_debug_print(NETIF_DEBUG, netmask);
 206   LWIP_DEBUGF(NETIF_DEBUG, (" gw "));
 207   ip_addr_debug_print(NETIF_DEBUG, gw);
 208   LWIP_DEBUGF(NETIF_DEBUG, ("\n"));
 209   return netif;
 210 }
 211
 212 /**
 213  * Change IP address configuration for a network interface (including netmask
 214  * and default gateway).
 215  *
 216  * @param netif the network interface to change
 217  * @param ipaddr the new IP address
 218  * @param netmask the new netmask
 219  * @param gw the new default gateway
 220  */
 221 void
 222 netif_set_addr(struct netif *netif, ip_addr_t *ipaddr, ip_addr_t *netmask,
 223     ip_addr_t *gw)
 224 {
 225   netif_set_ipaddr(netif, ipaddr);
 226   netif_set_netmask(netif, netmask);
 227   netif_set_gw(netif, gw);
 228 }
 229
 230 /**
 231  * Remove a network interface from the list of lwIP netifs.
 232  *
 233  * @param netif the network interface to remove
 234  */
 235 void
 236 netif_remove(struct netif *netif)
 237 {
 238   if (netif == NULL) {
 239     return;
 240   }
 241
 242 #if LWIP_IGMP
 243   /* stop IGMP processing */
 244   if (netif->flags & NETIF_FLAG_IGMP) {
 245     igmp_stop(netif);
 246   }
 247 #endif /* LWIP_IGMP */
 248   if (netif_is_up(netif)) {
 249     /* set netif down before removing (call callback function) */
 250     netif_set_down(netif);
 251   }
 252
 253   snmp_delete_ipaddridx_tree(netif);
 254
 255   /*  is it the first netif? */
 256   if (netif_list == netif) {
 257     netif_list = netif->next;
 258   } else {
 259     /*  look for netif further down the list */
 260     struct netif * tmpNetif;
 261     for (tmpNetif = netif_list; tmpNetif != NULL; tmpNetif = tmpNetif->next) {
 262       if (tmpNetif->next == netif) {
 263         tmpNetif->next = netif->next;
 264         break;
 265       }
 266     }
 267     if (tmpNetif == NULL)
 268       return; /*  we didn't find any netif today */
 269   }
 270   snmp_dec_iflist();
 271   /* this netif is default? */
 272   if (netif_default == netif) {
 273     /* reset default netif */
 274     netif_set_default(NULL);
 275   }
 276   LWIP_DEBUGF( NETIF_DEBUG, ("netif_remove: removed netif\n") );
 277 }
 278
 279 /**
 280  * Find a network interface by searching for its name
 281  *
 282  * @param name the name of the netif (like netif->name) plus concatenated number
 283  * in ascii representation (e.g. 'en0')
 284  */
 285 struct netif *
 286 netif_find(char *name)
 287 {
 288   struct netif *netif;
 289   u8_t num;
 290
 291   if (name == NULL) {
 292     return NULL;
 293   }
 294
 295   num = name[2] - '0';
 296
 297   for(netif = netif_list; netif != NULL; netif = netif->next) {
 298     if (num == netif->num &&
 299        name[0] == netif->name[0] &&
 300        name[1] == netif->name[1]) {
 301       LWIP_DEBUGF(NETIF_DEBUG, ("netif_find: found %c%c\n", name[0], name[1]));
 302       return netif;
 303     }
 304   }
 305   LWIP_DEBUGF(NETIF_DEBUG, ("netif_find: didn't find %c%c\n", name[0], name[1]));
 306   return NULL;
 307 }
 308
 309 /**
 310  * Change the IP address of a network interface
 311  *
 312  * @param netif the network interface to change
 313  * @param ipaddr the new IP address
 314  *
 315  * @note call netif_set_addr() if you also want to change netmask and
 316  * default gateway
 317  */
 318 void
 319 netif_set_ipaddr(struct netif *netif, ip_addr_t *ipaddr)
 320 {
 321   /* TODO: Handling of obsolete pcbs */
 322   /* See:  http://mail.gnu.org/archive/html/lwip-users/2003-03/msg00118.html */
 323 #if LWIP_TCP
 324   struct tcp_pcb *pcb;
 325   struct tcp_pcb_listen *lpcb;
 326
 327   /* address is actually being changed? */
 328   if ((ip_addr_cmp(ipaddr, &(netif->ip_addr))) == 0) {
 329     /* extern struct tcp_pcb *tcp_active_pcbs; defined by tcp.h */
 330     LWIP_DEBUGF(NETIF_DEBUG | LWIP_DBG_STATE, ("netif_set_ipaddr: netif address being changed\n"));
 331     pcb = tcp_active_pcbs;
 332     while (pcb != NULL) {
 333       /* PCB bound to current local interface address? */
 334       if (ip_addr_cmp(&(pcb->local_ip), &(netif->ip_addr))) {
 335         /* this connection must be aborted */
 336         struct tcp_pcb *next = pcb->next;
 337         LWIP_DEBUGF(NETIF_DEBUG | LWIP_DBG_STATE, ("netif_set_ipaddr: aborting TCP pcb %p\n", (void *)pcb));
 338         tcp_abort(pcb);
 339         pcb = next;
 340       } else {
 341         pcb = pcb->next;
 342       }
 343     }
 344     for (lpcb = tcp_listen_pcbs.listen_pcbs; lpcb != NULL; lpcb = lpcb->next) {
 345       /* PCB bound to current local interface address? */
 346       if ((!(ip_addr_isany(&(lpcb->local_ip)))) &&
 347           (ip_addr_cmp(&(lpcb->local_ip), &(netif->ip_addr)))) {
 348         /* The PCB is listening to the old ipaddr and
 349          * is set to listen to the new one instead */
 350         ip_addr_set(&(lpcb->local_ip), ipaddr);
 351       }
 352     }
 353   }
 354 #endif
 355   snmp_delete_ipaddridx_tree(netif);
 356   snmp_delete_iprteidx_tree(0,netif);
 357   /* set new IP address to netif */
 358   ip_addr_set(&(netif->ip_addr), ipaddr);
 359   snmp_insert_ipaddridx_tree(netif);
 360   snmp_insert_iprteidx_tree(0,netif);
 361
 362   LWIP_DEBUGF(NETIF_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE, ("netif: IP address of interface %c%c set to %"U16_F".%"U16_F".%"U16_F".%"U16_F"\n",
 363     netif->name[0], netif->name[1],
 364     ip4_addr1_16(&netif->ip_addr),
 365     ip4_addr2_16(&netif->ip_addr),
 366     ip4_addr3_16(&netif->ip_addr),
 367     ip4_addr4_16(&netif->ip_addr)));
 368 }
 369
 370 /**
 371  * Change the default gateway for a network interface
 372  *
 373  * @param netif the network interface to change
 374  * @param gw the new default gateway
 375  *
 376  * @note call netif_set_addr() if you also want to change ip address and netmask
 377  */
 378 void
 379 netif_set_gw(struct netif *netif, ip_addr_t *gw)
 380 {
 381   ip_addr_set(&(netif->gw), gw);
 382   LWIP_DEBUGF(NETIF_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE, ("netif: GW address of interface %c%c set to %"U16_F".%"U16_F".%"U16_F".%"U16_F"\n",
 383     netif->name[0], netif->name[1],
 384     ip4_addr1_16(&netif->gw),
 385     ip4_addr2_16(&netif->gw),
 386     ip4_addr3_16(&netif->gw),
 387     ip4_addr4_16(&netif->gw)));
 388 }
 389
 390 /**
 391  * Change the netmask of a network interface
 392  *
 393  * @param netif the network interface to change
 394  * @param netmask the new netmask
 395  *
 396  * @note call netif_set_addr() if you also want to change ip address and
 397  * default gateway
 398  */
 399 void
 400 netif_set_netmask(struct netif *netif, ip_addr_t *netmask)
 401 {
 402   snmp_delete_iprteidx_tree(0, netif);
 403   /* set new netmask to netif */
 404   ip_addr_set(&(netif->netmask), netmask);
 405   snmp_insert_iprteidx_tree(0, netif);
 406   LWIP_DEBUGF(NETIF_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE, ("netif: netmask of interface %c%c set to %"U16_F".%"U16_F".%"U16_F".%"U16_F"\n",
 407     netif->name[0], netif->name[1],
 408     ip4_addr1_16(&netif->netmask),
 409     ip4_addr2_16(&netif->netmask),
 410     ip4_addr3_16(&netif->netmask),
 411     ip4_addr4_16(&netif->netmask)));
 412 }
 413
 414 /**
 415  * Set a network interface as the default network interface
 416  * (used to output all packets for which no specific route is found)
 417  *
 418  * @param netif the default network interface
 419  */
 420 void
 421 netif_set_default(struct netif *netif)
 422 {
 423   if (netif == NULL) {
 424     /* remove default route */
 425     snmp_delete_iprteidx_tree(1, netif);
 426   } else {
 427     /* install default route */
 428     snmp_insert_iprteidx_tree(1, netif);
 429   }
 430   netif_default = netif;
 431   LWIP_DEBUGF(NETIF_DEBUG, ("netif: setting default interface %c%c\n",
 432            netif ? netif->name[0] : '\'', netif ? netif->name[1] : '\''));
 433 }
 434
 435 /**
 436  * Bring an interface up, available for processing
 437  * traffic.
 438  *
 439  * @note: Enabling DHCP on a down interface will make it come
 440  * up once configured.
 441  *
 442  * @see dhcp_start()
 443  */
 444 void netif_set_up(struct netif *netif)
 445 {
 446   if (!(netif->flags & NETIF_FLAG_UP)) {
 447     netif->flags |= NETIF_FLAG_UP;
 448
 449 #if LWIP_SNMP
 450     snmp_get_sysuptime(&netif->ts);
 451 #endif /* LWIP_SNMP */
 452
 453     NETIF_STATUS_CALLBACK(netif);
 454
 455     if (netif->flags & NETIF_FLAG_LINK_UP) {
 456 #if LWIP_ARP
 457       /* For Ethernet network interfaces, we would like to send a "gratuitous ARP" */
 458       if (netif->flags & (NETIF_FLAG_ETHARP)) {
 459         etharp_gratuitous(netif);
 460       }
 461 #endif /* LWIP_ARP */
 462
 463 #if LWIP_IGMP
 464       /* resend IGMP memberships */
 465       if (netif->flags & NETIF_FLAG_IGMP) {
 466         igmp_report_groups( netif);
 467       }
 468 #endif /* LWIP_IGMP */
 469     }
 470   }
 471 }
 472
 473 /**
 474  * Bring an interface down, disabling any traffic processing.
 475  *
 476  * @note: Enabling DHCP on a down interface will make it come
 477  * up once configured.
 478  *
 479  * @see dhcp_start()
 480  */
 481 void netif_set_down(struct netif *netif)
 482 {
 483   if (netif->flags & NETIF_FLAG_UP) {
 484     netif->flags &= ~NETIF_FLAG_UP;
 485 #if LWIP_SNMP
 486     snmp_get_sysuptime(&netif->ts);
 487 #endif
 488
 489     NETIF_STATUS_CALLBACK(netif);
 490   }
 491 }
 492
 493 #if LWIP_NETIF_STATUS_CALLBACK
 494 /**
 495  * Set callback to be called when interface is brought up/down
 496  */
 497 void netif_set_status_callback(struct netif *netif, netif_status_callback_fn status_callback)
 498 {
 499   if (netif) {
 500     netif->status_callback = status_callback;
 501   }
 502 }
 503 #endif /* LWIP_NETIF_STATUS_CALLBACK */
 504
 505 /**
 506  * Called by a driver when its link goes up
 507  */
 508 void netif_set_link_up(struct netif *netif )
 509 {
 510   if (!(netif->flags & NETIF_FLAG_LINK_UP)) {
 511     netif->flags |= NETIF_FLAG_LINK_UP;
 512
 513 #if LWIP_DHCP
 514     if (netif->dhcp) {
 515       dhcp_network_changed(netif);
 516     }
 517 #endif /* LWIP_DHCP */
 518
 519 #if LWIP_AUTOIP
 520     if (netif->autoip) {
 521       autoip_network_changed(netif);
 522     }
 523 #endif /* LWIP_AUTOIP */
 524
 525     if (netif->flags & NETIF_FLAG_UP) {
 526 #if LWIP_ARP
 527       /* For Ethernet network interfaces, we would like to send a "gratuitous ARP" */
 528       if (netif->flags & NETIF_FLAG_ETHARP) {
 529         etharp_gratuitous(netif);
 530       }
 531 #endif /* LWIP_ARP */
 532
 533 #if LWIP_IGMP
 534       /* resend IGMP memberships */
 535       if (netif->flags & NETIF_FLAG_IGMP) {
 536         igmp_report_groups( netif);
 537       }
 538 #endif /* LWIP_IGMP */
 539     }
 540     NETIF_LINK_CALLBACK(netif);
 541   }
 542 }
 543
 544 /**
 545  * Called by a driver when its link goes down
 546  */
 547 void netif_set_link_down(struct netif *netif )
 548 {
 549   if (netif->flags & NETIF_FLAG_LINK_UP) {
 550     netif->flags &= ~NETIF_FLAG_LINK_UP;
 551     NETIF_LINK_CALLBACK(netif);
 552   }
 553 }
 554
 555 #if LWIP_NETIF_LINK_CALLBACK
 556 /**
 557  * Set callback to be called when link is brought up/down
 558  */
 559 void netif_set_link_callback(struct netif *netif, netif_status_callback_fn link_callback)
 560 {
 561   if (netif) {
 562     netif->link_callback = link_callback;
 563   }
 564 }
 565 #endif /* LWIP_NETIF_LINK_CALLBACK */
 566
 567 #if ENABLE_LOOPBACK
 568 /**
 569  * Send an IP packet to be received on the same netif (loopif-like).
 570  * The pbuf is simply copied and handed back to netif->input.
 571  * In multithreaded mode, this is done directly since netif->input must put
 572  * the packet on a queue.
 573  * In callback mode, the packet is put on an internal queue and is fed to
 574  * netif->input by netif_poll().
 575  *
 576  * @param netif the lwip network interface structure
 577  * @param p the (IP) packet to 'send'
 578  * @param ipaddr the ip address to send the packet to (not used)
 579  * @return ERR_OK if the packet has been sent
 580  *         ERR_MEM if the pbuf used to copy the packet couldn't be allocated
 581  */
 582 err_t
 583 netif_loop_output(struct netif *netif, struct pbuf *p,
 584        ip_addr_t *ipaddr)
 585 {
 586   struct pbuf *r;
 587   err_t err;
 588   struct pbuf *last;
 589 #if LWIP_LOOPBACK_MAX_PBUFS
 590   u8_t clen = 0;
 591 #endif /* LWIP_LOOPBACK_MAX_PBUFS */
 592   /* If we have a loopif, SNMP counters are adjusted for it,
 593    * if not they are adjusted for 'netif'. */
 594 #if LWIP_HAVE_LOOPIF
 595   struct netif *stats_if = &loop_netif;
 596 #else /* LWIP_HAVE_LOOPIF */
 597   struct netif *stats_if = netif;
 598 #endif /* LWIP_HAVE_LOOPIF */
 599   SYS_ARCH_DECL_PROTECT(lev);
 600   LWIP_UNUSED_ARG(ipaddr);
 601
 602   /* Allocate a new pbuf */
 603   r = pbuf_alloc(PBUF_LINK, p->tot_len, PBUF_RAM);
 604   if (r == NULL) {
 605     LINK_STATS_INC(link.memerr);
 606     LINK_STATS_INC(link.drop);
 607     snmp_inc_ifoutdiscards(stats_if);
 608     return ERR_MEM;
 609   }
 610 #if LWIP_LOOPBACK_MAX_PBUFS
 611   clen = pbuf_clen(r);
 612   /* check for overflow or too many pbuf on queue */
 613   if(((netif->loop_cnt_current + clen) < netif->loop_cnt_current) ||
 614      ((netif->loop_cnt_current + clen) > LWIP_LOOPBACK_MAX_PBUFS)) {
 615     pbuf_free(r);
 616     LINK_STATS_INC(link.memerr);
 617     LINK_STATS_INC(link.drop);
 618     snmp_inc_ifoutdiscards(stats_if);
 619     return ERR_MEM;
 620   }
 621   netif->loop_cnt_current += clen;
 622 #endif /* LWIP_LOOPBACK_MAX_PBUFS */
 623
 624   /* Copy the whole pbuf queue p into the single pbuf r */
 625   if ((err = pbuf_copy(r, p)) != ERR_OK) {
 626     pbuf_free(r);
 627     LINK_STATS_INC(link.memerr);
 628     LINK_STATS_INC(link.drop);
 629     snmp_inc_ifoutdiscards(stats_if);
 630     return err;
 631   }
 632
 633   /* Put the packet on a linked list which gets emptied through calling
 634      netif_poll(). */
 635
 636   /* let last point to the last pbuf in chain r */
 637   for (last = r; last->next != NULL; last = last->next);
 638
 639   SYS_ARCH_PROTECT(lev);
 640   if(netif->loop_first != NULL) {
 641     LWIP_ASSERT("if first != NULL, last must also be != NULL", netif->loop_last != NULL);
 642     netif->loop_last->next = r;
 643     netif->loop_last = last;
 644   } else {
 645     netif->loop_first = r;
 646     netif->loop_last = last;
 647   }
 648   SYS_ARCH_UNPROTECT(lev);
 649
 650   LINK_STATS_INC(link.xmit);
 651   snmp_add_ifoutoctets(stats_if, p->tot_len);
 652   snmp_inc_ifoutucastpkts(stats_if);
 653
 654 #if LWIP_NETIF_LOOPBACK_MULTITHREADING
 655   /* For multithreading environment, schedule a call to netif_poll */
 656   tcpip_callback((tcpip_callback_fn)netif_poll, netif);
 657 #endif /* LWIP_NETIF_LOOPBACK_MULTITHREADING */
 658
 659   return ERR_OK;
 660 }
 661
 662 /**
 663  * Call netif_poll() in the main loop of your application. This is to prevent
 664  * reentering non-reentrant functions like tcp_input(). Packets passed to
 665  * netif_loop_output() are put on a list that is passed to netif->input() by
 666  * netif_poll().
 667  */
 668 void
 669 netif_poll(struct netif *netif)
 670 {
 671   struct pbuf *in;
 672   /* If we have a loopif, SNMP counters are adjusted for it,
 673    * if not they are adjusted for 'netif'. */
 674 #if LWIP_HAVE_LOOPIF
 675   struct netif *stats_if = &loop_netif;
 676 #else /* LWIP_HAVE_LOOPIF */
 677   struct netif *stats_if = netif;
 678 #endif /* LWIP_HAVE_LOOPIF */
 679   SYS_ARCH_DECL_PROTECT(lev);
 680
 681   do {
 682     /* Get a packet from the list. With SYS_LIGHTWEIGHT_PROT=1, this is protected */
 683     SYS_ARCH_PROTECT(lev);
 684     in = netif->loop_first;
 685     if (in != NULL) {
 686       struct pbuf *in_end = in;
 687 #if LWIP_LOOPBACK_MAX_PBUFS
 688       u8_t clen = pbuf_clen(in);
 689       /* adjust the number of pbufs on queue */
 690       LWIP_ASSERT("netif->loop_cnt_current underflow",
 691         ((netif->loop_cnt_current - clen) < netif->loop_cnt_current));
 692       netif->loop_cnt_current -= clen;
 693 #endif /* LWIP_LOOPBACK_MAX_PBUFS */
 694       while (in_end->len != in_end->tot_len) {
 695         LWIP_ASSERT("bogus pbuf: len != tot_len but next == NULL!", in_end->next != NULL);
 696         in_end = in_end->next;
 697       }
 698       /* 'in_end' now points to the last pbuf from 'in' */
 699       if (in_end == netif->loop_last) {
 700         /* this was the last pbuf in the list */
 701         netif->loop_first = netif->loop_last = NULL;
 702       } else {
 703         /* pop the pbuf off the list */
 704         netif->loop_first = in_end->next;
 705         LWIP_ASSERT("should not be null since first != last!", netif->loop_first != NULL);
 706       }
 707       /* De-queue the pbuf from its successors on the 'loop_' list. */
 708       in_end->next = NULL;
 709     }
 710     SYS_ARCH_UNPROTECT(lev);
 711
 712     if (in != NULL) {
 713       LINK_STATS_INC(link.recv);
 714       snmp_add_ifinoctets(stats_if, in->tot_len);
 715       snmp_inc_ifinucastpkts(stats_if);
 716       /* loopback packets are always IP packets! */
 717       if (ip_input(in, netif) != ERR_OK) {
 718         pbuf_free(in);
 719       }
 720       /* Don't reference the packet any more! */
 721       in = NULL;
 722     }
 723   /* go on while there is a packet on the list */
 724   } while (netif->loop_first != NULL);
 725 }
 726
 727 #if !LWIP_NETIF_LOOPBACK_MULTITHREADING
 728 /**
 729  * Calls netif_poll() for every netif on the netif_list.
 730  */
 731 void
 732 netif_poll_all(void)
 733 {
 734   struct netif *netif = netif_list;
 735   /* loop through netifs */
 736   while (netif != NULL) {
 737     netif_poll(netif);
 738     /* proceed to next network interface */
 739     netif = netif->next;
 740   }
 741 }
 742 #endif /* !LWIP_NETIF_LOOPBACK_MULTITHREADING */
 743 #endif /* ENABLE_LOOPBACK */