net_if.h

Go to the documentation of this file.

/*
 * Copyright (c) 2016 Intel Corporation.
 *
 * SPDX-License-Identifier: Apache-2.0
 */
 
#ifndef ZEPHYR_INCLUDE_NET_NET_IF_H_
#define ZEPHYR_INCLUDE_NET_NET_IF_H_
 
#include <zephyr/device.h>
#include <zephyr/sys/slist.h>
#include <zephyr/sys/iterable_sections.h>
#include <zephyr/net/net_core.h>
#include <zephyr/net/hostname.h>
#include <zephyr/net/net_linkaddr.h>
#include <zephyr/net/net_ip.h>
#include <zephyr/net/net_l2.h>
#include <zephyr/net/net_stats.h>
#include <zephyr/net/net_timeout.h>
 
#if defined(CONFIG_NET_DHCPV4) && defined(CONFIG_NET_NATIVE_IPV4)
#include <zephyr/net/dhcpv4.h>
#endif
#if defined(CONFIG_NET_DHCPV6) && defined(CONFIG_NET_NATIVE_IPV6)
#include <zephyr/net/dhcpv6.h>
#endif
#if defined(CONFIG_NET_IPV4_AUTO) && defined(CONFIG_NET_NATIVE_IPV4)
#include <zephyr/net/ipv4_autoconf.h>
#endif
 
