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
 
        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
#endif /* CONFIG_NET_NATIVE_IPV6 */
 
        union {
#if defined(CONFIG_NET_IPV6_DAD)
                struct {
                        sys_snode_t dad_node;
                        uint32_t dad_start;
 
                        uint8_t dad_count;
                };
#endif /* CONFIG_NET_IPV6_DAD */
#if defined(CONFIG_NET_IPV4_ACD)
                struct {
                        sys_snode_t acd_node;
                        k_timepoint_t acd_timeout;
 
                        uint8_t acd_count;
 
                        uint8_t acd_state;
                };
#endif /* CONFIG_NET_IPV4_ACD */
        };
 
#if defined(CONFIG_NET_IPV6_DAD) || defined(CONFIG_NET_IPV4_ACD)
        uint8_t ifindex;
#endif
 
        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_IPV4_ACD)
        uint8_t conflict_cnt;
#endif
};
 
#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 {
        struct net_if *iface;
 
        struct in_addr requested_ip;
 
        enum net_ipv4_autoconf_state state;
};
#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);
 
/* used to ensure encoding of checksum support in net_if.h and
 * ethernet.h is the same
 */
#define NET_IF_CHECKSUM_NONE_BIT                        0
#define NET_IF_CHECKSUM_IPV4_HEADER_BIT                 BIT(0)
#define NET_IF_CHECKSUM_IPV4_ICMP_BIT                   BIT(1)
/* Space for future protocols and restrictions for IPV4 */
#define NET_IF_CHECKSUM_IPV6_HEADER_BIT                 BIT(10)
#define NET_IF_CHECKSUM_IPV6_ICMP_BIT                   BIT(11)
/* Space for future protocols and restrictions for IPV6 */
#define NET_IF_CHECKSUM_TCP_BIT                         BIT(21)
#define NET_IF_CHECKSUM_UDP_BIT                         BIT(22)
 
enum net_if_checksum_type {
        NET_IF_CHECKSUM_IPV4_HEADER = NET_IF_CHECKSUM_IPV4_HEADER_BIT,
        NET_IF_CHECKSUM_IPV4_TCP    = NET_IF_CHECKSUM_IPV4_HEADER_BIT |
                                      NET_IF_CHECKSUM_TCP_BIT,
        NET_IF_CHECKSUM_IPV4_UDP    = NET_IF_CHECKSUM_IPV4_HEADER_BIT |
                                      NET_IF_CHECKSUM_UDP_BIT,
        NET_IF_CHECKSUM_IPV4_ICMP   = NET_IF_CHECKSUM_IPV4_ICMP_BIT,
        NET_IF_CHECKSUM_IPV6_HEADER = NET_IF_CHECKSUM_IPV6_HEADER_BIT,
        NET_IF_CHECKSUM_IPV6_TCP    = NET_IF_CHECKSUM_IPV6_HEADER_BIT |
                                      NET_IF_CHECKSUM_TCP_BIT,
        NET_IF_CHECKSUM_IPV6_UDP    = NET_IF_CHECKSUM_IPV6_HEADER_BIT |
                                      NET_IF_CHECKSUM_UDP_BIT,
        NET_IF_CHECKSUM_IPV6_ICMP   = NET_IF_CHECKSUM_IPV6_ICMP_BIT
};
 
bool net_if_need_calc_rx_checksum(struct net_if *iface,
                                  enum net_if_checksum_type chksum_type);
 
bool net_if_need_calc_tx_checksum(struct net_if *iface,
                                  enum net_if_checksum_type chksum_type);
 
__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);
 
struct net_if *net_if_get_wifi_sta(void);
 
struct net_if *net_if_get_wifi_sap(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 <zephyr/syscalls/net_if.h>
 
#endif /* ZEPHYR_INCLUDE_NET_NET_IF_H_ */