virtual.h

Go to the documentation of this file.

 
/*
 * Copyright (c) 2021 Intel Corporation
 *
 * SPDX-License-Identifier: Apache-2.0
 */
 
#ifndef ZEPHYR_INCLUDE_NET_VIRTUAL_H_
#define ZEPHYR_INCLUDE_NET_VIRTUAL_H_
 
#include <zephyr/kernel.h>
#include <zephyr/types.h>
#include <stdbool.h>
#include <zephyr/sys/atomic.h>
 
#include <zephyr/net/net_ip.h>
#include <zephyr/net/net_pkt.h>
 
#include <zephyr/sys/util.h>
#include <zephyr/net/net_if.h>
 
#ifdef __cplusplus
extern "C" {
#endif
 
enum virtual_interface_caps {
        VIRTUAL_INTERFACE_IPIP = BIT(1),
 
        VIRTUAL_INTERFACE_VLAN = BIT(2),
 
        VIRTUAL_INTERFACE_BRIDGE = BIT(3),
 
        VIRTUAL_INTERFACE_VPN = BIT(4),
 
        /* Marker for capabilities - must be at the end of the enum.
         * It is here because the capability list cannot be empty.
         */
        VIRTUAL_INTERFACE_NUM_CAPS
};
enum virtual_interface_caps {…};
 
enum virtual_interface_config_type {
        VIRTUAL_INTERFACE_CONFIG_TYPE_PEER_ADDRESS,
        VIRTUAL_INTERFACE_CONFIG_TYPE_MTU,
        VIRTUAL_INTERFACE_CONFIG_TYPE_LINK_TYPE,
        VIRTUAL_INTERFACE_CONFIG_TYPE_PRIVATE_KEY,
        VIRTUAL_INTERFACE_CONFIG_TYPE_PUBLIC_KEY,
};
 
struct virtual_interface_link_types {
        int count;
        uint16_t type[COND_CODE_1(CONFIG_NET_CAPTURE_COOKED_MODE,
                                  (CONFIG_NET_CAPTURE_COOKED_MODE_MAX_LINK_TYPES),
                                  (1))];
};
 
#if !defined(NET_VIRTUAL_MAX_PUBLIC_KEY_LEN)
#define NET_VIRTUAL_MAX_PUBLIC_KEY_LEN 32U
#endif
 
struct virtual_interface_config {
        sa_family_t family;
        union {
                struct in_addr peer4addr;
                struct in6_addr peer6addr;
                int mtu;
                struct virtual_interface_link_types link_types;
                struct {
                        size_t len;
                        uint8_t *data;
                } private_key;
                struct {
                        size_t len;
                        uint8_t data[NET_VIRTUAL_MAX_PUBLIC_KEY_LEN];
                } public_key;
        };
};
 
#if defined(CONFIG_NET_L2_VIRTUAL)
#define VIRTUAL_MAX_NAME_LEN CONFIG_NET_L2_VIRTUAL_MAX_NAME_LEN
#else
#define VIRTUAL_MAX_NAME_LEN 0
#endif
struct virtual_interface_api {
        struct net_if_api iface_api;
 
        enum virtual_interface_caps (*get_capabilities)(struct net_if *iface);
 
        int (*start)(const struct device *dev);
 
        int (*stop)(const struct device *dev);
 
        int (*send)(struct net_if *iface, struct net_pkt *pkt);
 
        enum net_verdict (*recv)(struct net_if *iface, struct net_pkt *pkt);
 
        int (*attach)(struct net_if *virtual_iface, struct net_if *iface);
 
        int (*set_config)(struct net_if *iface,
                          enum virtual_interface_config_type type,
                          const struct virtual_interface_config *config);
 
        int (*get_config)(struct net_if *iface,
                          enum virtual_interface_config_type type,
                          struct virtual_interface_config *config);
};
struct virtual_interface_api {…};
 
/* Make sure that the network interface API is properly setup inside
 * Virtual API struct (it is the first one).
 */
BUILD_ASSERT(offsetof(struct virtual_interface_api, iface_api) == 0);
 
struct virtual_interface_context {
        /* Keep track of contexts */
        sys_snode_t node;
 
        /* My virtual network interface */
        struct net_if *virtual_iface;
        struct net_if *iface;
 
        enum net_l2_flags virtual_l2_flags;
 
        bool is_init;
 
        struct net_linkaddr lladdr;
 
        char name[VIRTUAL_MAX_NAME_LEN];
};
struct virtual_interface_context {…};
 
int net_virtual_interface_attach(struct net_if *virtual_iface,
                                  struct net_if *iface);
 
struct net_if *net_virtual_get_iface(struct net_if *iface);
 
char *net_virtual_get_name(struct net_if *iface, char *buf, size_t len);
 
void net_virtual_set_name(struct net_if *iface, const char *name);
 
enum net_l2_flags net_virtual_set_flags(struct net_if *iface,
                                        enum net_l2_flags flags);
 
enum net_verdict net_virtual_input(struct net_if *input_iface,
                                   struct net_addr *remote_addr,
                                   struct net_pkt *pkt);
 
#if defined(CONFIG_NET_L2_VIRTUAL)
void net_virtual_init(struct net_if *iface);
#else
static inline void net_virtual_init(struct net_if *iface)
{
        ARG_UNUSED(iface);
}
#endif
 
#if defined(CONFIG_NET_L2_VIRTUAL)
void net_virtual_disable(struct net_if *iface);
#else
static inline void net_virtual_disable(struct net_if *iface)
{
        ARG_UNUSED(iface);
}
#endif
 
#if defined(CONFIG_NET_L2_VIRTUAL)
void net_virtual_enable(struct net_if *iface);
#else
static inline void net_virtual_enable(struct net_if *iface)
{
        ARG_UNUSED(iface);
}
#endif
 
#define VIRTUAL_L2_CTX_TYPE     struct virtual_interface_context
 
static inline enum virtual_interface_caps
net_virtual_get_iface_capabilities(struct net_if *iface)
{
        const struct virtual_interface_api *virt =
                (struct virtual_interface_api *)net_if_get_device(iface)->api;
 
        if (!virt->get_capabilities) {
                return (enum virtual_interface_caps)0;
        }
 
        return virt->get_capabilities(iface);
}
 
#define Z_NET_VIRTUAL_INTERFACE_INIT(node_id, dev_id, name, init_fn,    \
                                     pm, data, config, prio, api, mtu)  \
        Z_NET_DEVICE_INIT(node_id, dev_id, name, init_fn, pm, data,     \
                          config, prio, api, VIRTUAL_L2,                \
                          NET_L2_GET_CTX_TYPE(VIRTUAL_L2), mtu)
 
