/**

 * @file

 * lwIP network interface abstraction

 *

 * @defgroup netif Network interface (NETIF)

 * @ingroup callbackstyle_api

 *

 * @defgroup netif_ip4 IPv4 address handling

 * @ingroup netif

 *

 * @defgroup netif_ip6 IPv6 address handling

 * @ingroup netif

 *

 * @defgroup netif_cd Client data handling

 * Store data (void*) on a netif for application usage.

 * @see @ref LWIP_NUM_NETIF_CLIENT_DATA

 * @ingroup netif

 */

/*

 * Copyright (c) 2001-2004 Swedish Institute of Computer Science.

 * All rights reserved.

 *

 * Redistribution and use in source and binary forms, with or without modification,

 * are permitted provided that the following conditions are met:

 *

 * 1. Redistributions of source code must retain the above copyright notice,

 *    this list of conditions and the following disclaimer.

 * 2. Redistributions in binary form must reproduce the above copyright notice,

 *    this list of conditions and the following disclaimer in the documentation

 *    and/or other materials provided with the distribution.

 * 3. The name of the author may not be used to endorse or promote products

 *    derived from this software without specific prior written permission.

 *

 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED

 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF

 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT

 * SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,

 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT

 * OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS

 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN

 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING

 * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY

 * OF SUCH DAMAGE.

 *

 * This file is part of the lwIP TCP/IP stack.

 *

 * Author: Adam Dunkels <adam@sics.se>

 */

#include "lwip/opt.h"

#include <string.h> /* memset */

#include <stdlib.h> /* atoi */

#include "lwip/def.h"

#include "lwip/ip_addr.h"

#include "lwip/ip6_addr.h"

#include "lwip/netif.h"

#include "lwip/priv/tcp_priv.h"

#include "lwip/udp.h"

#include "lwip/priv/raw_priv.h"

#include "lwip/snmp.h"

#include "lwip/igmp.h"

#include "lwip/etharp.h"

#include "lwip/stats.h"

#include "lwip/sys.h"

#include "lwip/ip.h"

#if ENABLE_LOOPBACK

#if LWIP_NETIF_LOOPBACK_MULTITHREADING

#include "lwip/tcpip.h"

#endif /* LWIP_NETIF_LOOPBACK_MULTITHREADING */

#endif /* ENABLE_LOOPBACK */

#include "netif/ethernet.h"

#if LWIP_AUTOIP

#include "lwip/autoip.h"

#endif /* LWIP_AUTOIP */

#if LWIP_DHCP

#include "lwip/dhcp.h"

#endif /* LWIP_DHCP */

#if LWIP_IPV6_DHCP6

#include "lwip/dhcp6.h"

#endif /* LWIP_IPV6_DHCP6 */

#if LWIP_IPV6_MLD

#include "lwip/mld6.h"

#endif /* LWIP_IPV6_MLD */

#if LWIP_IPV6

#include "lwip/nd6.h"

#endif

#if LWIP_NETIF_STATUS_CALLBACK

#define NETIF_STATUS_CALLBACK(n) do{ if (n->status_callback) { (n->status_callback)(n); }}while(0)

#else

#define NETIF_STATUS_CALLBACK(n)

#endif /* LWIP_NETIF_STATUS_CALLBACK */

#if LWIP_NETIF_LINK_CALLBACK

#define NETIF_LINK_CALLBACK(n) do{ if (n->link_callback) { (n->link_callback)(n); }}while(0)

#else

#define NETIF_LINK_CALLBACK(n)

#endif /* LWIP_NETIF_LINK_CALLBACK */

#if LWIP_NETIF_EXT_STATUS_CALLBACK

static netif_ext_callback_t *ext_callback;

#endif

#if !LWIP_SINGLE_NETIF

struct netif *netif_list;

#endif /* !LWIP_SINGLE_NETIF */

struct netif *netif_default;

#define netif_index_to_num(index)   ((index) - 1)

static u8_t netif_num;

#if LWIP_NUM_NETIF_CLIENT_DATA > 0

static u8_t netif_client_id;

#endif

#define NETIF_REPORT_TYPE_IPV4  0x01

#define NETIF_REPORT_TYPE_IPV6  0x02

static void netif_issue_reports(struct netif *netif, u8_t report_type);

#if LWIP_IPV6

static err_t netif_null_output_ip6(struct netif *netif, struct pbuf *p, const ip6_addr_t *ipaddr);

#endif /* LWIP_IPV6 */

#if LWIP_IPV4

static err_t netif_null_output_ip4(struct netif *netif, struct pbuf *p, const ip4_addr_t *ipaddr);

#endif /* LWIP_IPV4 */

#if LWIP_HAVE_LOOPIF

