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_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;
 
#if defined(CONFIG_NET_NATIVE_IPV6)
        struct net_timeout lifetime;
#endif
 
#if defined(CONFIG_NET_IPV6_DAD) && defined(CONFIG_NET_NATIVE_IPV6)
        sys_snode_t dad_node;
        uint32_t dad_start;
#endif
        enum net_addr_type addr_type;
 
        enum net_addr_state addr_state;
 
#if defined(CONFIG_NET_IPV6_DAD) && defined(CONFIG_NET_NATIVE_IPV6)
        uint8_t dad_count;
#endif
 
        uint8_t is_infinite : 1;
 
        uint8_t is_used : 1;
 
        uint8_t is_mesh_local : 1;
 
        uint8_t _unused : 5;
};
 
struct net_if_mcast_addr {
        struct net_addr address;
 
        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,
 
        /* 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_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;
};
 
#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_ipv4 {
        struct net_if_addr unicast[NET_IF_MAX_IPV4_ADDR];
 
        struct net_if_mcast_addr mcast[NET_IF_MAX_IPV4_MADDR];
 
        struct in_addr gw;
 
        struct in_addr netmask;
 
        uint8_t ttl;
};
 
#if defined(CONFIG_NET_DHCPV4) && defined(CONFIG_NET_NATIVE_IPV4)
struct net_if_dhcpv4 {
        sys_snode_t node;
 
        int64_t timer_start;
 
        uint32_t request_time;
 
        uint32_t xid;
 
        uint32_t lease_time;
 
        uint32_t renewal_time;
 
        uint32_t rebinding_time;
 
        struct in_addr server_id;
 
        struct in_addr requested_ip;
 
        enum net_dhcpv4_state state;
 
        uint8_t attempts;
 
        struct in_addr request_server_addr;
 
        struct in_addr response_src_addr;
};
#endif /* CONFIG_NET_DHCPV4 */
 
#if defined(CONFIG_NET_IPV4_AUTO) && defined(CONFIG_NET_NATIVE_IPV4)
struct net_if_ipv4_autoconf {
        sys_snode_t node;
 
        struct net_if *iface;
 
        int64_t timer_start;
 
        uint32_t timer_timeout;
 
        struct in_addr current_ip;
 
        struct in_addr requested_ip;
 
        enum net_ipv4_autoconf_state state;
 
        uint8_t probe_cnt;
 
        uint8_t announce_cnt;
 
        uint8_t conflict_cnt;
};
#endif /* CONFIG_NET_IPV4_AUTO */
 
/* We always need to have at least one IP config */
#define NET_IF_MAX_CONFIGS 1
struct net_if_ip {
#if defined(CONFIG_NET_NATIVE_IPV6)
        struct net_if_ipv6 *ipv6;
#endif /* CONFIG_NET_IPV6 */
 
#if defined(CONFIG_NET_NATIVE_IPV4)
        struct net_if_ipv4 *ipv4;
#endif /* CONFIG_NET_IPV4 */
};
 
struct net_if_config {
#if defined(CONFIG_NET_IP)
        struct net_if_ip ip;
#endif
 
#if defined(CONFIG_NET_DHCPV4) && defined(CONFIG_NET_NATIVE_IPV4)
        struct net_if_dhcpv4 dhcpv4;
#endif /* CONFIG_NET_DHCPV4 */
 
#if defined(CONFIG_NET_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 */
};
 
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;
 
        /* For internal use */
        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;
};
 
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 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)
        NET_ASSERT(iface);
        NET_ASSERT(iface->if_dev);
 
        return (iface->if_dev->offload != NULL);
#else
        ARG_UNUSED(iface);
 
        return false;
#endif
}
 
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 */
 
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);
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);
 
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);
 
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,
                                                  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_ipv6_set_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;
#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
        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);
#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;
#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
        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)
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);
 
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);
 
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);
 
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);
 
void net_if_ipv4_set_netmask(struct net_if *iface,
                             const struct in_addr *netmask);
 
__syscall bool net_if_ipv4_set_netmask_by_index(int index,
                                                const struct in_addr *netmask);
 
void net_if_ipv4_set_gw(struct net_if *iface, const struct in_addr *gw);
 
__syscall bool net_if_ipv4_set_gw_by_index(int index, const struct in_addr *gw);
 
struct net_if *net_if_select_src_iface(const struct sockaddr *dst);
 
typedef void (*net_if_link_callback_t)(struct net_if *iface,
                                       struct net_linkaddr *dst,
                                       int status);
 
struct net_if_link_cb {
        sys_snode_t node;
 
        net_if_link_callback_t cb;
};
 
void net_if_register_link_cb(struct net_if_link_cb *link,
                             net_if_link_callback_t cb);
 
void net_if_unregister_link_cb(struct net_if_link_cb *link);
 
void net_if_call_link_cb(struct net_if *iface, struct net_linkaddr *lladdr,
                         int status);
 
bool net_if_need_calc_rx_checksum(struct net_if *iface);
 
bool net_if_need_calc_tx_checksum(struct net_if *iface);
 
