net_context.h

Go to the documentation of this file.

 
/*
 * Copyright (c) 2016 Intel Corporation
 * Copyright (c) 2021 Nordic Semiconductor
 * Copyright (c) 2025 Aerlync Labs Inc.
 * Copyright 2025 NXP
 *
 * 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)

#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 net_sockaddr *addr,
                                    net_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 net_sockaddr_ptr local;

        struct net_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 net_sockaddr addr;
                        net_socklen_t addrlen;
                } proxy;
#endif
#if defined(CONFIG_NET_CONTEXT_CLAMP_PORT_RANGE)
                uint32_t port_range;
#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
#if defined(CONFIG_NET_IPV4_MAPPING_TO_IPV6)
                bool ipv6_v6only;
#endif
#if defined(CONFIG_NET_CONTEXT_RECV_PKTINFO)
                bool recv_pktinfo;
#endif
#if defined(CONFIG_NET_CONTEXT_RECV_HOPLIMIT)
                bool recv_hoplimit;
#endif
#if defined(CONFIG_NET_IPV6)
                uint16_t addr_preferences;
#endif
#if defined(CONFIG_NET_IPV6) || defined(CONFIG_NET_IPV4)
                union {
                        uint8_t ipv6_mcast_ifindex;

                        uint8_t ipv4_mcast_ifindex;
                };
                union {
                        bool ipv6_mcast_loop;  
                        bool ipv4_mcast_loop;  
                };

                bool dont_fragment;
#endif /* CONFIG_NET_IPV6 || CONFIG_NET_IPV4 */
 
#if defined(CONFIG_NET_CONTEXT_TIMESTAMPING)
                uint8_t timestamping;
#endif
        } options;

        uint16_t proto;

        uint16_t flags;

        int8_t iface;

        union {
                struct {
                        uint8_t ipv6_hop_limit;       
                        uint8_t ipv6_mcast_hop_limit; 
                };
                struct {
                        uint8_t ipv4_ttl;       
                        uint8_t ipv4_mcast_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 &= (uint16_t)~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 &= (uint16_t)~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 net_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,
                                          net_sa_family_t family)
{
        uint8_t flag = 0U;
 
        NET_ASSERT(context);
 
        if (family == NET_AF_UNSPEC || family == NET_AF_INET || family == NET_AF_INET6 ||
            family == NET_AF_PACKET || family == NET_AF_CAN) {
                /* Family is in BIT(4), BIT(5) and BIT(6) */
                flag = (uint8_t)(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 == NET_SOCK_DGRAM || type == NET_SOCK_STREAM || type == NET_SOCK_RAW) {
                /* Type is in BIT(6) and BIT(7)*/
                flag = (uint16_t)(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 = (uint8_t)net_if_get_by_iface(iface);
}

static inline void net_context_bind_iface(struct net_context *context,
                                          struct net_if *iface)
{
        NET_ASSERT(iface);
 
        context->flags |= NET_CONTEXT_BOUND_TO_IFACE;
        net_context_set_iface(context, 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_ipv4_mcast_ttl(struct net_context *context)
{
        return context->ipv4_mcast_ttl;
}

static inline void net_context_set_ipv4_mcast_ttl(struct net_context *context,
                                                  uint8_t ttl)
{
        context->ipv4_mcast_ttl = ttl;
}
 
#if defined(CONFIG_NET_IPV4)
static inline bool net_context_get_ipv4_mcast_loop(struct net_context *context)
{
        return context->options.ipv4_mcast_loop;
}

static inline void net_context_set_ipv4_mcast_loop(struct net_context *context,
                                                   bool ipv4_mcast_loop)
{
        context->options.ipv4_mcast_loop = ipv4_mcast_loop;
}
#endif

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;
}

static inline uint8_t net_context_get_ipv6_mcast_hop_limit(struct net_context *context)
{
        return context->ipv6_mcast_hop_limit;
}

static inline void net_context_set_ipv6_mcast_hop_limit(struct net_context *context,
                                                        uint8_t hop_limit)
{
        context->ipv6_mcast_hop_limit = hop_limit;
}
 
#if defined(CONFIG_NET_IPV6)

static inline bool net_context_get_ipv6_mcast_loop(struct net_context *context)
{
        return context->options.ipv6_mcast_loop;
}

static inline void net_context_set_ipv6_mcast_loop(struct net_context *context,
                                                   bool ipv6_mcast_loop)
{
        context->options.ipv6_mcast_loop = ipv6_mcast_loop;
}
 
#endif

#if defined(CONFIG_SOCKS)
static inline void net_context_set_proxy_enabled(struct net_context *context,
                                                 bool enable)
{
        context->proxy_enabled = enable;
}
#else
static inline void net_context_set_proxy_enabled(struct net_context *context,
                                                 bool enable)
{
        ARG_UNUSED(context);
        ARG_UNUSED(enable);
}
#endif

#if defined(CONFIG_SOCKS)
static inline bool net_context_is_proxy_enabled(struct net_context *context)
{
        return context->proxy_enabled;
}
#else
static inline bool net_context_is_proxy_enabled(struct net_context *context)
{
        ARG_UNUSED(context);
        return false;
}
#endif

int net_context_get(net_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 net_in_addr *src,
                                const struct net_in_addr *dst);
#else
static inline int net_context_create_ipv4_new(struct net_context *context,
                                              struct net_pkt *pkt,
                                              const struct net_in_addr *src,
                                              const struct net_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 net_in6_addr *src,
                                const struct net_in6_addr *dst);
#else
static inline int net_context_create_ipv6_new(struct net_context *context,
                                              struct net_pkt *pkt,
                                              const struct net_in6_addr *src,
                                              const struct net_in6_addr *dst)
{
        ARG_UNUSED(context);
        ARG_UNUSED(pkt);
        ARG_UNUSED(src);
        ARG_UNUSED(dst);
        return -1;
}
#endif /* CONFIG_NET_IPV6 */

int net_context_bind(struct net_context *context,
                     const struct net_sockaddr *addr,
                     net_socklen_t addrlen);

int net_context_listen(struct net_context *context,
                       int backlog);

int net_context_connect(struct net_context *context,
                        const struct net_sockaddr *addr,
                        net_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 net_sockaddr *dst_addr,
                       net_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 net_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, 
        NET_OPT_IPV6_V6ONLY       = 11, 
        NET_OPT_RECV_PKTINFO      = 12, 
        NET_OPT_MCAST_TTL         = 13, 
        NET_OPT_MCAST_HOP_LIMIT   = 14, 
        NET_OPT_UNICAST_HOP_LIMIT = 15, 
        NET_OPT_TTL               = 16, 
        NET_OPT_ADDR_PREFERENCES  = 17, 
        NET_OPT_TIMESTAMPING      = 18, 
        NET_OPT_MCAST_IFINDEX     = 19, 
        NET_OPT_MTU               = 20, 
        NET_OPT_LOCAL_PORT_RANGE  = 21, 
        NET_OPT_IPV6_MCAST_LOOP   = 22, 
        NET_OPT_IPV4_MCAST_LOOP   = 23, 
        NET_OPT_RECV_HOPLIMIT     = 24, 
        NET_OPT_DONT_FRAGMENT     = 25, 
};

int net_context_set_option(struct net_context *context,
                           enum net_context_option option,
                           const void *value, uint32_t len);

int net_context_get_option(struct net_context *context,
                           enum net_context_option option,
                           void *value, uint32_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 net_sockaddr *local_addr);
 
#ifdef __cplusplus
}
#endif

 
#endif /* ZEPHYR_INCLUDE_NET_NET_CONTEXT_H_ */