#ifdef __cplusplus
extern "C" {
#endif
 
struct net_if_addr {
 struct net_addr address;
 
 atomic_t atomic_ref;
 
#if defined(CONFIG_NET_NATIVE_IPV6)
 struct net_timeout lifetime;
#endif
 
#if defined(CONFIG_NET_IPV6_DAD) && defined(CONFIG_NET_NATIVE_IPV6)
 sys_snode_t dad_node;
 uint32_t dad_start;
#endif
 enum net_addr_type addr_type;
 
 enum net_addr_state addr_state;
 
#if defined(CONFIG_NET_NATIVE_IPV6)
#if defined(CONFIG_NET_IPV6_PE)
 uint32_t addr_create_time;
 
 uint32_t addr_preferred_lifetime;
 
 int32_t addr_timeout;
#endif
 
#if defined(CONFIG_NET_IPV6_DAD)
 uint8_t dad_count;
 /* What interface the DAD is running */
 uint8_t ifindex;
#endif
#endif /* CONFIG_NET_NATIVE_IPV6 */
 
 uint8_t is_infinite : 1;
 
 uint8_t is_used : 1;
 
 uint8_t is_mesh_local : 1;
 
 uint8_t is_temporary : 1;
 
 uint8_t _unused : 4;
};
 
struct net_if_mcast_addr {
 struct net_addr address;
 
#if defined(CONFIG_NET_IPV4_IGMPV3)
 struct net_addr sources[CONFIG_NET_IF_MCAST_IPV4_SOURCE_COUNT];
 
 uint16_t sources_len;
 
 uint8_t record_type;
#endif
 
 uint8_t is_used : 1;
 
 uint8_t is_joined : 1;
 
 uint8_t _unused : 6;
};
 
struct net_if_ipv6_prefix {
 struct net_timeout lifetime;
 
 struct in6_addr prefix;
 
 struct net_if *iface;
 
 uint8_t len;
 
 uint8_t is_infinite : 1;
 
 uint8_t is_used : 1;
 
 uint8_t _unused : 6;
};
 
struct net_if_router {
 sys_snode_t node;
 
 struct net_addr address;
 
 struct net_if *iface;
 
 uint32_t life_start;
 
 uint16_t lifetime;
 
 uint8_t is_used : 1;
 
 uint8_t is_default : 1;
 
 uint8_t is_infinite : 1;
 
 uint8_t _unused : 5;
};
 
enum net_if_flag {
 NET_IF_UP,
 
 NET_IF_POINTOPOINT,
 
 NET_IF_PROMISC,
 
 NET_IF_NO_AUTO_START,
 
 NET_IF_SUSPENDED,
 
 NET_IF_FORWARD_MULTICASTS,
 
 NET_IF_IPV4,
 
 NET_IF_IPV6,
 
 NET_IF_RUNNING,
 
 NET_IF_LOWER_UP,
 
 NET_IF_DORMANT,
 
 NET_IF_IPV6_NO_ND,
 
 NET_IF_IPV6_NO_MLD,
 
 NET_IF_NO_TX_LOCK,
 
 /* Total number of flags - must be at the end of the enum */
 NET_IF_NUM_FLAGS
};
 
enum net_if_oper_state {
 NET_IF_OPER_UNKNOWN, 
 NET_IF_OPER_NOTPRESENT, 
 NET_IF_OPER_DOWN, 
 NET_IF_OPER_LOWERLAYERDOWN, 
 NET_IF_OPER_TESTING, 
 NET_IF_OPER_DORMANT, 
 NET_IF_OPER_UP, 
} __packed;
 
#if defined(CONFIG_NET_OFFLOAD)
struct net_offload;
#endif /* CONFIG_NET_OFFLOAD */
 
#if defined(CONFIG_NET_NATIVE_IPV6)
#define NET_IF_MAX_IPV6_ADDR CONFIG_NET_IF_UNICAST_IPV6_ADDR_COUNT
#define NET_IF_MAX_IPV6_MADDR CONFIG_NET_IF_MCAST_IPV6_ADDR_COUNT
#define NET_IF_MAX_IPV6_PREFIX CONFIG_NET_IF_IPV6_PREFIX_COUNT
#else
#define NET_IF_MAX_IPV6_ADDR 0
#define NET_IF_MAX_IPV6_MADDR 0
#define NET_IF_MAX_IPV6_PREFIX 0
#endif
/* @endcond */
 
struct net_if_ipv6 {
 struct net_if_addr unicast[NET_IF_MAX_IPV6_ADDR];
 
 struct net_if_mcast_addr mcast[NET_IF_MAX_IPV6_MADDR];
 
 struct net_if_ipv6_prefix prefix[NET_IF_MAX_IPV6_PREFIX];
 
 uint32_t base_reachable_time;
 
 uint32_t reachable_time;
 
 uint32_t retrans_timer;
 
#if defined(CONFIG_NET_IPV6_PE)
 uint32_t desync_factor;
#endif /* CONFIG_NET_IPV6_PE */
 
#if defined(CONFIG_NET_IPV6_ND) && defined(CONFIG_NET_NATIVE_IPV6)
 sys_snode_t rs_node;
 
 /* RS start time */
 uint32_t rs_start;
 
 uint8_t rs_count;
#endif
 
 uint8_t hop_limit;
 
 uint8_t mcast_hop_limit;
};
 
#if defined(CONFIG_NET_DHCPV6) && defined(CONFIG_NET_NATIVE_IPV6)
struct net_if_dhcpv6 {
 sys_snode_t node;
 
 struct net_dhcpv6_duid_storage clientid;
 
 struct net_dhcpv6_duid_storage serverid;
 
 enum net_dhcpv6_state state;
 
 struct net_dhcpv6_params params;
 
 uint64_t timeout;
 
 uint64_t exchange_start;
 
 uint64_t t1;
 
 uint64_t t2;
 
 uint64_t expire;
 
 uint32_t addr_iaid;
 
 uint32_t prefix_iaid;
 
 uint32_t retransmit_timeout;
 
 int16_t server_preference;
 
 uint8_t retransmissions;
 
 uint8_t tid[DHCPV6_TID_SIZE];
 
 uint8_t prefix_len;
 
 struct in6_addr prefix;
 
 struct in6_addr addr;
};
#endif /* defined(CONFIG_NET_DHCPV6) && defined(CONFIG_NET_NATIVE_IPV6) */
 
#if defined(CONFIG_NET_NATIVE_IPV4)
#define NET_IF_MAX_IPV4_ADDR CONFIG_NET_IF_UNICAST_IPV4_ADDR_COUNT
#define NET_IF_MAX_IPV4_MADDR CONFIG_NET_IF_MCAST_IPV4_ADDR_COUNT
#else
#define NET_IF_MAX_IPV4_ADDR 0
#define NET_IF_MAX_IPV4_MADDR 0
#endif
struct net_if_addr_ipv4 {
 struct net_if_addr ipv4;
 struct in_addr netmask;
};
 
struct net_if_ipv4 {
 struct net_if_addr_ipv4 unicast[NET_IF_MAX_IPV4_ADDR];
 
 struct net_if_mcast_addr mcast[NET_IF_MAX_IPV4_MADDR];
 
 struct in_addr gw;
 
 uint8_t ttl;
 
 uint8_t mcast_ttl;
};
 
#if defined(CONFIG_NET_DHCPV4) && defined(CONFIG_NET_NATIVE_IPV4)
struct net_if_dhcpv4 {
 sys_snode_t node;
 
 int64_t timer_start;
 
 uint32_t request_time;
 
 uint32_t xid;
 
 uint32_t lease_time;
 
 uint32_t renewal_time;
 
 uint32_t rebinding_time;
 
 struct in_addr server_id;
 
 struct in_addr requested_ip;
 
 struct in_addr netmask;
 
 enum net_dhcpv4_state state;
 
 uint8_t attempts;
 
 struct in_addr request_server_addr;
 
 struct in_addr response_src_addr;
 
#ifdef CONFIG_NET_DHCPV4_OPTION_NTP_SERVER
 struct in_addr ntp_addr;
#endif
};
#endif /* CONFIG_NET_DHCPV4 */
 
#if defined(CONFIG_NET_IPV4_AUTO) && defined(CONFIG_NET_NATIVE_IPV4)
struct net_if_ipv4_autoconf {
 sys_snode_t node;
 
 struct net_if *iface;
 
 int64_t timer_start;
 
 uint32_t timer_timeout;
 
 struct in_addr current_ip;
 
 struct in_addr requested_ip;
 
 enum net_ipv4_autoconf_state state;
 
 uint8_t probe_cnt;
 
 uint8_t announce_cnt;
 
 uint8_t conflict_cnt;
};
#endif /* CONFIG_NET_IPV4_AUTO */
 
/* We always need to have at least one IP config */
#define NET_IF_MAX_CONFIGS 1
struct net_if_ip {
#if defined(CONFIG_NET_NATIVE_IPV6)
 struct net_if_ipv6 *ipv6;
#endif /* CONFIG_NET_IPV6 */
 
#if defined(CONFIG_NET_NATIVE_IPV4)
 struct net_if_ipv4 *ipv4;
#endif /* CONFIG_NET_IPV4 */
};
 
struct net_if_config {
#if defined(CONFIG_NET_IP)
 struct net_if_ip ip;
#endif
 
#if defined(CONFIG_NET_DHCPV4) && defined(CONFIG_NET_NATIVE_IPV4)
 struct net_if_dhcpv4 dhcpv4;
#endif /* CONFIG_NET_DHCPV4 */
 
#if defined(CONFIG_NET_DHCPV6) && defined(CONFIG_NET_NATIVE_IPV6)
 struct net_if_dhcpv6 dhcpv6;
#endif /* CONFIG_NET_DHCPV6 */
 
#if defined(CONFIG_NET_IPV4_AUTO) && defined(CONFIG_NET_NATIVE_IPV4)
 struct net_if_ipv4_autoconf ipv4auto;
#endif /* CONFIG_NET_IPV4_AUTO */
 
#if defined(CONFIG_NET_L2_VIRTUAL)
 sys_slist_t virtual_interfaces;
#endif /* CONFIG_NET_L2_VIRTUAL */
 
#if defined(CONFIG_NET_INTERFACE_NAME)
 char name[CONFIG_NET_INTERFACE_NAME_LEN + 1];
#endif
};
 
struct net_traffic_class {
 struct k_fifo fifo;
 
 struct k_thread handler;
 
 k_thread_stack_t *stack;
};
 
typedef int (*net_socket_create_t)(int, int, int);
 
struct net_if_dev {
 const struct device *dev;
 
 const struct net_l2 * const l2;
 
 void *l2_data;
 
 ATOMIC_DEFINE(flags, NET_IF_NUM_FLAGS);
 
 struct net_linkaddr link_addr;
 
#if defined(CONFIG_NET_OFFLOAD)
 struct net_offload *offload;
#endif /* CONFIG_NET_OFFLOAD */
 
 uint16_t mtu;
 
#if defined(CONFIG_NET_SOCKETS_OFFLOAD)
 net_socket_create_t socket_offload;
#endif /* CONFIG_NET_SOCKETS_OFFLOAD */
 
 enum net_if_oper_state oper_state;
};
 
struct net_if {
 struct net_if_dev *if_dev;
 
#if defined(CONFIG_NET_STATISTICS_PER_INTERFACE)
 struct net_stats stats;
#endif /* CONFIG_NET_STATISTICS_PER_INTERFACE */
 
 struct net_if_config config;
 
#if defined(CONFIG_NET_POWER_MANAGEMENT)
 int tx_pending;
#endif
 
 struct k_mutex lock;
 
 struct k_mutex tx_lock;
 
 uint8_t pe_enabled : 1;
 
 uint8_t pe_prefer_public : 1;
 
 uint8_t _unused : 6;
};
 
static inline void net_if_lock(struct net_if *iface)
{
 NET_ASSERT(iface);
 
 (void)k_mutex_lock(&iface->lock, K_FOREVER);
}
 
static inline void net_if_unlock(struct net_if *iface)
{
 NET_ASSERT(iface);
 
 k_mutex_unlock(&iface->lock);
}
 
static inline bool net_if_flag_is_set(struct net_if *iface,
 enum net_if_flag value);
 
static inline void net_if_tx_lock(struct net_if *iface)
{
 NET_ASSERT(iface);
 
 if (net_if_flag_is_set(iface, NET_IF_NO_TX_LOCK)) {
 return;
 }
 
 (void)k_mutex_lock(&iface->tx_lock, K_FOREVER);
}
 
static inline void net_if_tx_unlock(struct net_if *iface)
{
 NET_ASSERT(iface);
 
 if (net_if_flag_is_set(iface, NET_IF_NO_TX_LOCK)) {
 return;
 }
 
 k_mutex_unlock(&iface->tx_lock);
}
 
static inline void net_if_flag_set(struct net_if *iface,
 enum net_if_flag value)
{
 NET_ASSERT(iface);
 NET_ASSERT(iface->if_dev);
 
 atomic_set_bit(iface->if_dev->flags, value);
}
 
static inline bool net_if_flag_test_and_set(struct net_if *iface,
 enum net_if_flag value)
{
 NET_ASSERT(iface);
 NET_ASSERT(iface->if_dev);
 
 return atomic_test_and_set_bit(iface->if_dev->flags, value);
}
 
static inline void net_if_flag_clear(struct net_if *iface,
 enum net_if_flag value)
{
 NET_ASSERT(iface);
 NET_ASSERT(iface->if_dev);
 
 atomic_clear_bit(iface->if_dev->flags, value);
}
 
static inline bool net_if_flag_test_and_clear(struct net_if *iface,
 enum net_if_flag value)
{
 NET_ASSERT(iface);
 NET_ASSERT(iface->if_dev);
 
 return atomic_test_and_clear_bit(iface->if_dev->flags, value);
}
 
static inline bool net_if_flag_is_set(struct net_if *iface,
 enum net_if_flag value)
{
 NET_ASSERT(iface);
 NET_ASSERT(iface->if_dev);
 
 if (iface == NULL) {
 return false;
 }
 
 return atomic_test_bit(iface->if_dev->flags, value);
}
 
static inline enum net_if_oper_state net_if_oper_state_set(
 struct net_if *iface, enum net_if_oper_state oper_state)
{
 NET_ASSERT(iface);
 NET_ASSERT(iface->if_dev);
 
 if (oper_state >= NET_IF_OPER_UNKNOWN && oper_state <= NET_IF_OPER_UP) {
 iface->if_dev->oper_state = oper_state;
 }
 
 return iface->if_dev->oper_state;
}
 
static inline enum net_if_oper_state net_if_oper_state(struct net_if *iface)
{
 NET_ASSERT(iface);
 NET_ASSERT(iface->if_dev);
 
 return iface->if_dev->oper_state;
}
 
enum net_verdict net_if_send_data(struct net_if *iface, struct net_pkt *pkt);
 
static inline const struct net_l2 *net_if_l2(struct net_if *iface)
{
 if (!iface || !iface->if_dev) {
 return NULL;
 }
 
 return iface->if_dev->l2;
}
 
enum net_verdict net_if_recv_data(struct net_if *iface, struct net_pkt *pkt);
 
static inline void *net_if_l2_data(struct net_if *iface)
{
 NET_ASSERT(iface);
 NET_ASSERT(iface->if_dev);
 
 return iface->if_dev->l2_data;
}
 
static inline const struct device *net_if_get_device(struct net_if *iface)
{
 NET_ASSERT(iface);
 NET_ASSERT(iface->if_dev);
 
 return iface->if_dev->dev;
}
 
void net_if_queue_tx(struct net_if *iface, struct net_pkt *pkt);
 
static inline bool net_if_is_ip_offloaded(struct net_if *iface)
{
#if defined(CONFIG_NET_OFFLOAD)
 return (iface != NULL && iface->if_dev != NULL &&
 iface->if_dev->offload != NULL);
#else
 ARG_UNUSED(iface);
 
 return false;
#endif
}
 
bool net_if_is_offloaded(struct net_if *iface);
 
static inline struct net_offload *net_if_offload(struct net_if *iface)
{
#if defined(CONFIG_NET_OFFLOAD)
 NET_ASSERT(iface);
 NET_ASSERT(iface->if_dev);
 
 return iface->if_dev->offload;
#else
 ARG_UNUSED(iface);
 
 return NULL;
#endif
}
 
static inline bool net_if_is_socket_offloaded(struct net_if *iface)
{
#if defined(CONFIG_NET_SOCKETS_OFFLOAD)
 NET_ASSERT(iface);
 NET_ASSERT(iface->if_dev);
 
 return (iface->if_dev->socket_offload != NULL);
#else
 ARG_UNUSED(iface);
 
 return false;
#endif
}
 
static inline void net_if_socket_offload_set(
 struct net_if *iface, net_socket_create_t socket_offload)
{
#if defined(CONFIG_NET_SOCKETS_OFFLOAD)
 NET_ASSERT(iface);
 NET_ASSERT(iface->if_dev);
 
 iface->if_dev->socket_offload = socket_offload;
#else
 ARG_UNUSED(iface);
 ARG_UNUSED(socket_offload);
#endif
}
 
static inline net_socket_create_t net_if_socket_offload(struct net_if *iface)
{
#if defined(CONFIG_NET_SOCKETS_OFFLOAD)
 NET_ASSERT(iface);
 NET_ASSERT(iface->if_dev);
 
 return iface->if_dev->socket_offload;
#else
 ARG_UNUSED(iface);
 
 return NULL;
#endif
}
 
static inline struct net_linkaddr *net_if_get_link_addr(struct net_if *iface)
{
 NET_ASSERT(iface);
 NET_ASSERT(iface->if_dev);
 
 return &iface->if_dev->link_addr;
}
 
static inline struct net_if_config *net_if_get_config(struct net_if *iface)
{
 NET_ASSERT(iface);
 
 return &iface->config;
}
 
#if defined(CONFIG_NET_IPV6_DAD) && defined(CONFIG_NET_NATIVE_IPV6)
void net_if_start_dad(struct net_if *iface);
#else
static inline void net_if_start_dad(struct net_if *iface)
{
 ARG_UNUSED(iface);
}
#endif
 
void net_if_start_rs(struct net_if *iface);
 
 
#if defined(CONFIG_NET_IPV6_ND) && defined(CONFIG_NET_NATIVE_IPV6)
void net_if_stop_rs(struct net_if *iface);
#else
static inline void net_if_stop_rs(struct net_if *iface)
{
 ARG_UNUSED(iface);
}
#endif /* CONFIG_NET_IPV6_ND */
 
#if defined(CONFIG_NET_IPV6_ND) && defined(CONFIG_NET_NATIVE_IPV6)
void net_if_nbr_reachability_hint(struct net_if *iface, const struct in6_addr *ipv6_addr);
#else
static inline void net_if_nbr_reachability_hint(struct net_if *iface,
 const struct in6_addr *ipv6_addr)
{
 ARG_UNUSED(iface);
 ARG_UNUSED(ipv6_addr);
}
#endif
 
static inline int net_if_set_link_addr_unlocked(struct net_if *iface,
 uint8_t *addr, uint8_t len,
 enum net_link_type type)
{
 if (net_if_flag_is_set(iface, NET_IF_RUNNING)) {
 return -EPERM;
 }
 
 net_if_get_link_addr(iface)->addr = addr;
 net_if_get_link_addr(iface)->len = len;
 net_if_get_link_addr(iface)->type = type;
 
 net_hostname_set_postfix(addr, len);
 
 return 0;
}
 
int net_if_set_link_addr_locked(struct net_if *iface,
 uint8_t *addr, uint8_t len,
 enum net_link_type type);
 
#if CONFIG_NET_IF_LOG_LEVEL >= LOG_LEVEL_DBG
extern int net_if_addr_unref_debug(struct net_if *iface,
 sa_family_t family,
 const void *addr,
 const char *caller, int line);
#define net_if_addr_unref(iface, family, addr) \
 net_if_addr_unref_debug(iface, family, addr, __func__, __LINE__)
 
extern struct net_if_addr *net_if_addr_ref_debug(struct net_if *iface,
 sa_family_t family,
 const void *addr,
 const char *caller,
 int line);
#define net_if_addr_ref(iface, family, addr) \
 net_if_addr_ref_debug(iface, family, addr, __func__, __LINE__)
#else
extern int net_if_addr_unref(struct net_if *iface,
 sa_family_t family,
 const void *addr);
extern struct net_if_addr *net_if_addr_ref(struct net_if *iface,
 sa_family_t family,
 const void *addr);
#endif /* CONFIG_NET_IF_LOG_LEVEL */
 
static inline int net_if_set_link_addr(struct net_if *iface,
 uint8_t *addr, uint8_t len,
 enum net_link_type type)
{
#if defined(CONFIG_NET_RAW_MODE)
 return net_if_set_link_addr_unlocked(iface, addr, len, type);
#else
 return net_if_set_link_addr_locked(iface, addr, len, type);
#endif
}
 
static inline uint16_t net_if_get_mtu(struct net_if *iface)
{
 if (iface == NULL) {
 return 0U;
 }
 
 NET_ASSERT(iface->if_dev);
 
 return iface->if_dev->mtu;
}
 
static inline void net_if_set_mtu(struct net_if *iface,
 uint16_t mtu)
{
 if (iface == NULL) {
 return;
 }
 
 NET_ASSERT(iface->if_dev);
 
 iface->if_dev->mtu = mtu;
}
 
static inline void net_if_addr_set_lf(struct net_if_addr *ifaddr,
 bool is_infinite)
{
 NET_ASSERT(ifaddr);
 
 ifaddr->is_infinite = is_infinite;
}
 
struct net_if *net_if_get_by_link_addr(struct net_linkaddr *ll_addr);
 
struct net_if *net_if_lookup_by_dev(const struct device *dev);
 
static inline struct net_if_config *net_if_config_get(struct net_if *iface)
{
 NET_ASSERT(iface);
 
 return &iface->config;
}
 
void net_if_router_rm(struct net_if_router *router);
 
void net_if_set_default(struct net_if *iface);
 
struct net_if *net_if_get_default(void);
 
struct net_if *net_if_get_first_by_type(const struct net_l2 *l2);
 
struct net_if *net_if_get_first_up(void);
 
#if defined(CONFIG_NET_L2_IEEE802154)
static inline struct net_if *net_if_get_ieee802154(void)
{
 return net_if_get_first_by_type(&NET_L2_GET_NAME(IEEE802154));
}
#endif /* CONFIG_NET_L2_IEEE802154 */
 
int net_if_config_ipv6_get(struct net_if *iface,
 struct net_if_ipv6 **ipv6);
 
int net_if_config_ipv6_put(struct net_if *iface);
 
struct net_if_addr *net_if_ipv6_addr_lookup(const struct in6_addr *addr,
 struct net_if **iface);
 
struct net_if_addr *net_if_ipv6_addr_lookup_by_iface(struct net_if *iface,
 struct in6_addr *addr);
 
__syscall int net_if_ipv6_addr_lookup_by_index(const struct in6_addr *addr);
 
struct net_if_addr *net_if_ipv6_addr_add(struct net_if *iface,
 struct in6_addr *addr,
 enum net_addr_type addr_type,
 uint32_t vlifetime);
 
__syscall bool net_if_ipv6_addr_add_by_index(int index,
 struct in6_addr *addr,
 enum net_addr_type addr_type,
 uint32_t vlifetime);
 
void net_if_ipv6_addr_update_lifetime(struct net_if_addr *ifaddr,
 uint32_t vlifetime);
 
bool net_if_ipv6_addr_rm(struct net_if *iface, const struct in6_addr *addr);
 
__syscall bool net_if_ipv6_addr_rm_by_index(int index,
 const struct in6_addr *addr);
 
typedef void (*net_if_ip_addr_cb_t)(struct net_if *iface,
 struct net_if_addr *addr,
 void *user_data);
 
void net_if_ipv6_addr_foreach(struct net_if *iface, net_if_ip_addr_cb_t cb,
 void *user_data);
 
struct net_if_mcast_addr *net_if_ipv6_maddr_add(struct net_if *iface,
 const struct in6_addr *addr);
 
bool net_if_ipv6_maddr_rm(struct net_if *iface, const struct in6_addr *addr);
 
typedef void (*net_if_ip_maddr_cb_t)(struct net_if *iface,
 struct net_if_mcast_addr *maddr,
 void *user_data);
 
void net_if_ipv6_maddr_foreach(struct net_if *iface, net_if_ip_maddr_cb_t cb,
 void *user_data);
 
struct net_if_mcast_addr *net_if_ipv6_maddr_lookup(const struct in6_addr *addr,
 struct net_if **iface);
 
typedef void (*net_if_mcast_callback_t)(struct net_if *iface,
 const struct net_addr *addr,
 bool is_joined);
 
struct net_if_mcast_monitor {
 sys_snode_t node;
 
 struct net_if *iface;
 
 net_if_mcast_callback_t cb;
};
 
void net_if_mcast_mon_register(struct net_if_mcast_monitor *mon,
 struct net_if *iface,
 net_if_mcast_callback_t cb);
 
void net_if_mcast_mon_unregister(struct net_if_mcast_monitor *mon);
 
void net_if_mcast_monitor(struct net_if *iface, const struct net_addr *addr,
 bool is_joined);
 
void net_if_ipv6_maddr_join(struct net_if *iface,
 struct net_if_mcast_addr *addr);
 
static inline bool net_if_ipv6_maddr_is_joined(struct net_if_mcast_addr *addr)
{
 NET_ASSERT(addr);
 
 return addr->is_joined;
}
 
void net_if_ipv6_maddr_leave(struct net_if *iface,
 struct net_if_mcast_addr *addr);
 
struct net_if_ipv6_prefix *net_if_ipv6_prefix_get(struct net_if *iface,
 const struct in6_addr *addr);
 
struct net_if_ipv6_prefix *net_if_ipv6_prefix_lookup(struct net_if *iface,
 struct in6_addr *addr,
 uint8_t len);
 
struct net_if_ipv6_prefix *net_if_ipv6_prefix_add(struct net_if *iface,
 struct in6_addr *prefix,
 uint8_t len,
 uint32_t lifetime);
 
bool net_if_ipv6_prefix_rm(struct net_if *iface, struct in6_addr *addr,
 uint8_t len);
 
static inline void net_if_ipv6_prefix_set_lf(struct net_if_ipv6_prefix *prefix,
 bool is_infinite)
{
 prefix->is_infinite = is_infinite;
}
 
void net_if_ipv6_prefix_set_timer(struct net_if_ipv6_prefix *prefix,
 uint32_t lifetime);
 
void net_if_ipv6_prefix_unset_timer(struct net_if_ipv6_prefix *prefix);
 
bool net_if_ipv6_addr_onlink(struct net_if **iface, struct in6_addr *addr);
 
#if defined(CONFIG_NET_NATIVE_IPV6)
static inline struct in6_addr *net_if_router_ipv6(struct net_if_router *router)
{
 NET_ASSERT(router);
 
 return &router->address.in6_addr;
}
#else
static inline struct in6_addr *net_if_router_ipv6(struct net_if_router *router)
{
 static struct in6_addr addr;
 
 ARG_UNUSED(router);
 
 return &addr;
}
#endif
 
struct net_if_router *net_if_ipv6_router_lookup(struct net_if *iface,
 struct in6_addr *addr);
 
struct net_if_router *net_if_ipv6_router_find_default(struct net_if *iface,
 struct in6_addr *addr);
 
void net_if_ipv6_router_update_lifetime(struct net_if_router *router,
 uint16_t lifetime);
 
struct net_if_router *net_if_ipv6_router_add(struct net_if *iface,
 struct in6_addr *addr,
 uint16_t router_lifetime);
 
bool net_if_ipv6_router_rm(struct net_if_router *router);
 
uint8_t net_if_ipv6_get_hop_limit(struct net_if *iface);
 
void net_if_ipv6_set_hop_limit(struct net_if *iface, uint8_t hop_limit);
 
/* The old hop limit setter function is deprecated because the naming
 * of it was incorrect. The API name was missing "_if_" so this function
 * should not be used.
 */
__deprecated
static inline void net_ipv6_set_hop_limit(struct net_if *iface,
 uint8_t hop_limit)
{
 net_if_ipv6_set_hop_limit(iface, hop_limit);
}
 
uint8_t net_if_ipv6_get_mcast_hop_limit(struct net_if *iface);
 
void net_if_ipv6_set_mcast_hop_limit(struct net_if *iface, uint8_t hop_limit);
 
static inline void net_if_ipv6_set_base_reachable_time(struct net_if *iface,
 uint32_t reachable_time)
{
#if defined(CONFIG_NET_NATIVE_IPV6)
 NET_ASSERT(iface);
 
 if (!iface->config.ip.ipv6) {
 return;
 }
 
 iface->config.ip.ipv6->base_reachable_time = reachable_time;
#else
 ARG_UNUSED(iface);
 ARG_UNUSED(reachable_time);
 
#endif
}
 
static inline uint32_t net_if_ipv6_get_reachable_time(struct net_if *iface)
{
#if defined(CONFIG_NET_NATIVE_IPV6)
 NET_ASSERT(iface);
 
 if (!iface->config.ip.ipv6) {
 return 0;
 }
 
 return iface->config.ip.ipv6->reachable_time;
#else
 ARG_UNUSED(iface);
 return 0;
#endif
}
 
uint32_t net_if_ipv6_calc_reachable_time(struct net_if_ipv6 *ipv6);
 
static inline void net_if_ipv6_set_reachable_time(struct net_if_ipv6 *ipv6)
{
#if defined(CONFIG_NET_NATIVE_IPV6)
 if (ipv6 == NULL) {
 return;
 }
 
 ipv6->reachable_time = net_if_ipv6_calc_reachable_time(ipv6);
#else
 ARG_UNUSED(ipv6);
#endif
}
 
static inline void net_if_ipv6_set_retrans_timer(struct net_if *iface,
 uint32_t retrans_timer)
{
#if defined(CONFIG_NET_NATIVE_IPV6)
 NET_ASSERT(iface);
 
 if (!iface->config.ip.ipv6) {
 return;
 }
 
 iface->config.ip.ipv6->retrans_timer = retrans_timer;
#else
 ARG_UNUSED(iface);
 ARG_UNUSED(retrans_timer);
#endif
}
 
static inline uint32_t net_if_ipv6_get_retrans_timer(struct net_if *iface)
{
#if defined(CONFIG_NET_NATIVE_IPV6)
 NET_ASSERT(iface);
 
 if (!iface->config.ip.ipv6) {
 return 0;
 }
 
 return iface->config.ip.ipv6->retrans_timer;
#else
 ARG_UNUSED(iface);
 return 0;
#endif
}
 
#if defined(CONFIG_NET_NATIVE_IPV6)
const struct in6_addr *net_if_ipv6_select_src_addr(struct net_if *iface,
 const struct in6_addr *dst);
#else
static inline const struct in6_addr *net_if_ipv6_select_src_addr(
 struct net_if *iface, const struct in6_addr *dst)
{
 ARG_UNUSED(iface);
 ARG_UNUSED(dst);
 
 return NULL;
}
#endif
 
#if defined(CONFIG_NET_NATIVE_IPV6)
const struct in6_addr *net_if_ipv6_select_src_addr_hint(struct net_if *iface,
 const struct in6_addr *dst,
 int flags);
#else
static inline const struct in6_addr *net_if_ipv6_select_src_addr_hint(
 struct net_if *iface, const struct in6_addr *dst, int flags)
{
 ARG_UNUSED(iface);
 ARG_UNUSED(dst);
 ARG_UNUSED(flags);
 
 return NULL;
}
#endif
 
#if defined(CONFIG_NET_NATIVE_IPV6)
struct net_if *net_if_ipv6_select_src_iface(const struct in6_addr *dst);
#else
static inline struct net_if *net_if_ipv6_select_src_iface(
 const struct in6_addr *dst)
{
 ARG_UNUSED(dst);
 
 return NULL;
}
#endif
 
struct in6_addr *net_if_ipv6_get_ll(struct net_if *iface,
 enum net_addr_state addr_state);
 
struct in6_addr *net_if_ipv6_get_ll_addr(enum net_addr_state state,
 struct net_if **iface);
 
void net_if_ipv6_dad_failed(struct net_if *iface, const struct in6_addr *addr);
 
struct in6_addr *net_if_ipv6_get_global_addr(enum net_addr_state state,
 struct net_if **iface);
 
int net_if_config_ipv4_get(struct net_if *iface,
 struct net_if_ipv4 **ipv4);
 
int net_if_config_ipv4_put(struct net_if *iface);
 
uint8_t net_if_ipv4_get_ttl(struct net_if *iface);
 
void net_if_ipv4_set_ttl(struct net_if *iface, uint8_t ttl);
 
uint8_t net_if_ipv4_get_mcast_ttl(struct net_if *iface);
 
void net_if_ipv4_set_mcast_ttl(struct net_if *iface, uint8_t ttl);
 
struct net_if_addr *net_if_ipv4_addr_lookup(const struct in_addr *addr,
 struct net_if **iface);
 
struct net_if_addr *net_if_ipv4_addr_add(struct net_if *iface,
 struct in_addr *addr,
 enum net_addr_type addr_type,
 uint32_t vlifetime);
 
bool net_if_ipv4_addr_rm(struct net_if *iface, const struct in_addr *addr);
 
__syscall int net_if_ipv4_addr_lookup_by_index(const struct in_addr *addr);
 
__syscall bool net_if_ipv4_addr_add_by_index(int index,
 struct in_addr *addr,
 enum net_addr_type addr_type,
 uint32_t vlifetime);
 
__syscall bool net_if_ipv4_addr_rm_by_index(int index,
 const struct in_addr *addr);
 
void net_if_ipv4_addr_foreach(struct net_if *iface, net_if_ip_addr_cb_t cb,
 void *user_data);
 
struct net_if_mcast_addr *net_if_ipv4_maddr_add(struct net_if *iface,
 const struct in_addr *addr);
 
bool net_if_ipv4_maddr_rm(struct net_if *iface, const struct in_addr *addr);
 
void net_if_ipv4_maddr_foreach(struct net_if *iface, net_if_ip_maddr_cb_t cb,
 void *user_data);
 
struct net_if_mcast_addr *net_if_ipv4_maddr_lookup(const struct in_addr *addr,
 struct net_if **iface);
 
void net_if_ipv4_maddr_join(struct net_if *iface,
 struct net_if_mcast_addr *addr);
 
static inline bool net_if_ipv4_maddr_is_joined(struct net_if_mcast_addr *addr)
{
 NET_ASSERT(addr);
 
 return addr->is_joined;
}
 
void net_if_ipv4_maddr_leave(struct net_if *iface,
 struct net_if_mcast_addr *addr);
 
#if defined(CONFIG_NET_NATIVE_IPV4)
static inline struct in_addr *net_if_router_ipv4(struct net_if_router *router)
{
 NET_ASSERT(router);
 
 return &router->address.in_addr;
}
#else
static inline struct in_addr *net_if_router_ipv4(struct net_if_router *router)
{
 static struct in_addr addr;
 
 ARG_UNUSED(router);
 
 return &addr;
}
#endif
 
struct net_if_router *net_if_ipv4_router_lookup(struct net_if *iface,
 struct in_addr *addr);
 
struct net_if_router *net_if_ipv4_router_find_default(struct net_if *iface,
 struct in_addr *addr);
struct net_if_router *net_if_ipv4_router_add(struct net_if *iface,
 struct in_addr *addr,
 bool is_default,
 uint16_t router_lifetime);
 
bool net_if_ipv4_router_rm(struct net_if_router *router);
 
bool net_if_ipv4_addr_mask_cmp(struct net_if *iface,
 const struct in_addr *addr);
 
bool net_if_ipv4_is_addr_bcast(struct net_if *iface,
 const struct in_addr *addr);
 
#if defined(CONFIG_NET_NATIVE_IPV4)
struct net_if *net_if_ipv4_select_src_iface(const struct in_addr *dst);
#else
static inline struct net_if *net_if_ipv4_select_src_iface(
 const struct in_addr *dst)
{
 ARG_UNUSED(dst);
 
 return NULL;
}
#endif
 
#if defined(CONFIG_NET_NATIVE_IPV4)
const struct in_addr *net_if_ipv4_select_src_addr(struct net_if *iface,
 const struct in_addr *dst);
#else
static inline const struct in_addr *net_if_ipv4_select_src_addr(
 struct net_if *iface, const struct in_addr *dst)
{
 ARG_UNUSED(iface);
 ARG_UNUSED(dst);
 
 return NULL;
}
#endif
 
struct in_addr *net_if_ipv4_get_ll(struct net_if *iface,
 enum net_addr_state addr_state);
 
struct in_addr *net_if_ipv4_get_global_addr(struct net_if *iface,
 enum net_addr_state addr_state);
 
struct in_addr net_if_ipv4_get_netmask_by_addr(struct net_if *iface,
 const struct in_addr *addr);
 
__deprecated struct in_addr net_if_ipv4_get_netmask(struct net_if *iface);
 
__deprecated void net_if_ipv4_set_netmask(struct net_if *iface,
 const struct in_addr *netmask);
 
__deprecated __syscall bool net_if_ipv4_set_netmask_by_index(int index,
 const struct in_addr *netmask);
 
__syscall bool net_if_ipv4_set_netmask_by_addr_by_index(int index,
 const struct in_addr *addr,
 const struct in_addr *netmask);
 
bool net_if_ipv4_set_netmask_by_addr(struct net_if *iface,
 const struct in_addr *addr,
 const struct in_addr *netmask);
 
void net_if_ipv4_set_gw(struct net_if *iface, const struct in_addr *gw);
 
__syscall bool net_if_ipv4_set_gw_by_index(int index, const struct in_addr *gw);
 
struct net_if *net_if_select_src_iface(const struct sockaddr *dst);
 
typedef void (*net_if_link_callback_t)(struct net_if *iface,
 struct net_linkaddr *dst,
 int status);
 
struct net_if_link_cb {
 sys_snode_t node;
 
 net_if_link_callback_t cb;
};
 
void net_if_register_link_cb(struct net_if_link_cb *link,
 net_if_link_callback_t cb);
 
void net_if_unregister_link_cb(struct net_if_link_cb *link);
 
void net_if_call_link_cb(struct net_if *iface, struct net_linkaddr *lladdr,
 int status);
 
bool net_if_need_calc_rx_checksum(struct net_if *iface);
 
bool net_if_need_calc_tx_checksum(struct net_if *iface);
 
__syscall struct net_if *net_if_get_by_index(int index);
 
int net_if_get_by_iface(struct net_if *iface);
 
typedef void (*net_if_cb_t)(struct net_if *iface, void *user_data);
 
void net_if_foreach(net_if_cb_t cb, void *user_data);
 
int net_if_up(struct net_if *iface);
 
static inline bool net_if_is_up(struct net_if *iface)
{
 NET_ASSERT(iface);
 
 return net_if_flag_is_set(iface, NET_IF_UP) &&
 net_if_flag_is_set(iface, NET_IF_RUNNING);
}
 
int net_if_down(struct net_if *iface);
 
static inline bool net_if_is_admin_up(struct net_if *iface)
{
 NET_ASSERT(iface);
 
 return net_if_flag_is_set(iface, NET_IF_UP);
}
 
void net_if_carrier_on(struct net_if *iface);
 
void net_if_carrier_off(struct net_if *iface);
 
static inline bool net_if_is_carrier_ok(struct net_if *iface)
{
 NET_ASSERT(iface);
 
 return net_if_flag_is_set(iface, NET_IF_LOWER_UP);
}
 
void net_if_dormant_on(struct net_if *iface);
 
void net_if_dormant_off(struct net_if *iface);
 
static inline bool net_if_is_dormant(struct net_if *iface)
{
 NET_ASSERT(iface);
 
 return net_if_flag_is_set(iface, NET_IF_DORMANT);
}
 
#if defined(CONFIG_NET_PKT_TIMESTAMP) && defined(CONFIG_NET_NATIVE)
typedef void (*net_if_timestamp_callback_t)(struct net_pkt *pkt);
 
struct net_if_timestamp_cb {
 sys_snode_t node;
 
 struct net_pkt *pkt;
 
 struct net_if *iface;
 
 net_if_timestamp_callback_t cb;
};
 
void net_if_register_timestamp_cb(struct net_if_timestamp_cb *handle,
 struct net_pkt *pkt,
 struct net_if *iface,
 net_if_timestamp_callback_t cb);
 
void net_if_unregister_timestamp_cb(struct net_if_timestamp_cb *handle);
 
void net_if_call_timestamp_cb(struct net_pkt *pkt);
 
/*
 * @brief Add timestamped TX buffer to be handled
 *
 * @param pkt Timestamped buffer
 */
void net_if_add_tx_timestamp(struct net_pkt *pkt);
#endif /* CONFIG_NET_PKT_TIMESTAMP */
 
#if defined(CONFIG_NET_PROMISCUOUS_MODE)
int net_if_set_promisc(struct net_if *iface);
#else
static inline int net_if_set_promisc(struct net_if *iface)
{
 ARG_UNUSED(iface);
 
 return -ENOTSUP;
}
#endif
 
#if defined(CONFIG_NET_PROMISCUOUS_MODE)
void net_if_unset_promisc(struct net_if *iface);
#else
static inline void net_if_unset_promisc(struct net_if *iface)
{
 ARG_UNUSED(iface);
}
#endif
 
#if defined(CONFIG_NET_PROMISCUOUS_MODE)
bool net_if_is_promisc(struct net_if *iface);
#else
static inline bool net_if_is_promisc(struct net_if *iface)
{
 ARG_UNUSED(iface);
 
 return false;
}
#endif
 
static inline bool net_if_are_pending_tx_packets(struct net_if *iface)
{
#if defined(CONFIG_NET_POWER_MANAGEMENT)
 return !!iface->tx_pending;
#else
 ARG_UNUSED(iface);
 
 return false;
#endif
}
 
#ifdef CONFIG_NET_POWER_MANAGEMENT
int net_if_suspend(struct net_if *iface);
 
int net_if_resume(struct net_if *iface);
 
bool net_if_is_suspended(struct net_if *iface);
#endif /* CONFIG_NET_POWER_MANAGEMENT */
 
bool net_if_is_wifi(struct net_if *iface);
 
struct net_if *net_if_get_first_wifi(void);
 
int net_if_get_name(struct net_if *iface, char *buf, int len);
 
int net_if_set_name(struct net_if *iface, const char *buf);
 
int net_if_get_by_name(const char *name);
 
struct net_if_api {
 void (*init)(struct net_if *iface);
};
 
#define NET_IF_DHCPV4_INIT \
 IF_ENABLED(UTIL_AND(IS_ENABLED(CONFIG_NET_DHCPV4), \
 IS_ENABLED(CONFIG_NET_NATIVE_IPV4)), \
 (.dhcpv4.state = NET_DHCPV4_DISABLED,))
 
#define NET_IF_DHCPV6_INIT \
 IF_ENABLED(UTIL_AND(IS_ENABLED(CONFIG_NET_DHCPV6), \
 IS_ENABLED(CONFIG_NET_NATIVE_IPV6)), \
 (.dhcpv6.state = NET_DHCPV6_DISABLED,))
 
#define NET_IF_CONFIG_INIT \
 .config = { \
 IF_ENABLED(CONFIG_NET_IP, (.ip = {},)) \
 NET_IF_DHCPV4_INIT \
 NET_IF_DHCPV6_INIT \
 }
 
#define NET_IF_GET_NAME(dev_id, sfx) __net_if_##dev_id##_##sfx
#define NET_IF_DEV_GET_NAME(dev_id, sfx) __net_if_dev_##dev_id##_##sfx
 
#define NET_IF_GET(dev_id, sfx) \
 ((struct net_if *)&NET_IF_GET_NAME(dev_id, sfx))
 
#define NET_IF_INIT(dev_id, sfx, _l2, _mtu, _num_configs) \
 static STRUCT_SECTION_ITERABLE(net_if_dev, \
 NET_IF_DEV_GET_NAME(dev_id, sfx)) = { \
 .dev = &(DEVICE_NAME_GET(dev_id)), \
 .l2 = &(NET_L2_GET_NAME(_l2)), \
 .l2_data = &(NET_L2_GET_DATA(dev_id, sfx)), \
 .mtu = _mtu, \
 .flags = {BIT(NET_IF_LOWER_UP)}, \
 }; \
 static Z_DECL_ALIGN(struct net_if) \
 NET_IF_GET_NAME(dev_id, sfx)[_num_configs] \
 __used __in_section(_net_if, static, \
 dev_id) = { \
 [0 ... (_num_configs - 1)] = { \
 .if_dev = &(NET_IF_DEV_GET_NAME(dev_id, sfx)), \
 NET_IF_CONFIG_INIT \
 } \
 }
 
#define NET_IF_OFFLOAD_INIT(dev_id, sfx, _mtu) \
 static STRUCT_SECTION_ITERABLE(net_if_dev, \
 NET_IF_DEV_GET_NAME(dev_id, sfx)) = { \
 .dev = &(DEVICE_NAME_GET(dev_id)), \
 .mtu = _mtu, \
 .l2 = &(NET_L2_GET_NAME(OFFLOADED_NETDEV)), \
 .flags = {BIT(NET_IF_LOWER_UP)}, \
 }; \
 static Z_DECL_ALIGN(struct net_if) \
 NET_IF_GET_NAME(dev_id, sfx)[NET_IF_MAX_CONFIGS] \
 __used __in_section(_net_if, static, \
 dev_id) = { \
 [0 ... (NET_IF_MAX_CONFIGS - 1)] = { \
 .if_dev = &(NET_IF_DEV_GET_NAME(dev_id, sfx)), \
 NET_IF_CONFIG_INIT \
 } \
 }
 
/* Network device initialization macros */
 
#define Z_NET_DEVICE_INIT_INSTANCE(node_id, dev_id, name, instance, \
 init_fn, pm, data, config, prio, \
 api, l2, l2_ctx_type, mtu) \
 Z_DEVICE_STATE_DEFINE(dev_id); \
 Z_DEVICE_DEFINE(node_id, dev_id, name, init_fn, pm, data, \
 config, POST_KERNEL, prio, api, \
 &Z_DEVICE_STATE_NAME(dev_id)); \
 NET_L2_DATA_INIT(dev_id, instance, l2_ctx_type); \
 NET_IF_INIT(dev_id, instance, l2, mtu, NET_IF_MAX_CONFIGS)
 
