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
 
#include <zephyr/net/prometheus/collector.h>
 
#ifdef __cplusplus
extern "C" {
#endif

#define NET_IF_IPV6_DAD_NONCE_LEN 6U

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;

                        sys_snode_t dad_need_node;

                        uint32_t dad_start;

                        uint8_t dad_count;

                        uint8_t dad_tx_failures;

                        uint8_t dad_nonce[NET_IF_IPV6_DAD_NONCE_LEN];
                };
#endif /* CONFIG_NET_IPV6_DAD */
#if defined(CONFIG_NET_IPV4_ACD)
                struct {
                        sys_snode_t acd_node;

                        sys_snode_t acd_need_node;

                        k_timepoint_t acd_timeout;

                        uint8_t acd_count;

                        uint8_t acd_state;
                };
#endif /* CONFIG_NET_IPV4_ACD */
                uint8_t _dummy;
        };
 
#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 is_added : 1;
 
        uint8_t _unused : 3;
};

struct net_if_mcast_addr {
        struct net_addr address;

        atomic_t atomic_ref;

        sys_snode_t rejoin_node;
 
#if defined(CONFIG_NET_IPV4_IGMP)
        k_timepoint_t igmp_resp_timeout;

        k_timepoint_t igmp_retx_timeout;

        uint8_t igmp_retx_left;
#endif
 
#if defined(CONFIG_NET_IPV6_MLD)
        k_timepoint_t mld_resp_timeout;

        k_timepoint_t mld_retx_timeout;

        uint8_t mld_retx_left;
#endif
 
#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 net_in6_addr prefix;

        struct net_if *iface;

        uint8_t len;

        uint8_t is_infinite : 1;

        uint8_t is_used : 1;

        uint8_t is_advertised : 1;
 
        uint8_t _unused : 5;
};

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_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_IID_STABLE)
        struct net_if_addr *iid;

        uint32_t network_counter;
#endif /* CONFIG_NET_IPV6_IID_STABLE */
 
#if defined(CONFIG_NET_IPV6_PE)
        uint32_t desync_factor;
#endif /* CONFIG_NET_IPV6_PE */
 
#if defined(CONFIG_NET_IPV6_MLD)
        k_timepoint_t mld_general_timeout;

        k_timepoint_t mld_v1_querier_timeout;

        uint8_t mld_version;
#endif
 
#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_IPV6_ND_RA_TX) && defined(CONFIG_NET_NATIVE_IPV6)
        int64_t ra_last_sent;

        int64_t ra_pending_at;

        uint8_t is_router : 1;
#endif
};
 
#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;

        uint32_t sol_max_rt;

        uint32_t inf_max_rt;

        uint32_t info_refresh_time;

        int16_t server_preference;

        uint8_t retransmissions;

        uint8_t tid[DHCPV6_TID_SIZE];

        uint8_t prefix_len;

        struct net_in6_addr prefix;

        struct net_in6_addr addr;
};
#endif /* defined(CONFIG_NET_DHCPV6) && defined(CONFIG_NET_NATIVE_IPV6) */

#if defined(CONFIG_NET_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 net_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 net_in_addr gw;

        uint8_t ttl;

        uint8_t mcast_ttl;
 
#if defined(CONFIG_NET_IPV4_IGMP)
        k_timepoint_t igmp_general_timeout;

        k_timepoint_t igmp_v1_querier_timeout;

        k_timepoint_t igmp_v2_querier_timeout;

        uint8_t igmp_version;
#endif
 
#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 net_in_addr server_id;

        struct net_in_addr requested_ip;

        struct net_in_addr netmask;

        enum net_dhcpv4_state state;

        uint8_t attempts;

        struct net_in_addr gw;

        struct net_in_addr gw_before;

        struct net_in_addr request_server_addr;

        struct net_in_addr response_src_addr;
 
#ifdef CONFIG_NET_DHCPV4_OPTION_NTP_SERVER
        struct net_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 net_in_addr requested_ip;

        enum net_ipv4_autoconf_state state;
};
#endif /* CONFIG_NET_IPV4_AUTO */