#if LWIP_IPV4

static err_t netif_loop_output_ipv4(struct netif *netif, struct pbuf *p, const ip4_addr_t *addr);

#endif

#if LWIP_IPV6

static err_t netif_loop_output_ipv6(struct netif *netif, struct pbuf *p, const ip6_addr_t *addr);

#endif

static struct netif loop_netif;

/**

 * Initialize a lwip network interface structure for a loopback interface

 *

 * @param netif the lwip network interface structure for this loopif

 * @return ERR_OK if the loopif is initialized

 *         ERR_MEM if private data couldn't be allocated

 */

static err_t

netif_loopif_init(struct netif *netif)

{

  LWIP_ASSERT("netif_loopif_init: invalid netif", netif != NULL);

  /* initialize the snmp variables and counters inside the struct netif

   * ifSpeed: no assumption can be made!

   */

  MIB2_INIT_NETIF(netif, snmp_ifType_softwareLoopback, 0);

  netif->name[0] = 'l';

  netif->name[1] = 'o';

#if LWIP_IPV4

  netif->output = netif_loop_output_ipv4;

#endif

#if LWIP_IPV6

  netif->output_ip6 = netif_loop_output_ipv6;

#endif

#if LWIP_LOOPIF_MULTICAST

  netif_set_flags(netif, NETIF_FLAG_IGMP);

#endif

  NETIF_SET_CHECKSUM_CTRL(netif, NETIF_CHECKSUM_DISABLE_ALL);

  return ERR_OK;

}

#endif /* LWIP_HAVE_LOOPIF */

void

netif_init(void)

{

#if LWIP_HAVE_LOOPIF

#if LWIP_IPV4

#define LOOPIF_ADDRINIT &loop_ipaddr, &loop_netmask, &loop_gw,

  ip4_addr_t loop_ipaddr, loop_netmask, loop_gw;

  IP4_ADDR(&loop_gw, 127, 0, 0, 1);

  IP4_ADDR(&loop_ipaddr, 127, 0, 0, 1);

  IP4_ADDR(&loop_netmask, 255, 0, 0, 0);

#else /* LWIP_IPV4 */

#define LOOPIF_ADDRINIT

#endif /* LWIP_IPV4 */

#if NO_SYS

  netif_add(&loop_netif, LOOPIF_ADDRINIT NULL, netif_loopif_init, ip_input);

#else  /* NO_SYS */

  netif_add(&loop_netif, LOOPIF_ADDRINIT NULL, netif_loopif_init, tcpip_input);

#endif /* NO_SYS */

#if LWIP_IPV6

  IP_ADDR6_HOST(loop_netif.ip6_addr, 0, 0, 0, 0x00000001UL);

  loop_netif.ip6_addr_state[0] = IP6_ADDR_VALID;

#endif /* LWIP_IPV6 */

  netif_set_link_up(&loop_netif);

  netif_set_up(&loop_netif);

#endif /* LWIP_HAVE_LOOPIF */

}

/**

 * @ingroup lwip_nosys

 * Forwards a received packet for input processing with

 * ethernet_input() or ip_input() depending on netif flags.

 * Don't call directly, pass to netif_add() and call

 * netif->input().

 * Only works if the netif driver correctly sets

 * NETIF_FLAG_ETHARP and/or NETIF_FLAG_ETHERNET flag!

 */

err_t

netif_input(struct pbuf *p, struct netif *inp)

{

  LWIP_ASSERT_CORE_LOCKED();

  LWIP_ASSERT("netif_input: invalid pbuf", p != NULL);

  LWIP_ASSERT("netif_input: invalid netif", inp != NULL);

#if LWIP_ETHERNET

  if (inp->flags & (NETIF_FLAG_ETHARP | NETIF_FLAG_ETHERNET)) {

    return ethernet_input(p, inp);

  } else

#endif /* LWIP_ETHERNET */

    return ip_input(p, inp);

}

/**

 * @ingroup netif

 * Add a network interface to the list of lwIP netifs.

 *

 * Same as @ref netif_add but without IPv4 addresses

 */

struct netif *

netif_add_noaddr(struct netif *netif, void *state, netif_init_fn init, netif_input_fn input)

{

  return netif_add(netif,

#if LWIP_IPV4

                   NULL, NULL, NULL,

#endif /* LWIP_IPV4*/

                   state, init, input);

}

