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)
 
#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
#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_IPV6)
 uint16_t addr_preferences;
#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 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 = (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 == SOCK_DGRAM || type == SOCK_STREAM || type == 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;
}
 
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_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(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)
{
 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 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, 
 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, 
};
 
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_ */