struct net_if_ip {
#if defined(CONFIG_NET_IPV6)
        struct net_if_ipv6 *ipv6;
#endif /* CONFIG_NET_IPV6 */
 
#if defined(CONFIG_NET_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;
 
#if NET_TC_COUNT > 1 || defined(CONFIG_NET_TC_TX_SKIP_FOR_HIGH_PRIO) \
        || defined(CONFIG_NET_TC_RX_SKIP_FOR_HIGH_PRIO)
        struct k_sem fifo_slot;
#endif

        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;

        int64_t oper_state_change_time;
};

struct net_if {
        struct net_if_dev *if_dev;
 
#if defined(CONFIG_NET_STATISTICS_PER_INTERFACE)
        struct net_stats stats;

        IF_ENABLED(CONFIG_NET_STATISTICS_VIA_PROMETHEUS,
                   (struct prometheus_collector *collector);)
#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)
{
        if (iface == NULL) {
                return;
        }
 
        NET_ASSERT(iface->if_dev != NULL);
 
        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)
{
        if (iface == NULL) {
                return false;
        }
 
        NET_ASSERT(iface->if_dev != NULL);
 
        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)
{
        if (iface == NULL) {
                return;
        }
 
        NET_ASSERT(iface->if_dev != NULL);
 
        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)
{
        if (iface == NULL) {
                return false;
        }
 
        NET_ASSERT(iface->if_dev != NULL);
 
        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)
{
        if (iface == NULL) {
                return false;
        }
 
        NET_ASSERT(iface->if_dev != NULL);
 
        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)
{
        if (iface == NULL) {
                return NET_IF_OPER_UNKNOWN;
        }
 
        NET_ASSERT(iface->if_dev != NULL);
 
        if (oper_state <= NET_IF_OPER_UP) {
                iface->if_dev->oper_state = oper_state;
        }
 
        net_if_lock(iface);
 
        iface->if_dev->oper_state_change_time = k_uptime_get();
 
        net_if_unlock(iface);
 
        return iface->if_dev->oper_state;
}

static inline enum net_if_oper_state net_if_oper_state(struct net_if *iface)
{
        if (iface == NULL) {
                return NET_IF_OPER_UNKNOWN;
        }
 
        NET_ASSERT(iface->if_dev != NULL);
 
        return iface->if_dev->oper_state;
}

static inline int net_if_oper_state_change_time(struct net_if *iface,
                                                int64_t *change_time)
{
        if (iface == NULL || change_time == NULL) {
                return -EINVAL;
        }
 
        NET_ASSERT(iface->if_dev != NULL);
 
        net_if_lock(iface);
 
        *change_time = iface->if_dev->oper_state_change_time;
 
        net_if_unlock(iface);
 
        return 0;
}

enum net_verdict net_if_try_send_data(struct net_if *iface,
                                      struct net_pkt *pkt, k_timeout_t timeout);

static inline enum net_verdict net_if_send_data(struct net_if *iface,
                                                struct net_pkt *pkt)
{
        k_timeout_t timeout = k_is_in_isr() ? K_NO_WAIT : K_FOREVER;
 