/**

 * @ingroup netif

 * Add a network interface to the list of lwIP netifs.

 *

 * @param netif a pre-allocated netif structure

 * @param ipaddr IP address for the new netif

 * @param netmask network mask for the new netif

 * @param gw default gateway IP address for the new netif

 * @param state opaque data passed to the new netif

 * @param init callback function that initializes the interface

 * @param input callback function that is called to pass

 * ingress packets up in the protocol layer stack.\n

 * It is recommended to use a function that passes the input directly

 * to the stack (netif_input(), NO_SYS=1 mode) or via sending a

 * message to TCPIP thread (tcpip_input(), NO_SYS=0 mode).\n

 * These functions use netif flags NETIF_FLAG_ETHARP and NETIF_FLAG_ETHERNET

 * to decide whether to forward to ethernet_input() or ip_input().

 * In other words, the functions only work when the netif

 * driver is implemented correctly!\n

 * Most members of struct netif should be be initialized by the

 * netif init function = netif driver (init parameter of this function).\n

 * IPv6: Don't forget to call netif_create_ip6_linklocal_address() after

 * setting the MAC address in struct netif.hwaddr

 * (IPv6 requires a link-local address).

 *

 * @return netif, or NULL if failed.

 */

struct netif *

netif_add(struct netif *netif,

#if LWIP_IPV4

          const ip4_addr_t *ipaddr, const ip4_addr_t *netmask, const ip4_addr_t *gw,

#endif /* LWIP_IPV4 */

          void *state, netif_init_fn init, netif_input_fn input)

{

#if LWIP_IPV6

  s8_t i;

#endif

  LWIP_ASSERT_CORE_LOCKED();

#if LWIP_SINGLE_NETIF

  if (netif_default != NULL) {

    LWIP_ASSERT("single netif already set", 0);

    return NULL;

  }

#endif

  LWIP_ERROR("netif_add: invalid netif", netif != NULL, return NULL);

  LWIP_ERROR("netif_add: No init function given", init != NULL, return NULL);

#if LWIP_IPV4

  if (ipaddr == NULL) {

    ipaddr = ip_2_ip4(IP4_ADDR_ANY);

  }

  if (netmask == NULL) {

    netmask = ip_2_ip4(IP4_ADDR_ANY);

  }

  if (gw == NULL) {

    gw = ip_2_ip4(IP4_ADDR_ANY);

  }

  /* reset new interface configuration state */

  ip_addr_set_zero_ip4(&netif->ip_addr);

  ip_addr_set_zero_ip4(&netif->netmask);

  ip_addr_set_zero_ip4(&netif->gw);

  netif->output = netif_null_output_ip4;

#endif /* LWIP_IPV4 */

#if LWIP_IPV6

  for (i = 0; i < LWIP_IPV6_NUM_ADDRESSES; i++) {

    ip_addr_set_zero_ip6(&netif->ip6_addr[i]);

    netif->ip6_addr_state[i] = IP6_ADDR_INVALID;

#if LWIP_IPV6_ADDRESS_LIFETIMES

    netif->ip6_addr_valid_life[i] = IP6_ADDR_LIFE_STATIC;

    netif->ip6_addr_pref_life[i] = IP6_ADDR_LIFE_STATIC;

#endif /* LWIP_IPV6_ADDRESS_LIFETIMES */

  }

  netif->output_ip6 = netif_null_output_ip6;

#endif /* LWIP_IPV6 */

  NETIF_SET_CHECKSUM_CTRL(netif, NETIF_CHECKSUM_ENABLE_ALL);

  netif->mtu = 0;

  netif->flags = 0;

#ifdef netif_get_client_data

  memset(netif->client_data, 0, sizeof(netif->client_data));

#endif /* LWIP_NUM_NETIF_CLIENT_DATA */

#if LWIP_IPV6

#if LWIP_IPV6_AUTOCONFIG

  /* IPv6 address autoconfiguration not enabled by default */

  netif->ip6_autoconfig_enabled = 0;

#endif /* LWIP_IPV6_AUTOCONFIG */

  nd6_restart_netif(netif);

#endif /* LWIP_IPV6 */

#if LWIP_NETIF_STATUS_CALLBACK

  netif->status_callback = NULL;

#endif /* LWIP_NETIF_STATUS_CALLBACK */

#if LWIP_NETIF_LINK_CALLBACK

  netif->link_callback = NULL;

#endif /* LWIP_NETIF_LINK_CALLBACK */

#if LWIP_IGMP

  netif->igmp_mac_filter = NULL;

#endif /* LWIP_IGMP */

#if LWIP_IPV6 && LWIP_IPV6_MLD

  netif->mld_mac_filter = NULL;

#endif /* LWIP_IPV6 && LWIP_IPV6_MLD */

#if ENABLE_LOOPBACK

  netif->loop_first = NULL;

  netif->loop_last = NULL;

#endif /* ENABLE_LOOPBACK */

  /* remember netif specific state information data */

  netif->state = state;

  netif->num = netif_num;

  netif->input = input;

  NETIF_RESET_HINTS(netif);

#if ENABLE_LOOPBACK && LWIP_LOOPBACK_MAX_PBUFS

  netif->loop_cnt_current = 0;

#endif /* ENABLE_LOOPBACK && LWIP_LOOPBACK_MAX_PBUFS */

#if LWIP_IPV4

  netif_set_addr(netif, ipaddr, netmask, gw);

#endif /* LWIP_IPV4 */

  /* call user specified initialization function for netif */

  if (init(netif) != ERR_OK) {

    return NULL;

  }

#if LWIP_IPV6 && LWIP_ND6_ALLOW_RA_UPDATES

  /* Initialize the MTU for IPv6 to the one set by the netif driver.

     This can be updated later by RA. */

  netif->mtu6 = netif->mtu;

#endif /* LWIP_IPV6 && LWIP_ND6_ALLOW_RA_UPDATES */

#if !LWIP_SINGLE_NETIF

  /* Assign a unique netif number in the range [0..254], so that (num+1) can

     serve as an interface index that fits in a u8_t.

     We assume that the new netif has not yet been added to the list here.

     This algorithm is O(n^2), but that should be OK for lwIP.

     */

  {

    struct netif *netif2;

    int num_netifs;

    do {

      if (netif->num == 255) {

        netif->num = 0;

      }

      num_netifs = 0;

      for (netif2 = netif_list; netif2 != NULL; netif2 = netif2->next) {

        LWIP_ASSERT("netif already added", netif2 != netif);

        num_netifs++;

        LWIP_ASSERT("too many netifs, max. supported number is 255", num_netifs <= 255);

        if (netif2->num == netif->num) {

          netif->num++;

          break;

        }

      }

    } while (netif2 != NULL);

  }

  if (netif->num == 254) {

    netif_num = 0;

  } else {

    netif_num = (u8_t)(netif->num + 1);

  }

  /* add this netif to the list */

  netif->next = netif_list;

  netif_list = netif;

#endif /* "LWIP_SINGLE_NETIF */

  mib2_netif_added(netif);

#if LWIP_IGMP

  /* start IGMP processing */

  if (netif->flags & NETIF_FLAG_IGMP) {

    igmp_start(netif);

  }

#endif /* LWIP_IGMP */

  LWIP_DEBUGF(NETIF_DEBUG, ("netif: added interface %c%c IP",

                            netif->name[0], netif->name[1]));

#if LWIP_IPV4

  LWIP_DEBUGF(NETIF_DEBUG, (" addr "));

  ip4_addr_debug_print(NETIF_DEBUG, ipaddr);

  LWIP_DEBUGF(NETIF_DEBUG, (" netmask "));

  ip4_addr_debug_print(NETIF_DEBUG, netmask);

  LWIP_DEBUGF(NETIF_DEBUG, (" gw "));

  ip4_addr_debug_print(NETIF_DEBUG, gw);

#endif /* LWIP_IPV4 */

  LWIP_DEBUGF(NETIF_DEBUG, ("\n"));

  netif_invoke_ext_callback(netif, LWIP_NSC_NETIF_ADDED, NULL);

  return netif;

}

