net_mgmt.h

Go to the documentation of this file.

/*
 * Copyright (c) 2016 Intel Corporation.
 *
 * SPDX-License-Identifier: Apache-2.0
 */

 
#ifndef ZEPHYR_INCLUDE_NET_NET_MGMT_H_
#define ZEPHYR_INCLUDE_NET_NET_MGMT_H_
 
#include <zephyr/sys/__assert.h>
#include <zephyr/net/net_core.h>
#include <zephyr/sys/iterable_sections.h>
 
#ifdef __cplusplus
extern "C" {
#endif

 
struct net_if;

#define NET_MGMT_EVENT_MASK        GENMASK64(63, 63) /* 0x8000000000000000 */
#define NET_MGMT_ON_IFACE_MASK     GENMASK64(62, 62) /* 0x4000000000000000 */
#define NET_MGMT_LAYER_MASK        GENMASK64(61, 60) /* 0x3000000000000000 */
#define NET_MGMT_SYNC_EVENT_MASK   GENMASK64(59, 59) /* 0x0800000000000000 */
#define NET_MGMT_LAYER_CODE_MASK   GENMASK64(58, 52) /* 0x07F0000000000000 */
#define NET_MGMT_COMMAND_MASK      GENMASK64(51, 0)  /* 0x000FFFFFFFFFFFFF */
 
#define NET_MGMT_MAX_COMMANDS 52 /* TODO: figure out the value from mask */
 
#define NET_MGMT_EVENT_BIT         BIT64(63)
#define NET_MGMT_IFACE_BIT         BIT64(62)
#define NET_MGMT_SYNC_EVENT_BIT    BIT64(59)
 
#define NET_MGMT_LAYER(_layer)     FIELD_PREP(NET_MGMT_LAYER_MASK, (_layer))
#define NET_MGMT_LAYER_CODE(_code) FIELD_PREP(NET_MGMT_LAYER_CODE_MASK, (_code))
 
#define NET_MGMT_EVENT(mgmt_request)             FIELD_GET(NET_MGMT_EVENT_MASK, mgmt_request)
#define NET_MGMT_ON_IFACE(mgmt_request)          FIELD_GET(NET_MGMT_ON_IFACE_MASK, mgmt_request)
#define NET_MGMT_EVENT_SYNCHRONOUS(mgmt_request) FIELD_GET(NET_MGMT_SYNC_EVENT_MASK, mgmt_request)
#define NET_MGMT_GET_LAYER(mgmt_request)         FIELD_GET(NET_MGMT_LAYER_MASK, mgmt_request)
#define NET_MGMT_GET_LAYER_CODE(mgmt_request)    FIELD_GET(NET_MGMT_LAYER_CODE_MASK, mgmt_request)
#define NET_MGMT_GET_COMMAND(mgmt_request)       FIELD_GET(NET_MGMT_COMMAND_MASK, mgmt_request)
 
#define NET_MGMT_CMD(cmd) cmd = BIT64(cmd ##_VAL)
 
/* Useful generic definitions */
#define NET_MGMT_LAYER_L2               1
#define NET_MGMT_LAYER_L3               2
#define NET_MGMT_LAYER_L4               3


enum net_mgmt_layer_code {
        NET_MGMT_LAYER_CODE_UNKNOWN    = 0x00, 
        NET_MGMT_LAYER_CODE_IFACE      = 0x01, 
        NET_MGMT_LAYER_CODE_CONN       = 0x02, 
        NET_MGMT_LAYER_CODE_IPV4       = 0x03, 
        NET_MGMT_LAYER_CODE_IPV6       = 0x04, 
        NET_MGMT_LAYER_CODE_L4         = 0x05, 
        NET_MGMT_LAYER_CODE_COAP       = 0x06, 
        NET_MGMT_LAYER_CODE_STATS      = 0x07, 
        NET_MGMT_LAYER_CODE_HOSTAP     = 0x08, 
        NET_MGMT_LAYER_CODE_ETHERNET   = 0x09, 
        NET_MGMT_LAYER_CODE_IEEE802514 = 0x0A, 
        NET_MGMT_LAYER_CODE_PPP        = 0x0B, 
        NET_MGMT_LAYER_CODE_VIRTUAL    = 0x0C, 
        NET_MGMT_LAYER_CODE_WIFI       = 0x0D, 
        NET_MGMT_LAYER_CODE_PACKET     = 0x0E, 
 
        /* Out of tree code can use the following userX layer codes */
        NET_MGMT_LAYER_CODE_USER3      = 0x7C, 
        NET_MGMT_LAYER_CODE_USER2      = 0x7D, 
        NET_MGMT_LAYER_CODE_USER1      = 0x7E, 
 
        /* Reserved layer code for future use */
        NET_MGMT_LAYER_CODE_RESERVED   = 0x7F  
};
 
#include <zephyr/net/net_event.h>

typedef int (*net_mgmt_request_handler_t)(uint64_t mgmt_request,
                                          struct net_if *iface,
                                          void *data, size_t len);

#define net_mgmt(_mgmt_request, _iface, _data, _len)                    \
        net_mgmt_##_mgmt_request(_mgmt_request, _iface, _data, _len)

#define NET_MGMT_DEFINE_REQUEST_HANDLER(_mgmt_request)                  \
        extern int net_mgmt_##_mgmt_request(uint64_t mgmt_request,      \
                                            struct net_if *iface,       \
                                            void *data, size_t len)