        return net_if_try_send_data(iface, pkt, timeout);
}

static inline const struct net_l2 *net_if_l2(struct net_if *iface)
{
        if (iface == NULL) {
                return NULL;
        }
 
        NET_ASSERT(iface->if_dev != 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)
{
        if (iface == NULL) {
                return NULL;
        }
 
        NET_ASSERT(iface->if_dev != NULL);
 
        return iface->if_dev->l2_data;
}

static inline const struct device *net_if_get_device(struct net_if *iface)
{
        if (iface == NULL) {
                return NULL;
        }
 
        NET_ASSERT(iface->if_dev != NULL);
 
        return iface->if_dev->dev;
}

void net_if_try_queue_tx(struct net_if *iface, struct net_pkt *pkt, k_timeout_t timeout);

static inline void net_if_queue_tx(struct net_if *iface, struct net_pkt *pkt)
{
        k_timeout_t timeout = k_is_in_isr() ? K_NO_WAIT : K_FOREVER;
 
        net_if_try_queue_tx(iface, pkt, timeout);
}

static inline bool net_if_is_ip_offloaded(struct net_if *iface)
{
#if defined(CONFIG_NET_OFFLOAD)
        __ASSERT_NO_MSG(iface == NULL || iface->if_dev != NULL);
        return (iface != 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)
        if (iface == NULL) {
                return NULL;
        }
 
        NET_ASSERT(iface->if_dev != NULL);
 
        return iface->if_dev->offload;
#else
        ARG_UNUSED(iface);
 
        return NULL;
#endif
}

static inline void net_if_offload_set(struct net_if *iface, struct net_offload *offload)
{
#if defined(CONFIG_NET_OFFLOAD)
        if (iface == NULL) {
                return;
        }
 
        NET_ASSERT(iface->if_dev != NULL);
 
        iface->if_dev->offload = offload;
#else
        ARG_UNUSED(iface);
        ARG_UNUSED(offload);
#endif
}

static inline bool net_if_is_socket_offloaded(struct net_if *iface)
{
#if defined(CONFIG_NET_SOCKETS_OFFLOAD)
        if (iface == NULL) {
                return false;
        }
 
        NET_ASSERT(iface->if_dev != NULL);
 
        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)
        if (iface == NULL) {
                return;
        }
 
        NET_ASSERT(iface->if_dev != NULL);
 
        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)
        if (iface == NULL) {
                return NULL;
        }
 
        NET_ASSERT(iface->if_dev != NULL);
 
        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)
{
        if (iface == NULL) {
                return NULL;
        }
 
        NET_ASSERT(iface->if_dev != NULL);
 
        return &iface->if_dev->link_addr;
}

static inline struct net_if_config *net_if_get_config(struct net_if *iface)
{
        if (iface == NULL) {
                return NULL;
        }
 
        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 net_in6_addr *ipv6_addr);
#else
static inline void net_if_nbr_reachability_hint(struct net_if *iface,
                                                const struct net_in6_addr *ipv6_addr)
{
        ARG_UNUSED(iface);
        ARG_UNUSED(ipv6_addr);
}
#endif

#if defined(CONFIG_NET_IPV6)
void net_if_ipv6_nbr_flush(struct net_if *iface);
#else
static inline void net_if_ipv6_nbr_flush(struct net_if *iface)
{
        ARG_UNUSED(iface);
}
#endif

#if defined(CONFIG_NET_IPV6)
bool net_if_ipv6_nbr_rm(struct net_if *iface, const struct net_in6_addr *addr);
#else
static inline bool net_if_ipv6_nbr_rm(struct net_if *iface,
                                      const struct net_in6_addr *addr)
{
        ARG_UNUSED(iface);
        ARG_UNUSED(addr);
 
        return false;
}
#endif

 
static inline int net_if_set_link_addr_unlocked(struct net_if *iface,
                                                const uint8_t *addr, uint8_t len,
                                                enum net_link_type type)
{
        int ret;
 
        if (net_if_flag_is_set(iface, NET_IF_RUNNING)) {
                return -EPERM;
        }
 
        if (len > sizeof(net_if_get_link_addr(iface)->addr)) {
                return -EINVAL;
        }
 
        ret = net_linkaddr_create(net_if_get_link_addr(iface), addr, len, type);
        if (ret < 0) {
                return ret;
        }
 
        net_hostname_set_postfix(addr, len);
 
        return 0;
}
 
int net_if_set_link_addr_locked(struct net_if *iface,
                                const 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,
                                   net_sa_family_t family,
                                   const void *addr,
                                   struct net_if_addr **ifaddr,
                                   const char *caller, int line);
#define net_if_addr_unref(iface, family, addr, ifaddr)                  \
        net_if_addr_unref_debug(iface, family, addr, ifaddr, __func__, __LINE__)
 
extern struct net_if_addr *net_if_addr_ref_debug(struct net_if *iface,
                                                 net_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,
                             net_sa_family_t family,
                             const void *addr,
                             struct net_if_addr **ifaddr);
extern struct net_if_addr *net_if_addr_ref(struct net_if *iface,
                                           net_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,
                                       const 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 != NULL);
 
        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 != NULL);
 
        iface->if_dev->mtu = mtu;
}