static void

netif_do_ip_addr_changed(const ip_addr_t *old_addr, const ip_addr_t *new_addr)

{

#if LWIP_TCP

  tcp_netif_ip_addr_changed(old_addr, new_addr);

#endif /* LWIP_TCP */

#if LWIP_UDP

  udp_netif_ip_addr_changed(old_addr, new_addr);

#endif /* LWIP_UDP */

#if LWIP_RAW

  raw_netif_ip_addr_changed(old_addr, new_addr);

#endif /* LWIP_RAW */

}

#if LWIP_IPV4

static int

netif_do_set_ipaddr(struct netif *netif, const ip4_addr_t *ipaddr, ip_addr_t *old_addr)

{

  LWIP_ASSERT("invalid pointer", ipaddr != NULL);

  LWIP_ASSERT("invalid pointer", old_addr != NULL);

  /* address is actually being changed? */

  if (ip4_addr_cmp(ipaddr, netif_ip4_addr(netif)) == 0) {

    ip_addr_t new_addr;

    *ip_2_ip4(&new_addr) = *ipaddr;

    IP_SET_TYPE_VAL(new_addr, IPADDR_TYPE_V4);

    ip_addr_copy(*old_addr, *netif_ip_addr4(netif));

    LWIP_DEBUGF(NETIF_DEBUG | LWIP_DBG_STATE, ("netif_set_ipaddr: netif address being changed\n"));

    netif_do_ip_addr_changed(old_addr, &new_addr);

    mib2_remove_ip4(netif);

    mib2_remove_route_ip4(0, netif);

    /* set new IP address to netif */

    ip4_addr_set(ip_2_ip4(&netif->ip_addr), ipaddr);

    IP_SET_TYPE_VAL(netif->ip_addr, IPADDR_TYPE_V4);

    mib2_add_ip4(netif);

    mib2_add_route_ip4(0, netif);

    netif_issue_reports(netif, NETIF_REPORT_TYPE_IPV4);

    NETIF_STATUS_CALLBACK(netif);

    return 1; /* address changed */

  }

  return 0; /* address unchanged */

}