#define Z_NET_VIRTUAL_INTERFACE_INIT_INSTANCE(node_id, dev_id, name,    \
                                              inst, init_fn, pm, data,  \
                                              config, prio, api, mtu)   \
        Z_NET_DEVICE_INIT_INSTANCE(node_id, dev_id, name, inst,         \
                                   init_fn, pm, data,                   \
                                   config, prio, api, VIRTUAL_L2,       \
                                   NET_L2_GET_CTX_TYPE(VIRTUAL_L2), mtu)
#define NET_VIRTUAL_INTERFACE_INIT(dev_id, name, init_fn, pm, data,     \
                                   config, prio, api, mtu)              \
        Z_NET_VIRTUAL_INTERFACE_INIT(DT_INVALID_NODE, dev_id, name,     \
                                     init_fn, pm, data, config, prio,   \
                                     api, mtu)
 
#define NET_VIRTUAL_INTERFACE_INIT_INSTANCE(dev_id, name, inst,          \
                                            init_fn, pm, data,           \
                                            config, prio, api, mtu)      \
        Z_NET_VIRTUAL_INTERFACE_INIT_INSTANCE(DT_INVALID_NODE, dev_id,   \
                                              name, inst,                \
                                              init_fn, pm, data, config, \
                                              prio, api, mtu)
 
#ifdef __cplusplus
}
#endif
 
#endif /* ZEPHYR_INCLUDE_NET_VIRTUAL_H_ */