__syscall struct net_if *net_if_get_by_index(int index);
 
int net_if_get_by_iface(struct net_if *iface);
 
typedef void (*net_if_cb_t)(struct net_if *iface, void *user_data);
 
void net_if_foreach(net_if_cb_t cb, void *user_data);
 
int net_if_up(struct net_if *iface);
 
static inline bool net_if_is_up(struct net_if *iface)
{
        NET_ASSERT(iface);
 
        return net_if_flag_is_set(iface, NET_IF_UP) &&
               net_if_flag_is_set(iface, NET_IF_RUNNING);
}
 
int net_if_down(struct net_if *iface);
 
static inline bool net_if_is_admin_up(struct net_if *iface)
{
        NET_ASSERT(iface);
 
        return net_if_flag_is_set(iface, NET_IF_UP);
}
 
void net_if_carrier_on(struct net_if *iface);
 
void net_if_carrier_off(struct net_if *iface);
 
static inline bool net_if_is_carrier_ok(struct net_if *iface)
{
        NET_ASSERT(iface);
 
        return net_if_flag_is_set(iface, NET_IF_LOWER_UP);
}
 
void net_if_dormant_on(struct net_if *iface);
 
void net_if_dormant_off(struct net_if *iface);
 
static inline bool net_if_is_dormant(struct net_if *iface)
{
        NET_ASSERT(iface);
 
        return net_if_flag_is_set(iface, NET_IF_DORMANT);
}
 
#if defined(CONFIG_NET_PKT_TIMESTAMP) && defined(CONFIG_NET_NATIVE)
typedef void (*net_if_timestamp_callback_t)(struct net_pkt *pkt);
 
struct net_if_timestamp_cb {
        sys_snode_t node;
 
        struct net_pkt *pkt;
 
        struct net_if *iface;
 
        net_if_timestamp_callback_t cb;
};
 
void net_if_register_timestamp_cb(struct net_if_timestamp_cb *handle,
                                  struct net_pkt *pkt,
                                  struct net_if *iface,
                                  net_if_timestamp_callback_t cb);
 
void net_if_unregister_timestamp_cb(struct net_if_timestamp_cb *handle);
 
void net_if_call_timestamp_cb(struct net_pkt *pkt);
 
/*
 * @brief Add timestamped TX buffer to be handled
 *
 * @param pkt Timestamped buffer
 */
void net_if_add_tx_timestamp(struct net_pkt *pkt);
#endif /* CONFIG_NET_PKT_TIMESTAMP */
 
#if defined(CONFIG_NET_PROMISCUOUS_MODE)
int net_if_set_promisc(struct net_if *iface);
#else
static inline int net_if_set_promisc(struct net_if *iface)
{
        ARG_UNUSED(iface);
 
        return -ENOTSUP;
}
#endif
 
#if defined(CONFIG_NET_PROMISCUOUS_MODE)
void net_if_unset_promisc(struct net_if *iface);
#else
static inline void net_if_unset_promisc(struct net_if *iface)
{
        ARG_UNUSED(iface);
}
#endif
 
#if defined(CONFIG_NET_PROMISCUOUS_MODE)
bool net_if_is_promisc(struct net_if *iface);
#else
static inline bool net_if_is_promisc(struct net_if *iface)
{
        ARG_UNUSED(iface);
 
        return false;
}
#endif
 
static inline bool net_if_are_pending_tx_packets(struct net_if *iface)
{
#if defined(CONFIG_NET_POWER_MANAGEMENT)
        return !!iface->tx_pending;
#else
        ARG_UNUSED(iface);
 
        return false;
#endif
}
 
#ifdef CONFIG_NET_POWER_MANAGEMENT
int net_if_suspend(struct net_if *iface);
 
int net_if_resume(struct net_if *iface);
 
bool net_if_is_suspended(struct net_if *iface);
#endif /* CONFIG_NET_POWER_MANAGEMENT */
 
struct net_if_api {
        void (*init)(struct net_if *iface);
};
 
#if defined(CONFIG_NET_IP)
#define NET_IF_IP_INIT .ip = {},
#else
#define NET_IF_IP_INIT
#endif
 
#if defined(CONFIG_NET_DHCPV4) && defined(CONFIG_NET_NATIVE_IPV4)
#define NET_IF_DHCPV4_INIT .dhcpv4.state = NET_DHCPV4_DISABLED,
#else
#define NET_IF_DHCPV4_INIT
#endif
 
#define NET_IF_CONFIG_INIT                              \
        .config = {                                     \
                NET_IF_IP_INIT                          \
                NET_IF_DHCPV4_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,                                            \
        };                                                              \
        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)),             \
        };                                                              \
        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(node_id, dev_id, name, 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, 0, l2_ctx_type);                       \
        NET_IF_INIT(dev_id, 0, l2, mtu, NET_IF_MAX_CONFIGS)
 
#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 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 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__)
 
#ifdef __cplusplus
}
#endif
 
#include <syscalls/net_if.h>
 
#endif /* ZEPHYR_INCLUDE_NET_NET_IF_H_ */