/**

 * @ingroup netif_ip4

 * Change the IP address of a network interface

 *

 * @param netif the network interface to change

 * @param ipaddr the new IP address

 *

 * @note call netif_set_addr() if you also want to change netmask and

 * default gateway

 */

void

netif_set_ipaddr(struct netif *netif, const ip4_addr_t *ipaddr)

{

  ip_addr_t old_addr;

  LWIP_ERROR("netif_set_ipaddr: invalid netif", netif != NULL, return);

  /* Don't propagate NULL pointer (IPv4 ANY) to subsequent functions */

  if (ipaddr == NULL) {

    ipaddr = IP4_ADDR_ANY4;

  }

  LWIP_ASSERT_CORE_LOCKED();

  if (netif_do_set_ipaddr(netif, ipaddr, &old_addr)) {

#if LWIP_NETIF_EXT_STATUS_CALLBACK

    netif_ext_callback_args_t args;

    args.ipv4_changed.old_address = &old_addr;

    netif_invoke_ext_callback(netif, LWIP_NSC_IPV4_ADDRESS_CHANGED, &args);

#endif

  }

}

static int

netif_do_set_netmask(struct netif *netif, const ip4_addr_t *netmask, ip_addr_t *old_nm)

{

  /* address is actually being changed? */

  if (ip4_addr_cmp(netmask, netif_ip4_netmask(netif)) == 0) {

#if LWIP_NETIF_EXT_STATUS_CALLBACK

    LWIP_ASSERT("invalid pointer", old_nm != NULL);

    ip_addr_copy(*old_nm, *netif_ip_netmask4(netif));

#else

    LWIP_UNUSED_ARG(old_nm);

#endif

    mib2_remove_route_ip4(0, netif);

    /* set new netmask to netif */

    ip4_addr_set(ip_2_ip4(&netif->netmask), netmask);

    IP_SET_TYPE_VAL(netif->netmask, IPADDR_TYPE_V4);

    mib2_add_route_ip4(0, netif);

    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",

                netif->name[0], netif->name[1],

                ip4_addr1_16(netif_ip4_netmask(netif)),

                ip4_addr2_16(netif_ip4_netmask(netif)),

                ip4_addr3_16(netif_ip4_netmask(netif)),

                ip4_addr4_16(netif_ip4_netmask(netif))));

    return 1; /* netmask changed */

  }

  return 0; /* netmask unchanged */

}

/**

 * @ingroup netif_ip4

 * Change the netmask of a network interface

 *

 * @param netif the network interface to change

 * @param netmask the new netmask

 *

 * @note call netif_set_addr() if you also want to change ip address and

 * default gateway

 */

void

netif_set_netmask(struct netif *netif, const ip4_addr_t *netmask)

{

#if LWIP_NETIF_EXT_STATUS_CALLBACK

  ip_addr_t old_nm_val;

  ip_addr_t *old_nm = &old_nm_val;

#else

  ip_addr_t *old_nm = NULL;

#endif

  LWIP_ASSERT_CORE_LOCKED();

  LWIP_ERROR("netif_set_netmask: invalid netif", netif != NULL, return);

  /* Don't propagate NULL pointer (IPv4 ANY) to subsequent functions */

  if (netmask == NULL) {

    netmask = IP4_ADDR_ANY4;

  }

  if (netif_do_set_netmask(netif, netmask, old_nm)) {

#if LWIP_NETIF_EXT_STATUS_CALLBACK

    netif_ext_callback_args_t args;

    args.ipv4_changed.old_netmask = old_nm;

    netif_invoke_ext_callback(netif, LWIP_NSC_IPV4_NETMASK_CHANGED, &args);

#endif

  }

}

static int

netif_do_set_gw(struct netif *netif, const ip4_addr_t *gw, ip_addr_t *old_gw)