static inline void net_if_addr_set_lf(struct net_if_addr *ifaddr,
                                      bool is_infinite)
{
        if (ifaddr == NULL) {
                return;
        }
 
        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);

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_raw(const uint8_t *addr,
                                                struct net_if **ret);

struct net_if_addr *net_if_ipv6_addr_lookup(const struct net_in6_addr *addr,
                                            struct net_if **iface);

struct net_if_addr *net_if_ipv6_addr_lookup_by_iface_raw(struct net_if *iface,
                                                         const uint8_t *addr);

struct net_if_addr *net_if_ipv6_addr_lookup_by_iface(struct net_if *iface,
                                                     const struct net_in6_addr *addr);

__syscall int net_if_ipv6_addr_lookup_by_index(const struct net_in6_addr *addr);

struct net_if_addr *net_if_ipv6_addr_add(struct net_if *iface,
                                         const struct net_in6_addr *addr,
                                         enum net_addr_type addr_type,
                                         uint32_t vlifetime);

__syscall bool net_if_ipv6_addr_add_by_index(int index,
                                             const struct net_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 net_in6_addr *addr);

__syscall bool net_if_ipv6_addr_rm_by_index(int index,
                                            const struct net_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 net_in6_addr *addr);

bool net_if_ipv6_maddr_rm(struct net_if *iface, const struct net_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_raw(const uint8_t *maddr,
                                                       struct net_if **ret);

struct net_if_mcast_addr *net_if_ipv6_maddr_lookup(const struct net_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)
{
        if (addr == NULL) {
                return false;
        }
 
        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 net_in6_addr *addr);

struct net_if_ipv6_prefix *net_if_ipv6_prefix_lookup(struct net_if *iface,
                                                     const struct net_in6_addr *addr,
                                                     uint8_t len);

struct net_if_ipv6_prefix *net_if_ipv6_prefix_add(struct net_if *iface,
                                                  const struct net_in6_addr *prefix,
                                                  uint8_t len,
                                                  uint32_t lifetime);

bool net_if_ipv6_prefix_rm(struct net_if *iface, const struct net_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);

int net_if_ipv6_prefix_set_advertise(struct net_if *iface,
                                     const struct net_in6_addr *prefix,
                                     uint8_t len, bool advertise);

int net_if_ipv6_router_start(struct net_if *iface);

int net_if_ipv6_router_stop(struct net_if *iface);

bool net_if_ipv6_addr_onlink(struct net_if **iface, const struct net_in6_addr *addr);

#if defined(CONFIG_NET_NATIVE_IPV6)
static inline struct net_in6_addr *net_if_router_ipv6(struct net_if_router *router)
{
        if (router == NULL) {
                return NULL;
        }
 
        return &router->address.in6_addr;
}
#else
static inline struct net_in6_addr *net_if_router_ipv6(struct net_if_router *router)
{
        static struct net_in6_addr addr;
 
        ARG_UNUSED(router);
 
        return &addr;
}
#endif

struct net_if_router *net_if_ipv6_router_lookup(struct net_if *iface,
                                                const struct net_in6_addr *addr);

struct net_if_router *net_if_ipv6_router_find_default(struct net_if *iface,
                                                      const struct net_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,
                                             const struct net_in6_addr *addr,
                                             bool is_default,
                                             uint16_t router_lifetime);

bool net_if_ipv6_router_rm(struct net_if_router *router);

#if defined(CONFIG_NET_NATIVE_IPV6)
uint8_t net_if_ipv6_get_hop_limit(struct net_if *iface);
#else
static inline uint8_t net_if_ipv6_get_hop_limit(struct net_if *iface)
{
        ARG_UNUSED(iface);
 
        return 0;
}
#endif /* CONFIG_NET_NATIVE_IPV6 */

#if defined(CONFIG_NET_NATIVE_IPV6)
void net_if_ipv6_set_hop_limit(struct net_if *iface, uint8_t hop_limit);
#else
static inline void net_if_ipv6_set_hop_limit(struct net_if *iface,
                                             uint8_t hop_limit)
{
        ARG_UNUSED(iface);
        ARG_UNUSED(hop_limit);
}
#endif /* CONFIG_NET_NATIVE_IPV6 */

#if defined(CONFIG_NET_NATIVE_IPV6)
uint8_t net_if_ipv6_get_mcast_hop_limit(struct net_if *iface);
#else
static inline uint8_t net_if_ipv6_get_mcast_hop_limit(struct net_if *iface)
{
        ARG_UNUSED(iface);
 
        return 0;
}
#endif /* CONFIG_NET_NATIVE_IPV6 */

#if defined(CONFIG_NET_NATIVE_IPV6)
void net_if_ipv6_set_mcast_hop_limit(struct net_if *iface, uint8_t hop_limit);
#else
static inline void net_if_ipv6_set_mcast_hop_limit(struct net_if *iface,
                                                   uint8_t hop_limit)
{
        ARG_UNUSED(iface);
        ARG_UNUSED(hop_limit);
}
#endif /* CONFIG_NET_NATIVE_IPV6 */

#define NET_IPV6_MAX_REACHABLE_TIME 3600000U

static inline void net_if_ipv6_set_base_reachable_time(struct net_if *iface,
                                                       uint32_t reachable_time)
{
#if defined(CONFIG_NET_NATIVE_IPV6)
        if (iface == NULL) {
                return;
        }
 
        if (!iface->config.ip.ipv6) {
                return;
        }
 
        if (reachable_time > NET_IPV6_MAX_REACHABLE_TIME) {
                reachable_time = NET_IPV6_MAX_REACHABLE_TIME;
        }
 
        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_base_reachable_time(struct net_if *iface)
{
#if defined(CONFIG_NET_NATIVE_IPV6)
        if (iface == NULL) {
                return 0;
        }
 
        if (iface->config.ip.ipv6 == NULL) {
                return 0;
        }
 
        return iface->config.ip.ipv6->base_reachable_time;
#else
        ARG_UNUSED(iface);
        return 0;
#endif
}

static inline uint32_t net_if_ipv6_get_reachable_time(struct net_if *iface)
{
#if defined(CONFIG_NET_NATIVE_IPV6)
        if (iface == NULL) {
                return 0;
        }
 
        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)
        if (iface == NULL) {
                return;
        }
 
        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)
        if (iface == NULL) {
                return 0;
        }
 
        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_IPV6)
