Network interface (NETIF)

Collaboration diagram for Network interface (NETIF):

Modules
	IPv4 address handling
	IPv6 address handling
	Client data handling
	Flags
	MIB2 statistics

Classes
union	netif_ext_callback_args_t

Macros
#define	netif_is_up(netif)   (((netif)->flags & NETIF_FLAG_UP) ? (u8_t)1 : (u8_t)0)

Typedefs
typedef u16_t	netif_nsc_reason_t
typedef void(*	netif_ext_callback_fn) (struct netif *netif, netif_nsc_reason_t reason, const netif_ext_callback_args_t *args)

Functions
struct netif *	netif_add_noaddr (struct netif *netif, void *state, netif_init_fn init, netif_input_fn input)
struct netif *	netif_add (struct netif *netif, void *state, netif_init_fn init, netif_input_fn input)
void	netif_remove (struct netif *netif)
void	netif_set_default (struct netif *netif)
void	netif_set_up (struct netif *netif)
void	netif_set_down (struct netif *netif)
void	netif_set_link_up (struct netif *netif)
void	netif_set_link_down (struct netif *netif)
u8_t	netif_name_to_index (const char *name)
char *	netif_index_to_name (u8_t idx, char *name)
struct netif *	netif_get_by_index (u8_t idx)
struct netif *	netif_find (const char *name)

Detailed Description

Macro Definition Documentation

netif_is_up

#define netif_is_up

(

netif

)

(((netif)->flags & NETIF_FLAG_UP) ? (u8_t)1 : (u8_t)0)

Ask if an interface is up

Definition at line 479 of file netif.h.

Typedef Documentation

netif_ext_callback_fn

typedef void(* netif_ext_callback_fn) (struct netif *netif, netif_nsc_reason_t reason, const netif_ext_callback_args_t *args)

Function used for extended netif status callbacks Note: When parsing reason argument, keep in mind that more reasons may be added in the future!

Parameters

netif	netif that is affected by change
reason	change reason
args	depends on reason, see reason description

Definition at line 668 of file netif.h.

netif_nsc_reason_t

typedef u16_t netif_nsc_reason_t

Extended netif status callback (NSC) reasons flags. May be extended in the future!

Definition at line 586 of file netif.h.

Function Documentation

netif_add()

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

Add a network interface to the list of lwIP netifs.

Parameters

netif	a pre-allocated netif structure
ipaddr	IP address for the new netif
netmask	network mask for the new netif
gw	default gateway IP address for the new netif
state	opaque data passed to the new netif
init	callback function that initializes the interface
input	callback function that is called to pass ingress packets up in the protocol layer stack. 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). 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! Most members of struct netif should be be initialized by the netif init function = netif driver (init parameter of this function). 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).

Returns

netif, or NULL if failed.

Definition at line 287 of file netif.c.

{
#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 should be enabled by default */
  netif->ip6_autoconfig_enabled = 1;
#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 */
 
  /* remember netif specific state information data */
  netif->state = state;
  netif->num = netif_num;
  netif->input = input;
 
#if LWIP_ACD
  netif->acd_list = NULL;
#endif /* LWIP_ACD */
  NETIF_RESET_HINTS(netif);
#if ENABLE_LOOPBACK
  netif->loop_first = NULL;
  netif->loop_last = NULL;
#if LWIP_LOOPBACK_MAX_PBUFS
  netif->loop_cnt_current = 0;
#endif /* LWIP_LOOPBACK_MAX_PBUFS */
#if LWIP_NETIF_LOOPBACK_MULTITHREADING
  netif->reschedule_poll = 0;
#endif /* LWIP_NETIF_LOOPBACK_MULTITHREADING */
#endif /* ENABLE_LOOPBACK */
 
#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;
}

Referenced by default_netif_add(), lwip_fuzztest(), main(), netif_add_noaddr(), netif_init(), START_TEST(), TCPRegisterInterface(), and test_netif_add().

netif_add_noaddr()

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

Add a network interface to the list of lwIP netifs.

Same as netif_add but without IPv4 addresses

Definition at line 250 of file netif.c.

{
  return netif_add(netif,
#if LWIP_IPV4
                   NULL, NULL, NULL,
#endif /* LWIP_IPV4*/
                   state, init, input);
}

Referenced by START_TEST().

netif_find()

struct netif * netif_find

(

const char *

name

)

Find a network interface by searching for its name

Parameters

name	the name of the netif (like netif->name) plus concatenated number in ascii representation (e.g. 'en0')

Definition at line 1755 of file netif.c.

{
  struct netif *netif;
  u8_t num;
 
  LWIP_ASSERT_CORE_LOCKED();
 
  if (name == NULL) {
    return NULL;
  }
 
  num = (u8_t)atoi(&name[2]);
  if (!num && (name[2] != '0')) {
    /* this means atoi has failed */
    return NULL;
  }
 
  NETIF_FOREACH(netif) {
    if (num == netif->num &&
        name[0] == netif->name[0] &&
        name[1] == netif->name[1]) {
      LWIP_DEBUGF(NETIF_DEBUG, ("netif_find: found %c%c\n", name[0], name[1]));
      return netif;
    }
  }
  LWIP_DEBUGF(NETIF_DEBUG, ("netif_find: didn't find %c%c\n", name[0], name[1]));
  return NULL;
}