{

  /* address is actually being changed? */

  if (ip4_addr_cmp(gw, netif_ip4_gw(netif)) == 0) {

#if LWIP_NETIF_EXT_STATUS_CALLBACK

    LWIP_ASSERT("invalid pointer", old_gw != NULL);

    ip_addr_copy(*old_gw, *netif_ip_gw4(netif));

#else

    LWIP_UNUSED_ARG(old_gw);

#endif

    ip4_addr_set(ip_2_ip4(&netif->gw), gw);

    IP_SET_TYPE_VAL(netif->gw, IPADDR_TYPE_V4);

    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",

                netif->name[0], netif->name[1],

                ip4_addr1_16(netif_ip4_gw(netif)),

                ip4_addr2_16(netif_ip4_gw(netif)),

                ip4_addr3_16(netif_ip4_gw(netif)),

                ip4_addr4_16(netif_ip4_gw(netif))));

    return 1; /* gateway changed */

  }

  return 0; /* gateway unchanged */

}

/**

 * @ingroup netif_ip4

 * Change the default gateway for a network interface

 *

 * @param netif the network interface to change

 * @param gw the new default gateway

 *

 * @note call netif_set_addr() if you also want to change ip address and netmask

 */

void

netif_set_gw(struct netif *netif, const ip4_addr_t *gw)

{

#if LWIP_NETIF_EXT_STATUS_CALLBACK

  ip_addr_t old_gw_val;

  ip_addr_t *old_gw = &old_gw_val;

#else

  ip_addr_t *old_gw = NULL;

#endif

  LWIP_ASSERT_CORE_LOCKED();

  LWIP_ERROR("netif_set_gw: invalid netif", netif != NULL, return);

  /* Don't propagate NULL pointer (IPv4 ANY) to subsequent functions */

  if (gw == NULL) {

    gw = IP4_ADDR_ANY4;

  }

  if (netif_do_set_gw(netif, gw, old_gw)) {

#if LWIP_NETIF_EXT_STATUS_CALLBACK

    netif_ext_callback_args_t args;

    args.ipv4_changed.old_gw = old_gw;

    netif_invoke_ext_callback(netif, LWIP_NSC_IPV4_GATEWAY_CHANGED, &args);

#endif

  }

}

/**

 * @ingroup netif_ip4

 * Change IP address configuration for a network interface (including netmask

 * and default gateway).

 *

 * @param netif the network interface to change

 * @param ipaddr the new IP address

 * @param netmask the new netmask

 * @param gw the new default gateway

 */

void

netif_set_addr(struct netif *netif, const ip4_addr_t *ipaddr, const ip4_addr_t *netmask,

               const ip4_addr_t *gw)

{

#if LWIP_NETIF_EXT_STATUS_CALLBACK

  netif_nsc_reason_t change_reason = LWIP_NSC_NONE;

  netif_ext_callback_args_t cb_args;

  ip_addr_t old_nm_val;

  ip_addr_t old_gw_val;

  ip_addr_t *old_nm = &old_nm_val;

  ip_addr_t *old_gw = &old_gw_val;

#else

  ip_addr_t *old_nm = NULL;

  ip_addr_t *old_gw = NULL;

#endif

  ip_addr_t old_addr;

  int remove;

  LWIP_ASSERT_CORE_LOCKED();

  /* Don't propagate NULL pointer (IPv4 ANY) to subsequent functions */

  if (ipaddr == NULL) {

    ipaddr = IP4_ADDR_ANY4;

  }

  if (netmask == NULL) {

    netmask = IP4_ADDR_ANY4;

  }

  if (gw == NULL) {

    gw = IP4_ADDR_ANY4;

  }

  remove = ip4_addr_isany(ipaddr);

  if (remove) {

    /* when removing an address, we have to remove it *before* changing netmask/gw

       to ensure that tcp RST segment can be sent correctly */

    if (netif_do_set_ipaddr(netif, ipaddr, &old_addr)) {

#if LWIP_NETIF_EXT_STATUS_CALLBACK

      change_reason |= LWIP_NSC_IPV4_ADDRESS_CHANGED;

      cb_args.ipv4_changed.old_address = &old_addr;

#endif

    }

  }

  if (netif_do_set_netmask(netif, netmask, old_nm)) {

#if LWIP_NETIF_EXT_STATUS_CALLBACK

    change_reason |= LWIP_NSC_IPV4_NETMASK_CHANGED;

    cb_args.ipv4_changed.old_netmask = old_nm;

#endif

  }

  if (netif_do_set_gw(netif, gw, old_gw)) {

#if LWIP_NETIF_EXT_STATUS_CALLBACK

    change_reason |= LWIP_NSC_IPV4_GATEWAY_CHANGED;

    cb_args.ipv4_changed.old_gw = old_gw;

#endif

  }

  if (!remove) {

    /* set ipaddr last to ensure netmask/gw have been set when status callback is called */

    if (netif_do_set_ipaddr(netif, ipaddr, &old_addr)) {

#if LWIP_NETIF_EXT_STATUS_CALLBACK

      change_reason |= LWIP_NSC_IPV4_ADDRESS_CHANGED;

      cb_args.ipv4_changed.old_address = &old_addr;

#endif

    }

  }

#if LWIP_NETIF_EXT_STATUS_CALLBACK

  if (change_reason != LWIP_NSC_NONE) {

    change_reason |= LWIP_NSC_IPV4_SETTINGS_CHANGED;

    netif_invoke_ext_callback(netif, change_reason, &cb_args);

  }

#endif

}

