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.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) { if (n->status_callback) (n->status_callback)(n); }
  65 #else
  66 #define NETIF_STATUS_CALLBACK(n) { /* NOP */ }
  67 #endif /* LWIP_NETIF_STATUS_CALLBACK */
  68
  69 #if LWIP_NETIF_LINK_CALLBACK
  70 #define NETIF_LINK_CALLBACK(n) { if (n->link_callback) (n->link_callback)(n); }
  71 #else
  72 #define NETIF_LINK_CALLBACK(n) { /* NOP */ }
  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 LWIP_ARP
 456     /* For Ethernet network interfaces, we would like to send a "gratuitous ARP" */
 457     if (netif->flags & NETIF_FLAG_ETHARP) {
 458       etharp_gratuitous(netif);
 459     }
 460 #endif /* LWIP_ARP */
 461
 462 #if LWIP_IGMP
 463     /* resend IGMP memberships */
 464     if (netif->flags & NETIF_FLAG_IGMP) {
 465       igmp_report_groups( netif);
 466     }
 467 #endif /* LWIP_IGMP */
 468   }
 469 }
 470
 471 /**
 472  * Bring an interface down, disabling any traffic processing.
 473  *
 474  * @note: Enabling DHCP on a down interface will make it come
 475  * up once configured.
 476  *
 477  * @see dhcp_start()
 478  */
 479 void netif_set_down(struct netif *netif)
 480 {
 481   if (netif->flags & NETIF_FLAG_UP) {
 482     netif->flags &= ~NETIF_FLAG_UP;
 483 #if LWIP_SNMP
 484     snmp_get_sysuptime(&netif->ts);
 485 #endif
 486
 487     NETIF_STATUS_CALLBACK(netif);
 488   }
 489 }
 490
 491 #if LWIP_NETIF_STATUS_CALLBACK
 492 /**
 493  * Set callback to be called when interface is brought up/down
 494  */
 495 void netif_set_status_callback(struct netif *netif, netif_status_callback_fn status_callback)
 496 {
 497   if (netif) {
 498     netif->status_callback = status_callback;
 499   }
 500 }
 501 #endif /* LWIP_NETIF_STATUS_CALLBACK */
 502
 503 #if LWIP_NETIF_LINK_CALLBACK
 504 /**
 505  * Called by a driver when its link goes up
 506  */
 507 void netif_set_link_up(struct netif *netif )
 508 {
 509   netif->flags |= NETIF_FLAG_LINK_UP;
 510
 511 #if LWIP_DHCP
 512   if (netif->dhcp) {
 513     dhcp_network_changed(netif);
 514   }
 515 #endif /* LWIP_DHCP */
 516
 517 #if LWIP_AUTOIP
 518   if (netif->autoip) {
 519     autoip_network_changed(netif);
 520   }
 521 #endif /* LWIP_AUTOIP */
 522
 523   if (netif->flags & NETIF_FLAG_UP) {
 524 #if LWIP_ARP
 525     /* For Ethernet network interfaces, we would like to send a "gratuitous ARP" */
 526     if (netif->flags & NETIF_FLAG_ETHARP) {
 527       etharp_gratuitous(netif);
 528     }
 529 #endif /* LWIP_ARP */
 530
 531 #if LWIP_IGMP
 532     /* resend IGMP memberships */
 533     if (netif->flags & NETIF_FLAG_IGMP) {
 534       igmp_report_groups( netif);
 535     }
 536 #endif /* LWIP_IGMP */
 537   }
 538   NETIF_LINK_CALLBACK(netif);
 539 }
 540
 541 /**
 542  * Called by a driver when its link goes down
 543  */
 544 void netif_set_link_down(struct netif *netif )
 545 {
 546   netif->flags &= ~NETIF_FLAG_LINK_UP;
 547   NETIF_LINK_CALLBACK(netif);
 548 }
 549
 550 /**
 551  * Set callback to be called when link is brought up/down
 552  */
 553 void netif_set_link_callback(struct netif *netif, netif_status_callback_fn link_callback)
 554 {
 555   if (netif) {
 556     netif->link_callback = link_callback;
 557   }
 558 }
 559 #endif /* LWIP_NETIF_LINK_CALLBACK */
 560
 561 #if ENABLE_LOOPBACK
 562 /**
 563  * Send an IP packet to be received on the same netif (loopif-like).
 564  * The pbuf is simply copied and handed back to netif->input.
 565  * In multithreaded mode, this is done directly since netif->input must put
 566  * the packet on a queue.
 567  * In callback mode, the packet is put on an internal queue and is fed to
 568  * netif->input by netif_poll().
 569  *
 570  * @param netif the lwip network interface structure
 571  * @param p the (IP) packet to 'send'
 572  * @param ipaddr the ip address to send the packet to (not used)
 573  * @return ERR_OK if the packet has been sent
 574  *         ERR_MEM if the pbuf used to copy the packet couldn't be allocated
 575  */
 576 err_t
 577 netif_loop_output(struct netif *netif, struct pbuf *p,
 578        ip_addr_t *ipaddr)
 579 {
 580   struct pbuf *r;
 581   err_t err;
 582   struct pbuf *last;
 583 #if LWIP_LOOPBACK_MAX_PBUFS
 584   u8_t clen = 0;
 585 #endif /* LWIP_LOOPBACK_MAX_PBUFS */
 586   SYS_ARCH_DECL_PROTECT(lev);
 587   /* If we have a loopif, SNMP counters are adjusted for it,
 588    * if not they are adjusted for 'netif'. */
 589 #if LWIP_HAVE_LOOPIF
 590   struct netif *stats_if = &loop_netif;
 591 #else /* LWIP_HAVE_LOOPIF */
 592   struct netif *stats_if = netif;
 593 #endif /* LWIP_HAVE_LOOPIF */
 594   LWIP_UNUSED_ARG(ipaddr);
 595
 596   /* Allocate a new pbuf */
 597   r = pbuf_alloc(PBUF_LINK, p->tot_len, PBUF_RAM);
 598   if (r == NULL) {
 599     LINK_STATS_INC(link.memerr);
 600     LINK_STATS_INC(link.drop);
 601     snmp_inc_ifoutdiscards(stats_if);
 602     return ERR_MEM;
 603   }
 604 #if LWIP_LOOPBACK_MAX_PBUFS
 605   clen = pbuf_clen(r);
 606   /* check for overflow or too many pbuf on queue */
 607   if(((netif->loop_cnt_current + clen) < netif->loop_cnt_current) ||
 608      ((netif->loop_cnt_current + clen) > LWIP_LOOPBACK_MAX_PBUFS)) {
 609     pbuf_free(r);
 610     LINK_STATS_INC(link.memerr);
 611     LINK_STATS_INC(link.drop);
 612     snmp_inc_ifoutdiscards(stats_if);
 613     return ERR_MEM;
 614   }
 615   netif->loop_cnt_current += clen;
 616 #endif /* LWIP_LOOPBACK_MAX_PBUFS */
 617
 618   /* Copy the whole pbuf queue p into the single pbuf r */
 619   if ((err = pbuf_copy(r, p)) != ERR_OK) {
 620     pbuf_free(r);
 621     LINK_STATS_INC(link.memerr);
 622     LINK_STATS_INC(link.drop);
 623     snmp_inc_ifoutdiscards(stats_if);
 624     return err;
 625   }
 626
 627   /* Put the packet on a linked list which gets emptied through calling
 628      netif_poll(). */
 629
 630   /* let last point to the last pbuf in chain r */
 631   for (last = r; last->next != NULL; last = last->next);
 632
 633   SYS_ARCH_PROTECT(lev);
 634   if(netif->loop_first != NULL) {
 635     LWIP_ASSERT("if first != NULL, last must also be != NULL", netif->loop_last != NULL);
 636     netif->loop_last->next = r;
 637     netif->loop_last = last;
 638   } else {
 639     netif->loop_first = r;
 640     netif->loop_last = last;
 641   }
 642   SYS_ARCH_UNPROTECT(lev);
 643
 644   LINK_STATS_INC(link.xmit);
 645   snmp_add_ifoutoctets(stats_if, p->tot_len);
 646   snmp_inc_ifoutucastpkts(stats_if);
 647
 648 #if LWIP_NETIF_LOOPBACK_MULTITHREADING
 649   /* For multithreading environment, schedule a call to netif_poll */
 650   tcpip_callback((tcpip_callback_fn)netif_poll, netif);
 651 #endif /* LWIP_NETIF_LOOPBACK_MULTITHREADING */
 652
 653   return ERR_OK;
 654 }
 655
 656 /**
 657  * Call netif_poll() in the main loop of your application. This is to prevent
 658  * reentering non-reentrant functions like tcp_input(). Packets passed to
 659  * netif_loop_output() are put on a list that is passed to netif->input() by
 660  * netif_poll().
 661  */
 662 void
 663 netif_poll(struct netif *netif)
 664 {
 665   struct pbuf *in;
 666   /* If we have a loopif, SNMP counters are adjusted for it,
 667    * if not they are adjusted for 'netif'. */
 668 #if LWIP_HAVE_LOOPIF
 669   struct netif *stats_if = &loop_netif;
 670 #else /* LWIP_HAVE_LOOPIF */
 671   struct netif *stats_if = netif;
 672 #endif /* LWIP_HAVE_LOOPIF */
 673   SYS_ARCH_DECL_PROTECT(lev);
 674
 675   do {
 676     /* Get a packet from the list. With SYS_LIGHTWEIGHT_PROT=1, this is protected */
 677     SYS_ARCH_PROTECT(lev);
 678     in = netif->loop_first;
 679     if (in != NULL) {
 680       struct pbuf *in_end = in;
 681 #if LWIP_LOOPBACK_MAX_PBUFS
 682       u8_t clen = pbuf_clen(in);
 683       /* adjust the number of pbufs on queue */
 684       LWIP_ASSERT("netif->loop_cnt_current underflow",
 685         ((netif->loop_cnt_current - clen) < netif->loop_cnt_current));
 686       netif->loop_cnt_current -= clen;
 687 #endif /* LWIP_LOOPBACK_MAX_PBUFS */
 688       while (in_end->len != in_end->tot_len) {
 689         LWIP_ASSERT("bogus pbuf: len != tot_len but next == NULL!", in_end->next != NULL);
 690         in_end = in_end->next;
 691       }
 692       /* 'in_end' now points to the last pbuf from 'in' */
 693       if (in_end == netif->loop_last) {
 694         /* this was the last pbuf in the list */
 695         netif->loop_first = netif->loop_last = NULL;
 696       } else {
 697         /* pop the pbuf off the list */
 698         netif->loop_first = in_end->next;
 699         LWIP_ASSERT("should not be null since first != last!", netif->loop_first != NULL);
 700       }
 701       /* De-queue the pbuf from its successors on the 'loop_' list. */
 702       in_end->next = NULL;
 703     }
 704     SYS_ARCH_UNPROTECT(lev);
 705
 706     if (in != NULL) {
 707       LINK_STATS_INC(link.recv);
 708       snmp_add_ifinoctets(stats_if, in->tot_len);
 709       snmp_inc_ifinucastpkts(stats_if);
 710       /* loopback packets are always IP packets! */
 711       if (ip_input(in, netif) != ERR_OK) {
 712         pbuf_free(in);
 713       }
 714       /* Don't reference the packet any more! */
 715       in = NULL;
 716     }
 717   /* go on while there is a packet on the list */
 718   } while (netif->loop_first != NULL);
 719 }
 720
 721 #if !LWIP_NETIF_LOOPBACK_MULTITHREADING
 722 /**
 723  * Calls netif_poll() for every netif on the netif_list.
 724  */
 725 void
 726 netif_poll_all(void)
 727 {
 728   struct netif *netif = netif_list;
 729   /* loop through netifs */
 730   while (netif != NULL) {
 731     netif_poll(netif);
 732     /* proceed to next network interface */
 733     netif = netif->next;
 734   }
 735 }
 736 #endif /* !LWIP_NETIF_LOOPBACK_MULTITHREADING */
 737 #endif /* ENABLE_LOOPBACK */