const struct net_in6_addr *net_if_ipv6_select_src_addr(struct net_if *iface,
                                                   const struct net_in6_addr *dst);
#else
static inline const struct net_in6_addr *net_if_ipv6_select_src_addr(
        struct net_if *iface, const struct net_in6_addr *dst)
{
        ARG_UNUSED(iface);
        ARG_UNUSED(dst);
 
        return NULL;
}
#endif

#if defined(CONFIG_NET_IPV6)
const struct net_in6_addr *net_if_ipv6_select_src_addr_hint(struct net_if *iface,
                                                        const struct net_in6_addr *dst,
                                                        int flags);
#else
static inline const struct net_in6_addr *net_if_ipv6_select_src_addr_hint(
        struct net_if *iface, const struct net_in6_addr *dst, int flags)
{
        ARG_UNUSED(iface);
        ARG_UNUSED(dst);
        ARG_UNUSED(flags);
 
        return NULL;
}
#endif

#if defined(CONFIG_NET_IPV6)
struct net_if *net_if_ipv6_select_src_iface(const struct net_in6_addr *dst);
#else
static inline struct net_if *net_if_ipv6_select_src_iface(
        const struct net_in6_addr *dst)
{
        ARG_UNUSED(dst);
 
        return NULL;
}
#endif

#if defined(CONFIG_NET_IPV6)
struct net_if *net_if_ipv6_select_src_iface_addr(const struct net_in6_addr *dst,
                                                 const struct net_in6_addr **src_addr);
#else
static inline struct net_if *net_if_ipv6_select_src_iface_addr(
        const struct net_in6_addr *dst, const struct net_in6_addr **src_addr)
{
        ARG_UNUSED(dst);
        ARG_UNUSED(src_addr);
 
        return NULL;
}
#endif /* CONFIG_NET_IPV6 */