#endif /* LWIP_IPV4*/

/**

 * @ingroup netif

 * Remove a network interface from the list of lwIP netifs.

 *

 * @param netif the network interface to remove

 */

void

netif_remove(struct netif *netif)

{

#if LWIP_IPV6

  int i;

#endif

  LWIP_ASSERT_CORE_LOCKED();

  if (netif == NULL) {

    return;

  }

  netif_invoke_ext_callback(netif, LWIP_NSC_NETIF_REMOVED, NULL);

#if LWIP_IPV4

  if (!ip4_addr_isany_val(*netif_ip4_addr(netif))) {

    netif_do_ip_addr_changed(netif_ip_addr4(netif), NULL);

  }

#if LWIP_IGMP

  /* stop IGMP processing */

  if (netif->flags & NETIF_FLAG_IGMP) {

    igmp_stop(netif);

  }

#endif /* LWIP_IGMP */

#endif /* LWIP_IPV4*/

#if LWIP_IPV6

  for (i = 0; i < LWIP_IPV6_NUM_ADDRESSES; i++) {

    if (ip6_addr_isvalid(netif_ip6_addr_state(netif, i))) {

      netif_do_ip_addr_changed(netif_ip_addr6(netif, i), NULL);

    }

  }

#if LWIP_IPV6_MLD

  /* stop MLD processing */

  mld6_stop(netif);

#endif /* LWIP_IPV6_MLD */

#endif /* LWIP_IPV6 */

  if (netif_is_up(netif)) {

    /* set netif down before removing (call callback function) */

    netif_set_down(netif);

  }

  mib2_remove_ip4(netif);

  /* this netif is default? */

  if (netif_default == netif) {

    /* reset default netif */

    netif_set_default(NULL);

  }

#if !LWIP_SINGLE_NETIF

  /*  is it the first netif? */

  if (netif_list == netif) {

    netif_list = netif->next;

  } else {

    /*  look for netif further down the list */

    struct netif *tmp_netif;

    NETIF_FOREACH(tmp_netif) {

      if (tmp_netif->next == netif) {

        tmp_netif->next = netif->next;

        break;

      }

    }

    if (tmp_netif == NULL) {

      return; /* netif is not on the list */

    }

  }

#endif /* !LWIP_SINGLE_NETIF */

  mib2_netif_removed(netif);

#if LWIP_NETIF_REMOVE_CALLBACK

  if (netif->remove_callback) {

    netif->remove_callback(netif);

  }

#endif /* LWIP_NETIF_REMOVE_CALLBACK */

  LWIP_DEBUGF( NETIF_DEBUG, ("netif_remove: removed netif\n") );

}

/**

 * @ingroup netif

 * Set a network interface as the default network interface

 * (used to output all packets for which no specific route is found)

 *

 * @param netif the default network interface

 */

void

netif_set_default(struct netif *netif)

{

  LWIP_ASSERT_CORE_LOCKED();

  if (netif == NULL) {

    /* remove default route */

    mib2_remove_route_ip4(1, netif);

  } else {

    /* install default route */

    mib2_add_route_ip4(1, netif);

  }

  netif_default = netif;

  LWIP_DEBUGF(NETIF_DEBUG, ("netif: setting default interface %c%c\n",

                            netif ? netif->name[0] : '\'', netif ? netif->name[1] : '\''));

}

/**

 * @ingroup netif

 * Bring an interface up, available for processing

 * traffic.

 */

void

netif_set_up(struct netif *netif)

{

  LWIP_ASSERT_CORE_LOCKED();

  LWIP_ERROR("netif_set_up: invalid netif", netif != NULL, return);

  if (!(netif->flags & NETIF_FLAG_UP)) {

    netif_set_flags(netif, NETIF_FLAG_UP);

    MIB2_COPY_SYSUPTIME_TO(&netif->ts);

    NETIF_STATUS_CALLBACK(netif);

#if LWIP_NETIF_EXT_STATUS_CALLBACK

    {

      netif_ext_callback_args_t args;

      args.status_changed.state = 1;

      netif_invoke_ext_callback(netif, LWIP_NSC_STATUS_CHANGED, &args);

    }

#endif

    netif_issue_reports(netif, NETIF_REPORT_TYPE_IPV4 | NETIF_REPORT_TYPE_IPV6);

#if LWIP_IPV6

    nd6_restart_netif(netif);

#endif /* LWIP_IPV6 */

  }

}