#define Z_NET_DEVICE_INIT(node_id, dev_id, name, init_fn, pm, data, \
 config, prio, api, l2, l2_ctx_type, mtu) \
 Z_NET_DEVICE_INIT_INSTANCE(node_id, dev_id, name, 0, init_fn, \
 pm, data, config, prio, api, l2, \
 l2_ctx_type, mtu)
 
#define NET_DEVICE_INIT(dev_id, name, init_fn, pm, data, config, prio, \
 api, l2, l2_ctx_type, mtu) \
 Z_NET_DEVICE_INIT(DT_INVALID_NODE, dev_id, name, init_fn, pm, \
 data, config, prio, api, l2, l2_ctx_type, mtu)
 
#define NET_DEVICE_DT_DEFINE(node_id, init_fn, pm, data, \
 config, prio, api, l2, l2_ctx_type, mtu) \
 Z_NET_DEVICE_INIT(node_id, Z_DEVICE_DT_DEV_ID(node_id), \
 DEVICE_DT_NAME(node_id), init_fn, pm, data, \
 config, prio, api, l2, l2_ctx_type, mtu)
 
#define NET_DEVICE_DT_INST_DEFINE(inst, ...) \
 NET_DEVICE_DT_DEFINE(DT_DRV_INST(inst), __VA_ARGS__)
 