struct net_in6_addr *net_if_ipv6_get_ll(struct net_if *iface,
                                    enum net_addr_state addr_state);

struct net_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 net_in6_addr *addr);

struct net_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);

bool net_if_ipv4_addr_onlink(struct net_if **iface, const struct net_in_addr *addr);

struct net_if_addr *net_if_ipv4_addr_lookup(const struct net_in_addr *addr,
                                            struct net_if **iface);

struct net_if_addr *net_if_ipv4_addr_lookup_by_iface_raw(struct net_if *iface,
                                                         const uint8_t *addr);

struct net_if_addr *net_if_ipv4_addr_lookup_by_iface(struct net_if *iface,
                                                     const struct net_in_addr *addr);

struct net_if_addr *net_if_ipv4_addr_add(struct net_if *iface,
                                         const struct net_in_addr *addr,
                                         enum net_addr_type addr_type,
                                         uint32_t vlifetime);

bool net_if_ipv4_addr_rm(struct net_if *iface, const struct net_in_addr *addr);

__syscall int net_if_ipv4_addr_lookup_by_index(const struct net_in_addr *addr);

__syscall bool net_if_ipv4_addr_add_by_index(int index,
                                             const struct net_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 net_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 net_in_addr *addr);

bool net_if_ipv4_maddr_rm(struct net_if *iface, const struct net_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 net_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)
{
        if (addr == NULL) {
                return false;
        }
 
        return addr->is_joined;
}

void net_if_ipv4_maddr_leave(struct net_if *iface,
                             struct net_if_mcast_addr *addr);

#if defined(CONFIG_NET_IPV4)
void net_if_ipv4_nbr_flush(struct net_if *iface);
#else
static inline void net_if_ipv4_nbr_flush(struct net_if *iface)
{
        ARG_UNUSED(iface);
}
#endif

#if defined(CONFIG_NET_IPV4)
bool net_if_ipv4_nbr_rm(struct net_if *iface, const struct net_in_addr *addr);
#else
static inline bool net_if_ipv4_nbr_rm(struct net_if *iface,
                                      const struct net_in_addr *addr)
{
        ARG_UNUSED(iface);
        ARG_UNUSED(addr);
 
        return false;
}
#endif

#if defined(CONFIG_NET_NATIVE_IPV4)
static inline struct net_in_addr *net_if_router_ipv4(struct net_if_router *router)
{
        if (router == NULL) {
                return NULL;
        }
 
        return &router->address.in_addr;
}
#else
static inline struct net_in_addr *net_if_router_ipv4(struct net_if_router *router)
{
        static struct net_in_addr addr;
 
        ARG_UNUSED(router);
 
        return &addr;
}
#endif

struct net_if_router *net_if_ipv4_router_lookup(struct net_if *iface,
                                                const struct net_in_addr *addr);

struct net_if_router *net_if_ipv4_router_find_default(struct net_if *iface,
                                                      const struct net_in_addr *addr);
struct net_if_router *net_if_ipv4_router_add(struct net_if *iface,
                                             const struct net_in_addr *addr,
                                             bool is_default,
                                             uint16_t router_lifetime);

bool net_if_ipv4_router_rm(struct net_if_router *router);

int net_if_ipv4_route_add(struct net_if *iface, const struct net_in_addr *addr, uint8_t mask_len,
                          const struct net_in_addr *nexthop, uint32_t lifetime);

bool net_if_ipv4_addr_mask_cmp(struct net_if *iface,
                               const struct net_in_addr *addr);

bool net_if_ipv4_is_addr_bcast(struct net_if *iface,
                               const struct net_in_addr *addr);

#if defined(CONFIG_NET_IPV4)
struct net_if *net_if_ipv4_select_src_iface(const struct net_in_addr *dst);
#else
static inline struct net_if *net_if_ipv4_select_src_iface(
        const struct net_in_addr *dst)
{
        ARG_UNUSED(dst);
 
        return NULL;
}
#endif

#if defined(CONFIG_NET_IPV4)
struct net_if *net_if_ipv4_select_src_iface_addr(const struct net_in_addr *dst,
                                                 const struct net_in_addr **src_addr);