/** Send ARP/IGMP/MLD/RS events, e.g. on link-up/netif-up or addr-change

 */

static void

netif_issue_reports(struct netif *netif, u8_t report_type)

{

  LWIP_ASSERT("netif_issue_reports: invalid netif", netif != NULL);

  /* Only send reports when both link and admin states are up */

  if (!(netif->flags & NETIF_FLAG_LINK_UP) ||

      !(netif->flags & NETIF_FLAG_UP)) {

    return;

  }

#if LWIP_IPV4

  if ((report_type & NETIF_REPORT_TYPE_IPV4) &&

      !ip4_addr_isany_val(*netif_ip4_addr(netif))) {

#if LWIP_ARP

    /* For Ethernet network interfaces, we would like to send a "gratuitous ARP" */

    if (netif->flags & (NETIF_FLAG_ETHARP)) {

      etharp_gratuitous(netif);

    }

#endif /* LWIP_ARP */

#if LWIP_IGMP

    /* resend IGMP memberships */

    if (netif->flags & NETIF_FLAG_IGMP) {

      igmp_report_groups(netif);

    }

#endif /* LWIP_IGMP */

  }

#endif /* LWIP_IPV4 */

#if LWIP_IPV6

  if (report_type & NETIF_REPORT_TYPE_IPV6) {

#if LWIP_IPV6_MLD

    /* send mld memberships */

    mld6_report_groups(netif);

#endif /* LWIP_IPV6_MLD */

  }

#endif /* LWIP_IPV6 */

}

/**

 * @ingroup netif

 * Bring an interface down, disabling any traffic processing.

 */

void

netif_set_down(struct netif *netif)

{

  LWIP_ASSERT_CORE_LOCKED();

  LWIP_ERROR("netif_set_down: invalid netif", netif != NULL, return);

  if (netif->flags & NETIF_FLAG_UP) {

#if LWIP_NETIF_EXT_STATUS_CALLBACK

    {

      netif_ext_callback_args_t args;

      args.status_changed.state = 0;

      netif_invoke_ext_callback(netif, LWIP_NSC_STATUS_CHANGED, &args);

    }

#endif

    netif_clear_flags(netif, NETIF_FLAG_UP);

    MIB2_COPY_SYSUPTIME_TO(&netif->ts);

#if LWIP_IPV4 && LWIP_ARP

    if (netif->flags & NETIF_FLAG_ETHARP) {

      etharp_cleanup_netif(netif);

    }

#endif /* LWIP_IPV4 && LWIP_ARP */

#if LWIP_IPV6

    nd6_cleanup_netif(netif);

#endif /* LWIP_IPV6 */

    NETIF_STATUS_CALLBACK(netif);

  }

}

#if LWIP_NETIF_STATUS_CALLBACK

/**

 * @ingroup netif

 * Set callback to be called when interface is brought up/down or address is changed while up

 */

void

netif_set_status_callback(struct netif *netif, netif_status_callback_fn status_callback)

{

  LWIP_ASSERT_CORE_LOCKED();

  if (netif) {

    netif->status_callback = status_callback;

  }

}

#endif /* LWIP_NETIF_STATUS_CALLBACK */

#if LWIP_NETIF_REMOVE_CALLBACK

/**

 * @ingroup netif

 * Set callback to be called when the interface has been removed

 */

void

netif_set_remove_callback(struct netif *netif, netif_status_callback_fn remove_callback)

{

  LWIP_ASSERT_CORE_LOCKED();

  if (netif) {

    netif->remove_callback = remove_callback;

  }

}

#endif /* LWIP_NETIF_REMOVE_CALLBACK */

/**

 * @ingroup netif

 * Called by a driver when its link goes up

 */

void

netif_set_link_up(struct netif *netif)

{

  LWIP_ASSERT_CORE_LOCKED();

  LWIP_ERROR("netif_set_link_up: invalid netif", netif != NULL, return);

  if (!(netif->flags & NETIF_FLAG_LINK_UP)) {

    netif_set_flags(netif, NETIF_FLAG_LINK_UP);

#if LWIP_DHCP

    dhcp_network_changed(netif);

#endif /* LWIP_DHCP */

#if LWIP_AUTOIP

    autoip_network_changed(netif);

#endif /* LWIP_AUTOIP */

    netif_issue_reports(netif, NETIF_REPORT_TYPE_IPV4 | NETIF_REPORT_TYPE_IPV6);

#if LWIP_IPV6

    nd6_restart_netif(netif);

#endif /* LWIP_IPV6 */

    NETIF_LINK_CALLBACK(netif);

#if LWIP_NETIF_EXT_STATUS_CALLBACK

    {

      netif_ext_callback_args_t args;