capture.h

Go to the documentation of this file.

 
/*
 * Copyright (c) 2021 Intel Corporation
 *
 * SPDX-License-Identifier: Apache-2.0
 */
 
#ifndef ZEPHYR_INCLUDE_NET_CAPTURE_H_
#define ZEPHYR_INCLUDE_NET_CAPTURE_H_
 
#include <zephyr/kernel.h>
#include <zephyr/device.h>
 
#ifdef __cplusplus
extern "C" {
#endif
 
struct net_if;
struct net_pkt;
struct device;
 
struct net_capture_interface_api {
        int (*cleanup)(const struct device *dev);
 
        int (*enable)(const struct device *dev, struct net_if *iface);
 
        int (*disable)(const struct device *dev);
 
        bool (*is_enabled)(const struct device *dev);
 
        int (*send)(const struct device *dev, struct net_if *iface, struct net_pkt *pkt);
};
 
int net_capture_setup(const char *remote_addr, const char *my_local_addr, const char *peer_addr,
                      const struct device **dev);
 
static inline int net_capture_cleanup(const struct device *dev)
{
#if defined(CONFIG_NET_CAPTURE)
        const struct net_capture_interface_api *api =
                (const struct net_capture_interface_api *)dev->api;
 
        return api->cleanup(dev);
#else
        ARG_UNUSED(dev);
 
        return -ENOTSUP;
#endif
}
 
static inline int net_capture_enable(const struct device *dev, struct net_if *iface)
{
#if defined(CONFIG_NET_CAPTURE)
        const struct net_capture_interface_api *api =
                (const struct net_capture_interface_api *)dev->api;
 
        return api->enable(dev, iface);
#else
        ARG_UNUSED(dev);
        ARG_UNUSED(iface);
 
        return -ENOTSUP;
#endif
}
 
static inline bool net_capture_is_enabled(const struct device *dev)
{
#if defined(CONFIG_NET_CAPTURE)
        const struct net_capture_interface_api *api;
 
        if (dev == NULL) {
                /* TODO: Go through all capture devices instead of one */
                dev = device_get_binding("NET_CAPTURE0");
                if (dev == NULL) {
                        return false;
                }
        }
 
        api = (const struct net_capture_interface_api *)dev->api;
 
        return api->is_enabled(dev);
#else
        ARG_UNUSED(dev);
 
        return false;
#endif
}
 
static inline int net_capture_disable(const struct device *dev)
{
#if defined(CONFIG_NET_CAPTURE)
        const struct net_capture_interface_api *api =
                (const struct net_capture_interface_api *)dev->api;
 
        return api->disable(dev);
#else
        ARG_UNUSED(dev);
 
        return -ENOTSUP;
#endif
}
 
static inline int net_capture_send(const struct device *dev, struct net_if *iface,
                                   struct net_pkt *pkt)
{
#if defined(CONFIG_NET_CAPTURE)
        const struct net_capture_interface_api *api =
                (const struct net_capture_interface_api *)dev->api;
 
        return api->send(dev, iface, pkt);
#else
        ARG_UNUSED(dev);
        ARG_UNUSED(iface);
        ARG_UNUSED(pkt);
 
        return -ENOTSUP;
#endif
}
 
#if defined(CONFIG_NET_CAPTURE)
void net_capture_pkt(struct net_if *iface, struct net_pkt *pkt);
#else
static inline void net_capture_pkt(struct net_if *iface, struct net_pkt *pkt)
{
        ARG_UNUSED(iface);
        ARG_UNUSED(pkt);
}
#endif
 
#if defined(CONFIG_NET_CAPTURE)
int net_capture_pkt_with_status(struct net_if *iface, struct net_pkt *pkt);
#else
static inline int net_capture_pkt_with_status(struct net_if *iface, struct net_pkt *pkt)
{
        ARG_UNUSED(iface);
        ARG_UNUSED(pkt);
 
        return -ENOTSUP;
}
#endif
 
enum net_capture_packet_type {
        NET_CAPTURE_HOST,      
        NET_CAPTURE_BROADCAST, 
        NET_CAPTURE_MULTICAST, 
        NET_CAPTURE_OTHERHOST, 
        NET_CAPTURE_OUTGOING,  
};
 
#define NET_CAPTURE_LL_ADDRLEN 8 
struct net_capture_cooked {
        uint16_t hatype;
        uint16_t halen;
        uint8_t addr[NET_CAPTURE_LL_ADDRLEN];
};
 
#if defined(CONFIG_NET_CAPTURE_COOKED_MODE)
int net_capture_cooked_setup(struct net_capture_cooked *ctx,
                             uint16_t hatype,
                             uint16_t halen,
                             uint8_t *addr);
#else
static inline int net_capture_cooked_setup(struct net_capture_cooked *ctx,
                                           uint16_t hatype,
                                           uint16_t halen,
                                           uint8_t *addr)
{
        ARG_UNUSED(ctx);
        ARG_UNUSED(hatype);
        ARG_UNUSED(halen);
        ARG_UNUSED(addr);
 
        return -ENOTSUP;
}
#endif
 
#if defined(CONFIG_NET_CAPTURE_COOKED_MODE)
void net_capture_data(struct net_capture_cooked *ctx,
                      const uint8_t *data, size_t len,
                      enum net_capture_packet_type type,
                      uint16_t ptype);
#else
static inline void net_capture_data(struct net_capture_cooked *ctx,
                                    const uint8_t *data, size_t len,
                                    enum net_capture_packet_type type,
                                    uint16_t ptype)
{
        ARG_UNUSED(ctx);
        ARG_UNUSED(data);
        ARG_UNUSED(len);
        ARG_UNUSED(type);
        ARG_UNUSED(ptype);
}
#endif
 
struct net_capture_info {
        const struct device *capture_dev;
        struct net_if *capture_iface;
        struct net_if *tunnel_iface;
        struct sockaddr *peer;
        struct sockaddr *local;
        bool is_enabled;
};
 
typedef void (*net_capture_cb_t)(struct net_capture_info *info, void *user_data);
 
#if defined(CONFIG_NET_CAPTURE)
void net_capture_foreach(net_capture_cb_t cb, void *user_data);
#else
static inline void net_capture_foreach(net_capture_cb_t cb, void *user_data)
{
        ARG_UNUSED(cb);
        ARG_UNUSED(user_data);
}
#endif
 
#ifdef __cplusplus
}
#endif
 
#endif /* ZEPHYR_INCLUDE_NET_CAPTURE_H_ */