#define NET_MGMT_REGISTER_REQUEST_HANDLER(_mgmt_request, _func) \
        FUNC_ALIAS(_func, net_mgmt_##_mgmt_request, int)
 
struct net_mgmt_event_callback;

typedef void (*net_mgmt_event_handler_t)(struct net_mgmt_event_callback *cb,
                                         uint64_t mgmt_event,
                                         struct net_if *iface);

struct net_mgmt_event_callback {
        sys_snode_t node;
 
        union {
                net_mgmt_event_handler_t handler;
                struct k_sem *sync_call;
        };
 
#ifdef CONFIG_NET_MGMT_EVENT_INFO
        const void *info;
        size_t info_length;
#endif

        union {
                uint64_t event_mask;
                uint64_t raised_event;
        };
};

typedef void (*net_mgmt_event_static_handler_t)(uint64_t mgmt_event,
                                                struct net_if *iface,
                                                void *info, size_t info_length,
                                                void *user_data);

 
/* Structure for event handler registered at compile time */
struct net_mgmt_event_static_handler {
        uint64_t event_mask;
        net_mgmt_event_static_handler_t handler;
        void *user_data;
};


#define NET_MGMT_REGISTER_EVENT_HANDLER(_name, _event_mask, _func, _user_data)  \
        const STRUCT_SECTION_ITERABLE(net_mgmt_event_static_handler, _name) = { \
                .event_mask = _event_mask,                                      \
                .handler = _func,                                               \
                .user_data = (void *)_user_data,                                \
        }

#ifdef CONFIG_NET_MGMT_EVENT
static inline
void net_mgmt_init_event_callback(struct net_mgmt_event_callback *cb,
                                  net_mgmt_event_handler_t handler,
                                  uint64_t mgmt_event_mask)
{
        __ASSERT(cb, "Callback pointer should not be NULL");
        __ASSERT(handler, "Handler pointer should not be NULL");
 
        cb->handler = handler;
        cb->event_mask = mgmt_event_mask;
};
#else
#define net_mgmt_init_event_callback(...)
#endif

#ifdef CONFIG_NET_MGMT_EVENT
void net_mgmt_add_event_callback(struct net_mgmt_event_callback *cb);
#else
#define net_mgmt_add_event_callback(...)
#endif

#ifdef CONFIG_NET_MGMT_EVENT
void net_mgmt_del_event_callback(struct net_mgmt_event_callback *cb);
#else
#define net_mgmt_del_event_callback(...)
#endif
 
#if defined(CONFIG_NET_MGMT_EVENT) || defined(__DOXYGEN__)
void net_mgmt_event_notify_with_info(uint64_t mgmt_event, struct net_if *iface,
                                     const void *info, size_t length);
#else
static inline void net_mgmt_event_notify_with_info(uint64_t mgmt_event, struct net_if *iface,
                                                   const void *info, size_t length)
{
        ARG_UNUSED(mgmt_event);
        ARG_UNUSED(iface);
        ARG_UNUSED(info);
        ARG_UNUSED(length);
}
#endif
 
#if defined(CONFIG_NET_MGMT_EVENT) || defined(__DOXYGEN__)
static inline void net_mgmt_event_notify(uint64_t mgmt_event,
                                         struct net_if *iface)
{
        net_mgmt_event_notify_with_info(mgmt_event, iface, NULL, 0);
}
#else
static inline void net_mgmt_event_notify(uint64_t mgmt_event,
                                         struct net_if *iface)
{
        ARG_UNUSED(mgmt_event);
        ARG_UNUSED(iface);
}
#endif

#ifdef CONFIG_NET_MGMT_EVENT
int net_mgmt_event_wait(uint64_t mgmt_event_mask,
                        uint64_t *raised_event,
                        struct net_if **iface,
                        const void **info,
                        size_t *info_length,
                        k_timeout_t timeout);
#else
static inline int net_mgmt_event_wait(uint64_t mgmt_event_mask,
                                      uint64_t *raised_event,
                                      struct net_if **iface,
                                      const void **info,
                                      size_t *info_length,
                                      k_timeout_t timeout)
{
        ARG_UNUSED(mgmt_event_mask);
        ARG_UNUSED(raised_event);
        ARG_UNUSED(iface);
        ARG_UNUSED(info);
        ARG_UNUSED(info_length);
        ARG_UNUSED(timeout);
        return 0;
}
#endif

#ifdef CONFIG_NET_MGMT_EVENT
int net_mgmt_event_wait_on_iface(struct net_if *iface,
                                 uint64_t mgmt_event_mask,
                                 uint64_t *raised_event,
                                 const void **info,
                                 size_t *info_length,
                                 k_timeout_t timeout);
#else
static inline int net_mgmt_event_wait_on_iface(struct net_if *iface,
                                               uint64_t mgmt_event_mask,
                                               uint64_t *raised_event,
                                               const void **info,
                                               size_t *info_length,
                                               k_timeout_t timeout)
{
        ARG_UNUSED(iface);
        ARG_UNUSED(mgmt_event_mask);
        ARG_UNUSED(raised_event);
        ARG_UNUSED(info);
        ARG_UNUSED(info_length);
        ARG_UNUSED(timeout);
        return 0;
}
#endif

#ifdef CONFIG_NET_MGMT_EVENT
void net_mgmt_event_init(void);
#else
#define net_mgmt_event_init(...)
#endif /* CONFIG_NET_MGMT_EVENT */

 
#ifdef __cplusplus
}
#endif
 
#endif /* ZEPHYR_INCLUDE_NET_NET_MGMT_H_ */