#else
static inline struct net_if *net_if_ipv4_select_src_iface_addr(
        const struct net_in_addr *dst, const struct net_in_addr **src_addr)
{
        ARG_UNUSED(dst);
        ARG_UNUSED(src_addr);
 
        return NULL;
}
#endif /* CONFIG_NET_IPV4 */

#if defined(CONFIG_NET_IPV4)
const struct net_in_addr *net_if_ipv4_select_src_addr(struct net_if *iface,
                                                  const struct net_in_addr *dst);
#else
static inline const struct net_in_addr *net_if_ipv4_select_src_addr(
        struct net_if *iface, const struct net_in_addr *dst)
{
        ARG_UNUSED(iface);
        ARG_UNUSED(dst);
 
        return NULL;
}
#endif

struct net_in_addr *net_if_ipv4_get_ll(struct net_if *iface,
                                   enum net_addr_state addr_state);

struct net_in_addr *net_if_ipv4_get_global_addr(struct net_if *iface,
                                            enum net_addr_state addr_state);

struct net_in_addr net_if_ipv4_get_netmask_by_addr(struct net_if *iface,
                                               const struct net_in_addr *addr);

__syscall bool net_if_ipv4_set_netmask_by_addr_by_index(int index,
                                                        const struct net_in_addr *addr,
                                                        const struct net_in_addr *netmask);

bool net_if_ipv4_set_netmask_by_addr(struct net_if *iface,
                                     const struct net_in_addr *addr,
                                     const struct net_in_addr *netmask);

struct net_in_addr net_if_ipv4_get_gw(struct net_if *iface);

void net_if_ipv4_set_gw(struct net_if *iface, const struct net_in_addr *gw);

__syscall bool net_if_ipv4_set_gw_by_index(int index, const struct net_in_addr *gw);

struct net_if *net_if_select_src_iface(const struct net_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
};

#if defined(CONFIG_NET_CHECKSUM_OFFLOAD)
bool net_if_need_calc_rx_checksum(struct net_if *iface,
                                  enum net_if_checksum_type chksum_type);
#else /* CONFIG_NET_CHECKSUM_OFFLOAD */
static inline bool net_if_need_calc_rx_checksum(struct net_if *iface,
                                                enum net_if_checksum_type chksum_type)
{
        ARG_UNUSED(iface);
        ARG_UNUSED(chksum_type);
        return true;
}
#endif /* CONFIG_NET_CHECKSUM_OFFLOAD */

#if defined(CONFIG_NET_CHECKSUM_OFFLOAD)
bool net_if_need_calc_tx_checksum(struct net_if *iface,
                                  enum net_if_checksum_type chksum_type);
#else /* CONFIG_NET_CHECKSUM_OFFLOAD */
static inline bool net_if_need_calc_tx_checksum(struct net_if *iface,
                                                enum net_if_checksum_type chksum_type)
{
        ARG_UNUSED(iface);
        ARG_UNUSED(chksum_type);
        return true;
}
#endif /* CONFIG_NET_CHECKSUM_OFFLOAD */

__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)
{
        if (iface == NULL) {
                return false;
        }
 
        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)
{
        if (iface == NULL) {
                return false;
        }
 
        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)
{
        if (iface == NULL) {
                return false;
        }
 
        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)
{
        if (iface == NULL) {
                return false;
        }
 
        return net_if_flag_is_set(iface, NET_IF_DORMANT);
}
 
#if defined(CONFIG_NET_PKT_TIMESTAMP_THREAD) || defined(__DOXYGEN__)
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_THREAD */

#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_ethernet(struct net_if *iface);

struct net_if *net_if_get_first_ethernet(void);

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_PROMETHEUS_GET_COLLECTOR_NAME(dev_id, sfx)                  \
        net_stats_##dev_id##_##sfx##_collector
#define NET_PROMETHEUS_INIT(dev_id, sfx)                                \
        IF_ENABLED(CONFIG_NET_STATISTICS_VIA_PROMETHEUS,                \
                   (.collector = &NET_PROMETHEUS_GET_COLLECTOR_NAME(dev_id, sfx),))
 
#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))
 