#define NET_DEVICE_INIT_INSTANCE(dev_id, name, instance, init_fn, pm, \
 data, config, prio, api, l2, \
 l2_ctx_type, mtu) \
 Z_NET_DEVICE_INIT_INSTANCE(DT_INVALID_NODE, dev_id, name, \
 instance, init_fn, pm, data, config, \
 prio, api, l2, l2_ctx_type, mtu)
 
#define NET_DEVICE_DT_DEFINE_INSTANCE(node_id, instance, init_fn, pm, \
 data, config, prio, api, l2, \
 l2_ctx_type, mtu) \
 Z_NET_DEVICE_INIT_INSTANCE(node_id, \
 Z_DEVICE_DT_DEV_ID(node_id), \
 DEVICE_DT_NAME(node_id), instance, \
 init_fn, pm, data, config, prio, \
 api, l2, l2_ctx_type, mtu)
 
#define NET_DEVICE_DT_INST_DEFINE_INSTANCE(inst, ...) \
 NET_DEVICE_DT_DEFINE_INSTANCE(DT_DRV_INST(inst), __VA_ARGS__)
 
#define Z_NET_DEVICE_OFFLOAD_INIT(node_id, dev_id, name, init_fn, pm, \
 data, config, prio, api, mtu) \
 Z_DEVICE_STATE_DEFINE(dev_id); \
 Z_DEVICE_DEFINE(node_id, dev_id, name, init_fn, pm, data, \
 config, POST_KERNEL, prio, api, \
 &Z_DEVICE_STATE_NAME(dev_id)); \
 NET_IF_OFFLOAD_INIT(dev_id, 0, mtu)
 
