net_context.h

Go to the documentation of this file.

 
/*
 * Copyright (c) 2016 Intel Corporation
 * Copyright (c) 2021 Nordic Semiconductor
 *
 * SPDX-License-Identifier: Apache-2.0
 */
 
#ifndef ZEPHYR_INCLUDE_NET_NET_CONTEXT_H_
#define ZEPHYR_INCLUDE_NET_NET_CONTEXT_H_
 
#include <zephyr/kernel.h>
#include <zephyr/sys/atomic.h>
 
#include <zephyr/net/net_ip.h>
#include <zephyr/net/net_if.h>
#include <zephyr/net/net_stats.h>
 
#ifdef __cplusplus
extern "C" {
#endif
 
#define NET_CONTEXT_IN_USE BIT(0)
 
enum net_context_state {
        NET_CONTEXT_IDLE = 0,
        NET_CONTEXT_UNCONNECTED = 0,
        NET_CONTEXT_CONFIGURING = 1,
        NET_CONTEXT_CONNECTING = 1,
        NET_CONTEXT_READY = 2,
        NET_CONTEXT_CONNECTED = 2,
        NET_CONTEXT_LISTENING = 3,
};
 
#define NET_CONTEXT_FAMILY (BIT(3) | BIT(4) | BIT(5))
 
#define NET_CONTEXT_TYPE   (BIT(6) | BIT(7))
 
#define NET_CONTEXT_REMOTE_ADDR_SET  BIT(8)
 
#define NET_CONTEXT_ACCEPTING_SOCK  BIT(9)
 
#define NET_CONTEXT_CLOSING_SOCK  BIT(10)
 
/* Context is bound to a specific interface */
#define NET_CONTEXT_BOUND_TO_IFACE BIT(11)
 
struct net_context;
 
typedef void (*net_context_recv_cb_t)(struct net_context *context,
                                      struct net_pkt *pkt,
                                      union net_ip_header *ip_hdr,
                                      union net_proto_header *proto_hdr,
                                      int status,
                                      void *user_data);
 
typedef void (*net_context_send_cb_t)(struct net_context *context,
                                      int status,
                                      void *user_data);
 
typedef void (*net_tcp_accept_cb_t)(struct net_context *new_context,
                                    struct sockaddr *addr,
                                    socklen_t addrlen,
                                    int status,
                                    void *user_data);
 
typedef void (*net_context_connect_cb_t)(struct net_context *context,
                                         int status,
                                         void *user_data);
 
/* The net_pkt_get_slab_func_t is here in order to avoid circular
 * dependency between net_pkt.h and net_context.h
 */
typedef struct k_mem_slab *(*net_pkt_get_slab_func_t)(void);
 
/* The net_pkt_get_pool_func_t is here in order to avoid circular
 * dependency between net_pkt.h and net_context.h
 */
typedef struct net_buf_pool *(*net_pkt_get_pool_func_t)(void);
 
struct net_tcp;
 
struct net_conn_handle;
 
__net_socket struct net_context {
        void *fifo_reserved;
 
        void *user_data;
 
        atomic_t refcount;
 
        struct k_mutex lock;
 
        struct sockaddr_ptr local;
 
        struct sockaddr remote;
 
        struct net_conn_handle *conn_handler;
 
        net_context_recv_cb_t recv_cb;
 
        net_context_send_cb_t send_cb;
 
        net_context_connect_cb_t connect_cb;
 
#if defined(CONFIG_NET_CONTEXT_NET_PKT_POOL)
        net_pkt_get_slab_func_t tx_slab;
 
        net_pkt_get_pool_func_t data_pool;
#endif /* CONFIG_NET_CONTEXT_NET_PKT_POOL */
 
#if defined(CONFIG_NET_TCP)
        void *tcp;
#endif /* CONFIG_NET_TCP */
 
#if defined(CONFIG_NET_CONTEXT_SYNC_RECV)
        struct k_sem recv_data_wait;
#endif /* CONFIG_NET_CONTEXT_SYNC_RECV */
 
#if defined(CONFIG_NET_SOCKETS)
        void *socket_data;
 
        union {
                struct k_fifo recv_q;
                struct k_fifo accept_q;
        };
 
        struct {
                struct k_condvar recv;
 
                struct k_mutex *lock;
        } cond;
#endif /* CONFIG_NET_SOCKETS */
 
#if defined(CONFIG_NET_OFFLOAD)
        void *offload_context;
#endif /* CONFIG_NET_OFFLOAD */
 
#if defined(CONFIG_NET_SOCKETS_CAN)
        int can_filter_id;
#endif /* CONFIG_NET_SOCKETS_CAN */
 
        struct {
#if defined(CONFIG_NET_CONTEXT_PRIORITY)
                uint8_t priority;
#endif
#if defined(CONFIG_NET_CONTEXT_TXTIME)
                bool txtime;
#endif
#if defined(CONFIG_SOCKS)
                struct {
                        struct sockaddr addr;
                        socklen_t addrlen;
                } proxy;
#endif
#if defined(CONFIG_NET_CONTEXT_RCVTIMEO)
                k_timeout_t rcvtimeo;
#endif
#if defined(CONFIG_NET_CONTEXT_SNDTIMEO)
                k_timeout_t sndtimeo;
#endif
#if defined(CONFIG_NET_CONTEXT_RCVBUF)
                uint16_t rcvbuf;
#endif
#if defined(CONFIG_NET_CONTEXT_SNDBUF)
                uint16_t sndbuf;
#endif
#if defined(CONFIG_NET_CONTEXT_DSCP_ECN)
                uint8_t dscp_ecn;
#endif
#if defined(CONFIG_NET_CONTEXT_REUSEADDR)
                bool reuseaddr;
#endif
#if defined(CONFIG_NET_CONTEXT_REUSEPORT)
                bool reuseport;
#endif
        } options;
 
        uint16_t proto;
 
        uint16_t flags;
 
        int8_t iface;
 
        union {
                uint8_t ipv6_hop_limit;
                uint8_t ipv4_ttl;
        };
 
#if defined(CONFIG_SOCKS)
        bool proxy_enabled;
#endif
 
};
 
static inline bool net_context_is_used(struct net_context *context)
{
        NET_ASSERT(context);
 
        return context->flags & NET_CONTEXT_IN_USE;
}
 
static inline bool net_context_is_bound_to_iface(struct net_context *context)
{
        NET_ASSERT(context);
 
        return context->flags & NET_CONTEXT_BOUND_TO_IFACE;
}
 
static inline bool net_context_is_accepting(struct net_context *context)
{
        NET_ASSERT(context);
 
        return context->flags & NET_CONTEXT_ACCEPTING_SOCK;
}
 
static inline void net_context_set_accepting(struct net_context *context,
                                             bool accepting)
{
        NET_ASSERT(context);
 
        if (accepting) {
                context->flags |= NET_CONTEXT_ACCEPTING_SOCK;
        } else {
                context->flags &= ~NET_CONTEXT_ACCEPTING_SOCK;
        }
}
 
static inline bool net_context_is_closing(struct net_context *context)
{
        NET_ASSERT(context);
 
        return context->flags & NET_CONTEXT_CLOSING_SOCK;
}
 
static inline void net_context_set_closing(struct net_context *context,
                                           bool closing)
{
        NET_ASSERT(context);
 
        if (closing) {
                context->flags |= NET_CONTEXT_CLOSING_SOCK;
        } else {
                context->flags &= ~NET_CONTEXT_CLOSING_SOCK;
        }
}
 
#define NET_CONTEXT_STATE_SHIFT 1
#define NET_CONTEXT_STATE_MASK 0x03
 
static inline
enum net_context_state net_context_get_state(struct net_context *context)
{
        NET_ASSERT(context);
 
        return (enum net_context_state)
                ((context->flags >> NET_CONTEXT_STATE_SHIFT) &
                NET_CONTEXT_STATE_MASK);
}
 
static inline void net_context_set_state(struct net_context *context,
                                         enum net_context_state state)
{
        NET_ASSERT(context);
 
        context->flags &= ~(NET_CONTEXT_STATE_MASK << NET_CONTEXT_STATE_SHIFT);
        context->flags |= ((state & NET_CONTEXT_STATE_MASK) <<
                           NET_CONTEXT_STATE_SHIFT);
}
 
static inline sa_family_t net_context_get_family(struct net_context *context)
{
        NET_ASSERT(context);
 
        return ((context->flags & NET_CONTEXT_FAMILY) >> 3);
}
 
static inline void net_context_set_family(struct net_context *context,
                                          sa_family_t family)
{
        uint8_t flag = 0U;
 
        NET_ASSERT(context);
 
        if (family == AF_UNSPEC || family == AF_INET || family == AF_INET6 ||
            family == AF_PACKET || family == AF_CAN) {
                /* Family is in BIT(4), BIT(5) and BIT(6) */
                flag = family << 3;
        }
 
        context->flags |= flag;
}
 
static inline
enum net_sock_type net_context_get_type(struct net_context *context)
{
        NET_ASSERT(context);
 
        return (enum net_sock_type)((context->flags & NET_CONTEXT_TYPE) >> 6);
}
 
static inline void net_context_set_type(struct net_context *context,
                                        enum net_sock_type type)
{
        uint16_t flag = 0U;
 
        NET_ASSERT(context);
 
        if (type == SOCK_DGRAM || type == SOCK_STREAM || type == SOCK_RAW) {
                /* Type is in BIT(6) and BIT(7)*/
                flag = type << 6;
        }
 
        context->flags |= flag;
}
 
#if defined(CONFIG_NET_SOCKETS_CAN)
static inline void net_context_set_can_filter_id(struct net_context *context,
                                             int filter_id)
{
        NET_ASSERT(context);
 
        context->can_filter_id = filter_id;
}
#else
static inline void net_context_set_can_filter_id(struct net_context *context,
                                             int filter_id)
{
        ARG_UNUSED(context);
        ARG_UNUSED(filter_id);
}
#endif
 
#if defined(CONFIG_NET_SOCKETS_CAN)
static inline int net_context_get_can_filter_id(struct net_context *context)
{
        NET_ASSERT(context);
 
        return context->can_filter_id;
}
#else
static inline int net_context_get_can_filter_id(struct net_context *context)
{
        ARG_UNUSED(context);
 
        return -1;
}
#endif
 
static inline uint16_t net_context_get_proto(struct net_context *context)
{
        return context->proto;
}
 
static inline void net_context_set_proto(struct net_context *context,
                                         uint16_t proto)
{
        context->proto = proto;
}
 
static inline
struct net_if *net_context_get_iface(struct net_context *context)
{
        NET_ASSERT(context);
 
        return net_if_get_by_index(context->iface);
}
 
static inline void net_context_set_iface(struct net_context *context,
                                         struct net_if *iface)
{
        NET_ASSERT(iface);
 
        context->iface = net_if_get_by_iface(iface);
}
 
static inline uint8_t net_context_get_ipv4_ttl(struct net_context *context)
{
        return context->ipv4_ttl;
}
 
static inline void net_context_set_ipv4_ttl(struct net_context *context,
                                            uint8_t ttl)
{
        context->ipv4_ttl = ttl;
}
 
static inline uint8_t net_context_get_ipv6_hop_limit(struct net_context *context)
{
        return context->ipv6_hop_limit;
}
 
static inline void net_context_set_ipv6_hop_limit(struct net_context *context,
                                                  uint8_t hop_limit)
{
        context->ipv6_hop_limit = hop_limit;
}
 
#if defined(CONFIG_SOCKS)
static inline void net_context_set_proxy_enabled(struct net_context *context,
                                                 bool enable)
{
        context->proxy_enabled = enable;
}
 
static inline bool net_context_is_proxy_enabled(struct net_context *context)
{
        return context->proxy_enabled;
}
#else
static inline void net_context_set_proxy_enabled(struct net_context *context,
                                                 bool enable)
{
        ARG_UNUSED(context);
        ARG_UNUSED(enable);
}
 
static inline bool net_context_is_proxy_enabled(struct net_context *context)
{
        return false;
}
#endif
 
int net_context_get(sa_family_t family,
                    enum net_sock_type type,
                    uint16_t ip_proto,
                    struct net_context **context);
 
int net_context_put(struct net_context *context);
 
int net_context_ref(struct net_context *context);
 
int net_context_unref(struct net_context *context);
 
#if defined(CONFIG_NET_IPV4)
int net_context_create_ipv4_new(struct net_context *context,
                                struct net_pkt *pkt,
                                const struct in_addr *src,
                                const struct in_addr *dst);
#else
static inline int net_context_create_ipv4_new(struct net_context *context,
                                              struct net_pkt *pkt,
                                              const struct in_addr *src,
                                              const struct in_addr *dst)
{
        return -1;
}
#endif /* CONFIG_NET_IPV4 */
 
#if defined(CONFIG_NET_IPV6)
int net_context_create_ipv6_new(struct net_context *context,
                                struct net_pkt *pkt,
                                const struct in6_addr *src,
                                const struct in6_addr *dst);
#else
static inline int net_context_create_ipv6_new(struct net_context *context,
                                              struct net_pkt *pkt,
                                              const struct in6_addr *src,
                                              const struct in6_addr *dst)
{
        return -1;
}
#endif /* CONFIG_NET_IPV6 */
 
int net_context_bind(struct net_context *context,
                     const struct sockaddr *addr,
                     socklen_t addrlen);
 
int net_context_listen(struct net_context *context,
                       int backlog);
 
int net_context_connect(struct net_context *context,
                        const struct sockaddr *addr,
                        socklen_t addrlen,
                        net_context_connect_cb_t cb,
                        k_timeout_t timeout,
                        void *user_data);
 
int net_context_accept(struct net_context *context,
                       net_tcp_accept_cb_t cb,
                       k_timeout_t timeout,
                       void *user_data);
 
int net_context_send(struct net_context *context,
                     const void *buf,
                     size_t len,
                     net_context_send_cb_t cb,
                     k_timeout_t timeout,
                     void *user_data);
 
int net_context_sendto(struct net_context *context,
                       const void *buf,
                       size_t len,
                       const struct sockaddr *dst_addr,
                       socklen_t addrlen,
                       net_context_send_cb_t cb,
                       k_timeout_t timeout,
                       void *user_data);
 
int net_context_sendmsg(struct net_context *context,
                        const struct msghdr *msghdr,
                        int flags,
                        net_context_send_cb_t cb,
                        k_timeout_t timeout,
                        void *user_data);
 
int net_context_recv(struct net_context *context,
                     net_context_recv_cb_t cb,
                     k_timeout_t timeout,
                     void *user_data);
 
int net_context_update_recv_wnd(struct net_context *context,
                                int32_t delta);
 
enum net_context_option {
        NET_OPT_PRIORITY        = 1,
        NET_OPT_TXTIME          = 2,
        NET_OPT_SOCKS5          = 3,
        NET_OPT_RCVTIMEO        = 4,
        NET_OPT_SNDTIMEO        = 5,
        NET_OPT_RCVBUF          = 6,
        NET_OPT_SNDBUF          = 7,
        NET_OPT_DSCP_ECN        = 8,
        NET_OPT_REUSEADDR       = 9,
        NET_OPT_REUSEPORT       = 10,
};
 
int net_context_set_option(struct net_context *context,
                           enum net_context_option option,
                           const void *value, size_t len);
 
int net_context_get_option(struct net_context *context,
                           enum net_context_option option,
                           void *value, size_t *len);
 
typedef void (*net_context_cb_t)(struct net_context *context, void *user_data);
 
void net_context_foreach(net_context_cb_t cb, void *user_data);
 
#if defined(CONFIG_NET_CONTEXT_NET_PKT_POOL)
static inline void net_context_setup_pools(struct net_context *context,
                                           net_pkt_get_slab_func_t tx_slab,
                                           net_pkt_get_pool_func_t data_pool)
{
        NET_ASSERT(context);
 
        context->tx_slab = tx_slab;
        context->data_pool = data_pool;
}
#else
#define net_context_setup_pools(context, tx_pool, data_pool)
#endif
 
bool net_context_port_in_use(enum net_ip_protocol ip_proto,
        uint16_t local_port, const struct sockaddr *local_addr);
 
#ifdef __cplusplus
}
#endif
 
#endif /* ZEPHYR_INCLUDE_NET_NET_CONTEXT_H_ */