#if defined(CONFIG_NET_STATISTICS_VIA_PROMETHEUS)
extern int net_stats_prometheus_scrape(struct prometheus_collector *collector,
                                       struct prometheus_metric *metric,
                                       void *user_data);
#endif /* CONFIG_NET_STATISTICS_VIA_PROMETHEUS */
 
#define NET_IF_INIT(dev_id, sfx, _l2, _mtu)                             \
        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 STRUCT_SECTION_ITERABLE(net_if,                          \
                                NET_IF_GET_NAME(dev_id, sfx)) = {       \
                .if_dev = &(NET_IF_DEV_GET_NAME(dev_id, sfx)),          \
                NET_IF_CONFIG_INIT                                      \
        };                                                              \
        IF_ENABLED(CONFIG_NET_STATISTICS_VIA_PROMETHEUS,                \
                   (static PROMETHEUS_COLLECTOR_DEFINE(                 \
                           NET_PROMETHEUS_GET_COLLECTOR_NAME(dev_id,    \
                                                             sfx),      \
                           net_stats_prometheus_scrape,                 \
                           NET_IF_GET(dev_id, sfx));                    \
                    NET_STATS_PROMETHEUS(NET_IF_GET(dev_id, sfx),       \
                                         dev_id, sfx);))
 
#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 STRUCT_SECTION_ITERABLE(net_if,                          \
                                NET_IF_GET_NAME(dev_id, sfx)) = {       \
                .if_dev = &(NET_IF_DEV_GET_NAME(dev_id, sfx)),          \
                NET_IF_CONFIG_INIT                                      \
        };                                                              \
        IF_ENABLED(CONFIG_NET_STATISTICS_VIA_PROMETHEUS,                \
                   (static PROMETHEUS_COLLECTOR_DEFINE(                 \
                           NET_PROMETHEUS_GET_COLLECTOR_NAME(dev_id,    \
                                                             sfx),      \
                           net_stats_prometheus_scrape,                 \
                           NET_IF_GET(dev_id, sfx));                    \
                    NET_STATS_PROMETHEUS(NET_IF_GET(dev_id, sfx),       \
                                         dev_id, sfx);))
 

 
/* Network device initialization macros */

#define NET_IF_DECLARE(dev_id, inst) \
        static struct net_if NET_IF_GET_NAME(dev_id, inst)
 
#define Z_NET_DEVICE_IF_INIT_INSTANCE(dev_id, instance, l2,             \
                                      l2_ctx_type, mtu)                 \
        NET_L2_DATA_INIT(dev_id, instance, l2_ctx_type);                \
        NET_IF_INIT(dev_id, instance, l2, mtu)
 
#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, NULL,           \
                        Z_DEVICE_DT_FLAGS(node_id), pm, data,           \
                        config, POST_KERNEL, prio, api,                 \
                        &Z_DEVICE_STATE_NAME(dev_id));                  \
        Z_NET_DEVICE_IF_INIT_INSTANCE(dev_id, instance, l2,             \
                                      l2_ctx_type, mtu)
 
#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_IF_DT_DECLARE(node_id, instance) \
        NET_IF_DECLARE(Z_DEVICE_DT_DEV_ID(node_id), instance)

#define NET_IF_DT_INST_DECLARE(inst, ...) NET_IF_DT_DECLARE(DT_DRV_INST(inst), __VA_ARGS__)

#define NET_IF_DT_GET(node_id, instance) NET_IF_GET(Z_DEVICE_DT_DEV_ID(node_id), instance)

#define NET_IF_DT_INST_GET(inst, ...) NET_IF_DT_GET(DT_DRV_INST(inst), __VA_ARGS__)

#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_ADD_IFACE(node_id, l2, l2_ctx_type, mtu, instance)                           \
        Z_NET_DEVICE_IF_INIT_INSTANCE(Z_DEVICE_DT_DEV_ID(node_id), instance, l2, l2_ctx_type, mtu)

#define NET_DEVICE_DT_INST_ADD_IFACE(inst, ...) \
        NET_DEVICE_DT_ADD_IFACE(DT_DRV_INST(inst), __VA_ARGS__)

#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, NULL,           \
                        Z_DEVICE_DT_FLAGS(node_id), 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_ */