#define NET_DEVICE_OFFLOAD_INIT(dev_id, name, init_fn, pm, data, \
 config, prio, api, mtu) \
 Z_NET_DEVICE_OFFLOAD_INIT(DT_INVALID_NODE, dev_id, name, \
 init_fn, pm, data, config, prio, api, \
 mtu)
 
#define NET_DEVICE_DT_OFFLOAD_DEFINE(node_id, init_fn, pm, data, \
 config, prio, api, mtu) \
 Z_NET_DEVICE_OFFLOAD_INIT(node_id, Z_DEVICE_DT_DEV_ID(node_id), \
 DEVICE_DT_NAME(node_id), init_fn, pm, \
 data, config, prio, api, mtu)
 
#define NET_DEVICE_DT_INST_OFFLOAD_DEFINE(inst, ...) \
 NET_DEVICE_DT_OFFLOAD_DEFINE(DT_DRV_INST(inst), __VA_ARGS__)
 
#define NET_IFACE_COUNT(_dst) \
 do { \
 extern struct net_if _net_if_list_start[]; \
 extern struct net_if _net_if_list_end[]; \
 *(_dst) = ((uintptr_t)_net_if_list_end - \
 (uintptr_t)_net_if_list_start) / \
 sizeof(struct net_if); \
 } while (0)
 
#ifdef __cplusplus
}
#endif
 
#include <syscalls/net_if.h>
 
#endif /* ZEPHYR_INCLUDE_NET_NET_IF_H_ */