Referenced by netif_name_to_index(), and START_TEST().

netif_get_by_index()

struct netif * netif_get_by_index

(

u8_t

idx

)

Return the interface for the netif index

Parameters

idx	index of netif to find

Definition at line 1730 of file netif.c.

{
  struct netif *netif;
 
  LWIP_ASSERT_CORE_LOCKED();
 
  if (idx != NETIF_NO_INDEX) {
    NETIF_FOREACH(netif) {
      if (idx == netif_get_index(netif)) {
        return netif; /* found! */
      }
    }
  }
 
  return NULL;
}

Referenced by netif_index_to_name().

netif_index_to_name()

char * netif_index_to_name	(	u8_t	idx,
		char *	name
	)

Return the interface name for the netif matching index or NULL if not found/on error

Parameters

idx	the interface index of the netif
name	char buffer of at least NETIF_NAMESIZE bytes

Definition at line 1710 of file netif.c.

{
  struct netif *netif = netif_get_by_index(idx);
 
  if (netif != NULL) {
    name[0] = netif->name[0];
    name[1] = netif->name[1];
    lwip_itoa(&name[2], NETIF_NAMESIZE - 2, netif_index_to_num(idx));
    return name;
  }
  return NULL;
}

netif_name_to_index()

u8_t netif_name_to_index

(

const char *

name

)

Return the interface index for the netif with name or NETIF_NO_INDEX if not found/on error

Parameters

name	the name of the netif

Definition at line 1691 of file netif.c.

{
  struct netif *netif = netif_find(name);
  if (netif != NULL) {
    return netif_get_index(netif);
  }
  /* No name found, return invalid index */
  return NETIF_NO_INDEX;
}

netif_remove()

void netif_remove

(

struct netif *

netif

)

Remove a network interface from the list of lwIP netifs.

Parameters

netif

the network interface to remove

Definition at line 764 of file netif.c.

{
#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") );
}

Referenced by default_netif_remove(), START_TEST(), TCPUnregisterInterface(), and test_netif_remove().

netif_set_default()

void netif_set_default

(

struct netif *

netif

)

Set a network interface as the default network interface (used to output all packets for which no specific route is found)

Parameters

netif

the default network interface

Definition at line 849 of file netif.c.

{
  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] : '\''));
}

Referenced by default_netif_add(), main(), netif_remove(), TCPUpdateInterfaceIPInformation(), and test_netif_add().

netif_set_down()

void netif_set_down

(

struct netif *

netif

)

Bring an interface down, disabling any traffic processing.

Definition at line 949 of file netif.c.

{
  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);
  }
}

Referenced by netif_remove(), START_TEST(), and TCPUpdateInterfaceIPInformation().

netif_set_link_down()

void netif_set_link_down

(

struct netif *

netif

)

Called by a driver when its link goes down

Definition at line 1056 of file netif.c.

{
  LWIP_ASSERT_CORE_LOCKED();
 
  LWIP_ERROR("netif_set_link_down: invalid netif", netif != NULL, return);
 
  if (netif->flags & NETIF_FLAG_LINK_UP) {
    netif_clear_flags(netif, NETIF_FLAG_LINK_UP);
 
#if LWIP_AUTOIP
    autoip_network_changed_link_down(netif);
#endif /* LWIP_AUTOIP */
 
#if LWIP_ACD
    acd_network_changed_link_down(netif);
#endif /* LWIP_ACD */
 
#if LWIP_IPV6 && LWIP_ND6_ALLOW_RA_UPDATES
    netif->mtu6 = netif->mtu;
#endif
 
    NETIF_LINK_CALLBACK(netif);
#if LWIP_NETIF_EXT_STATUS_CALLBACK
    {
      netif_ext_callback_args_t args;
      args.link_changed.state = 0;
      netif_invoke_ext_callback(netif, LWIP_NSC_LINK_CHANGED, &args);
    }
#endif
  }
}

Referenced by main(), TCPUpdateInterfaceLinkStatus(), test_tcp_rto_timeout_impl(), test_tcp_rto_timeout_syn_sent_impl(), and test_tcp_zwp_timeout_impl().

netif_set_link_up()

void netif_set_link_up

(

struct netif *

netif

)

Called by a driver when its link goes up

Definition at line 1018 of file netif.c.

{
  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_link_up(netif);
#endif /* LWIP_DHCP */
 
#if LWIP_AUTOIP
    autoip_network_changed_link_up(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;
      args.link_changed.state = 1;
      netif_invoke_ext_callback(netif, LWIP_NSC_LINK_CHANGED, &args);
    }
#endif
  }
}

Referenced by lwip_fuzztest(), main(), netif_init(), START_TEST(), and TCPUpdateInterfaceLinkStatus().

netif_set_up()

void netif_set_up

(

struct netif *

netif

)

Bring an interface up, available for processing traffic.

Definition at line 871 of file netif.c.

{
  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 */
  }
}

Referenced by default_netif_add(), ip4_teardown(), lwip_fuzztest(), main(), netif_init(), START_TEST(), TCPUpdateInterfaceIPInformation(), and test_netif_add().