faa0b2a848
This provides the infrastructure to create network packet filter rules and to apply them to the RX and TX packet paths. Rules are made of simple condition tests that can be linked together, creating a facility similarly to the Linux iptables functionality. A couple of generic and Ethernet-specific condition tests are also provided. Additional tests can be easily created on top of this. Signed-off-by: Nicolas Pitre <npitre@baylibre.com>
2188 lines
57 KiB
C
2188 lines
57 KiB
C
/** @file
|
|
* @brief Network packet buffer descriptor API
|
|
*
|
|
* Network data is passed between different parts of the stack via
|
|
* net_buf struct.
|
|
*/
|
|
|
|
/*
|
|
* Copyright (c) 2016 Intel Corporation
|
|
*
|
|
* SPDX-License-Identifier: Apache-2.0
|
|
*/
|
|
|
|
/* Data buffer API - used for all data to/from net */
|
|
|
|
#ifndef ZEPHYR_INCLUDE_NET_NET_PKT_H_
|
|
#define ZEPHYR_INCLUDE_NET_NET_PKT_H_
|
|
|
|
#include <zephyr/types.h>
|
|
#include <stdbool.h>
|
|
|
|
#include <net/buf.h>
|
|
|
|
#include <net/net_core.h>
|
|
#include <net/net_linkaddr.h>
|
|
#include <net/net_ip.h>
|
|
#include <net/net_if.h>
|
|
#include <net/net_context.h>
|
|
#include <net/ethernet_vlan.h>
|
|
#include <net/ptp_time.h>
|
|
|
|
#ifdef __cplusplus
|
|
extern "C" {
|
|
#endif
|
|
|
|
/**
|
|
* @brief Network packet management library
|
|
* @defgroup net_pkt Network Packet Library
|
|
* @ingroup networking
|
|
* @{
|
|
*/
|
|
|
|
struct net_context;
|
|
struct canbus_net_isotp_tx_ctx;
|
|
struct canbus_net_isotp_rx_ctx;
|
|
|
|
|
|
/* buffer cursor used in net_pkt */
|
|
struct net_pkt_cursor {
|
|
/** Current net_buf pointer by the cursor */
|
|
struct net_buf *buf;
|
|
/** Current position in the data buffer of the net_buf */
|
|
uint8_t *pos;
|
|
};
|
|
|
|
/**
|
|
* @brief Network packet.
|
|
*
|
|
* Note that if you add new fields into net_pkt, remember to update
|
|
* net_pkt_clone() function.
|
|
*/
|
|
struct net_pkt {
|
|
/**
|
|
* The fifo is used by RX/TX threads and by socket layer. The net_pkt
|
|
* is queued via fifo to the processing thread.
|
|
*/
|
|
intptr_t fifo;
|
|
|
|
/** Slab pointer from where it belongs to */
|
|
struct k_mem_slab *slab;
|
|
|
|
/** buffer holding the packet */
|
|
union {
|
|
struct net_buf *frags;
|
|
struct net_buf *buffer;
|
|
};
|
|
|
|
/** Internal buffer iterator used for reading/writing */
|
|
struct net_pkt_cursor cursor;
|
|
|
|
/** Network connection context */
|
|
struct net_context *context;
|
|
|
|
/** Network interface */
|
|
struct net_if *iface;
|
|
|
|
/** @cond ignore */
|
|
|
|
#if defined(CONFIG_NET_ROUTING) || defined(CONFIG_NET_ETHERNET_BRIDGE)
|
|
struct net_if *orig_iface; /* Original network interface */
|
|
#endif
|
|
|
|
#if defined(CONFIG_NET_PKT_TIMESTAMP)
|
|
/** Timestamp if available. */
|
|
struct net_ptp_time timestamp;
|
|
#endif
|
|
|
|
#if defined(CONFIG_NET_PKT_RXTIME_STATS) || defined(CONFIG_NET_PKT_TXTIME_STATS)
|
|
struct {
|
|
/** Create time in cycles */
|
|
uint32_t create_time;
|
|
|
|
#if defined(CONFIG_NET_PKT_TXTIME_STATS_DETAIL) || \
|
|
defined(CONFIG_NET_PKT_RXTIME_STATS_DETAIL)
|
|
/** Collect extra statistics for net_pkt processing
|
|
* from various points in the IP stack. See networking
|
|
* documentation where these points are located and how
|
|
* to interpret the results.
|
|
*/
|
|
struct {
|
|
uint32_t stat[NET_PKT_DETAIL_STATS_COUNT];
|
|
int count;
|
|
} detail;
|
|
#endif /* CONFIG_NET_PKT_TXTIME_STATS_DETAIL ||
|
|
CONFIG_NET_PKT_RXTIME_STATS_DETAIL */
|
|
};
|
|
#endif /* CONFIG_NET_PKT_RXTIME_STATS || CONFIG_NET_PKT_TXTIME_STATS */
|
|
|
|
#if defined(CONFIG_NET_PKT_TXTIME)
|
|
/** Network packet TX time in the future (in nanoseconds) */
|
|
uint64_t txtime;
|
|
#endif /* CONFIG_NET_PKT_TXTIME */
|
|
|
|
/** Reference counter */
|
|
atomic_t atomic_ref;
|
|
|
|
/* Filled by layer 2 when network packet is received. */
|
|
struct net_linkaddr lladdr_src;
|
|
struct net_linkaddr lladdr_dst;
|
|
|
|
#if defined(CONFIG_NET_TCP)
|
|
/** Allow placing the packet into sys_slist_t */
|
|
sys_snode_t next;
|
|
#endif
|
|
|
|
uint8_t ip_hdr_len; /* pre-filled in order to avoid func call */
|
|
|
|
uint8_t overwrite : 1; /* Is packet content being overwritten? */
|
|
|
|
uint8_t sent_or_eof: 1; /* For outgoing packet: is this sent or not
|
|
* For incoming packet of a socket: last
|
|
* packet before EOF
|
|
* Used only if defined(CONFIG_NET_TCP)
|
|
*/
|
|
union {
|
|
uint8_t pkt_queued: 1; /* For outgoing packet: is this packet
|
|
* queued to be sent but has not reached
|
|
* the driver yet.
|
|
* Used only if defined(CONFIG_NET_TCP)
|
|
*/
|
|
uint8_t ptp_pkt: 1; /* For outgoing packet: is this packet
|
|
* a L2 PTP packet.
|
|
* Used only if defined (CONFIG_NET_L2_PTP)
|
|
*/
|
|
};
|
|
|
|
uint8_t forwarding : 1; /* Are we forwarding this pkt
|
|
* Used only if defined(CONFIG_NET_ROUTE)
|
|
*/
|
|
uint8_t family : 3; /* IPv4 vs IPv6 */
|
|
|
|
union {
|
|
uint8_t ipv4_auto_arp_msg : 1; /* Is this pkt IPv4 autoconf ARP
|
|
* message. Used only if
|
|
* defined(CONFIG_NET_IPV4_AUTO).
|
|
* Note: family needs to be
|
|
* AF_INET.
|
|
*/
|
|
uint8_t lldp_pkt : 1; /* Is this pkt an LLDP message.
|
|
* Used only if
|
|
* defined(CONFIG_NET_LLDP).
|
|
* Note: family needs to be
|
|
* AF_UNSPEC.
|
|
*/
|
|
uint8_t ppp_msg : 1; /* This is a PPP message */
|
|
};
|
|
|
|
#if defined(CONFIG_NET_TCP)
|
|
uint8_t tcp_first_msg : 1; /* Is this the first time this pkt is
|
|
* sent, or is this a resend of a TCP
|
|
* segment.
|
|
*/
|
|
#endif
|
|
|
|
uint8_t captured : 1; /* Set to 1 if this packet is already being
|
|
* captured
|
|
*/
|
|
|
|
uint8_t l2_bridged : 1; /* set to 1 if this packet comes from a bridge
|
|
* and already contains its L2 header to be
|
|
* preserved. Useful only if
|
|
* defined(CONFIG_NET_ETHERNET_BRIDGE).
|
|
*/
|
|
|
|
union {
|
|
/* IPv6 hop limit or IPv4 ttl for this network packet.
|
|
* The value is shared between IPv6 and IPv4.
|
|
*/
|
|
uint8_t ipv6_hop_limit;
|
|
uint8_t ipv4_ttl;
|
|
};
|
|
|
|
union {
|
|
#if defined(CONFIG_NET_IPV4)
|
|
uint8_t ipv4_opts_len; /* Length if IPv4 Header Options */
|
|
#endif
|
|
#if defined(CONFIG_NET_IPV6)
|
|
uint16_t ipv6_ext_len; /* length of extension headers */
|
|
#endif
|
|
};
|
|
|
|
/** Network packet priority, can be left out in which case packet
|
|
* is not prioritised.
|
|
*/
|
|
uint8_t priority;
|
|
|
|
#if defined(CONFIG_NET_VLAN)
|
|
/* VLAN TCI (Tag Control Information). This contains the Priority
|
|
* Code Point (PCP), Drop Eligible Indicator (DEI) and VLAN
|
|
* Identifier (VID, called more commonly VLAN tag). This value is
|
|
* kept in host byte order.
|
|
*/
|
|
uint16_t vlan_tci;
|
|
#endif /* CONFIG_NET_VLAN */
|
|
|
|
#if defined(CONFIG_NET_IPV6)
|
|
/* Where is the start of the last header before payload data
|
|
* in IPv6 packet. This is offset value from start of the IPv6
|
|
* packet. Note that this value should be updated by who ever
|
|
* adds IPv6 extension headers to the network packet.
|
|
*/
|
|
uint16_t ipv6_prev_hdr_start;
|
|
|
|
#if defined(CONFIG_NET_IPV6_FRAGMENT)
|
|
uint16_t ipv6_fragment_flags; /* Fragment offset and M (More Fragment) flag */
|
|
uint32_t ipv6_fragment_id; /* Fragment id */
|
|
uint16_t ipv6_frag_hdr_start; /* Where starts the fragment header */
|
|
#endif /* CONFIG_NET_IPV6_FRAGMENT */
|
|
|
|
uint8_t ipv6_ext_opt_len; /* IPv6 ND option length */
|
|
uint8_t ipv6_next_hdr; /* What is the very first next header */
|
|
#endif /* CONFIG_NET_IPV6 */
|
|
|
|
#if defined(CONFIG_IEEE802154)
|
|
uint8_t ieee802154_rssi; /* Received Signal Strength Indication */
|
|
uint8_t ieee802154_lqi; /* Link Quality Indicator */
|
|
uint8_t ieee802154_arb : 1; /* ACK Request Bit is set in the frame */
|
|
uint8_t ieee802154_ack_fpb : 1; /* Frame Pending Bit was set in the ACK */
|
|
uint8_t ieee802154_frame_secured : 1; /* Frame is authenticated and
|
|
* encrypted according to its
|
|
* Auxiliary Security Header
|
|
*/
|
|
uint8_t ieee802154_mac_hdr_rdy : 1; /* Indicates if frame's MAC header
|
|
* is ready to be transmitted or if
|
|
* it requires further modifications,
|
|
* e.g. Frame Counter injection.
|
|
*/
|
|
#if defined(CONFIG_IEEE802154_2015)
|
|
uint8_t ieee802154_fv2015 : 1; /* Frame version is IEEE 802.15.4-2015 */
|
|
uint8_t ieee802154_ack_seb : 1; /* Security Enabled Bit was set in the ACK */
|
|
uint32_t ieee802154_ack_fc; /* Frame counter set in the ACK */
|
|
uint8_t ieee802154_ack_keyid; /* Key index set in the ACK */
|
|
#endif
|
|
#endif
|
|
#if defined(CONFIG_NET_L2_CANBUS)
|
|
union {
|
|
struct canbus_isotp_tx_ctx *canbus_tx_ctx;
|
|
struct canbus_isotp_rx_ctx *canbus_rx_ctx;
|
|
};
|
|
#endif
|
|
/* @endcond */
|
|
};
|
|
|
|
/** @cond ignore */
|
|
|
|
/* The interface real ll address */
|
|
static inline struct net_linkaddr *net_pkt_lladdr_if(struct net_pkt *pkt)
|
|
{
|
|
return net_if_get_link_addr(pkt->iface);
|
|
}
|
|
|
|
static inline struct net_context *net_pkt_context(struct net_pkt *pkt)
|
|
{
|
|
return pkt->context;
|
|
}
|
|
|
|
static inline void net_pkt_set_context(struct net_pkt *pkt,
|
|
struct net_context *ctx)
|
|
{
|
|
pkt->context = ctx;
|
|
}
|
|
|
|
static inline struct net_if *net_pkt_iface(struct net_pkt *pkt)
|
|
{
|
|
return pkt->iface;
|
|
}
|
|
|
|
static inline void net_pkt_set_iface(struct net_pkt *pkt, struct net_if *iface)
|
|
{
|
|
pkt->iface = iface;
|
|
|
|
/* If the network interface is set in pkt, then also set the type of
|
|
* the network address that is stored in pkt. This is done here so
|
|
* that the address type is properly set and is not forgotten.
|
|
*/
|
|
if (iface) {
|
|
pkt->lladdr_src.type = net_if_get_link_addr(iface)->type;
|
|
pkt->lladdr_dst.type = net_if_get_link_addr(iface)->type;
|
|
}
|
|
}
|
|
|
|
static inline struct net_if *net_pkt_orig_iface(struct net_pkt *pkt)
|
|
{
|
|
#if defined(CONFIG_NET_ROUTING) || defined(CONFIG_NET_ETHERNET_BRIDGE)
|
|
return pkt->orig_iface;
|
|
#else
|
|
return pkt->iface;
|
|
#endif
|
|
}
|
|
|
|
static inline void net_pkt_set_orig_iface(struct net_pkt *pkt,
|
|
struct net_if *iface)
|
|
{
|
|
#if defined(CONFIG_NET_ROUTING) || defined(CONFIG_NET_ETHERNET_BRIDGE)
|
|
pkt->orig_iface = iface;
|
|
#endif
|
|
}
|
|
|
|
static inline uint8_t net_pkt_family(struct net_pkt *pkt)
|
|
{
|
|
return pkt->family;
|
|
}
|
|
|
|
static inline void net_pkt_set_family(struct net_pkt *pkt, uint8_t family)
|
|
{
|
|
pkt->family = family;
|
|
}
|
|
|
|
static inline bool net_pkt_is_ptp(struct net_pkt *pkt)
|
|
{
|
|
return !!(pkt->ptp_pkt);
|
|
}
|
|
|
|
static inline void net_pkt_set_ptp(struct net_pkt *pkt, bool is_ptp)
|
|
{
|
|
pkt->ptp_pkt = is_ptp;
|
|
}
|
|
|
|
static inline bool net_pkt_is_captured(struct net_pkt *pkt)
|
|
{
|
|
return !!(pkt->captured);
|
|
}
|
|
|
|
static inline void net_pkt_set_captured(struct net_pkt *pkt, bool is_captured)
|
|
{
|
|
pkt->captured = is_captured;
|
|
}
|
|
|
|
static inline bool net_pkt_is_l2_bridged(struct net_pkt *pkt)
|
|
{
|
|
return IS_ENABLED(CONFIG_NET_ETHERNET_BRIDGE) ? !!(pkt->l2_bridged) : 0;
|
|
}
|
|
|
|
static inline void net_pkt_set_l2_bridged(struct net_pkt *pkt, bool is_l2_bridged)
|
|
{
|
|
if (IS_ENABLED(CONFIG_NET_ETHERNET_BRIDGE)) {
|
|
pkt->l2_bridged = is_l2_bridged;
|
|
}
|
|
}
|
|
|
|
static inline uint8_t net_pkt_ip_hdr_len(struct net_pkt *pkt)
|
|
{
|
|
return pkt->ip_hdr_len;
|
|
}
|
|
|
|
static inline void net_pkt_set_ip_hdr_len(struct net_pkt *pkt, uint8_t len)
|
|
{
|
|
pkt->ip_hdr_len = len;
|
|
}
|
|
|
|
static inline uint8_t net_pkt_sent(struct net_pkt *pkt)
|
|
{
|
|
return pkt->sent_or_eof;
|
|
}
|
|
|
|
static inline void net_pkt_set_sent(struct net_pkt *pkt, bool sent)
|
|
{
|
|
pkt->sent_or_eof = sent;
|
|
}
|
|
|
|
static inline uint8_t net_pkt_queued(struct net_pkt *pkt)
|
|
{
|
|
return pkt->pkt_queued;
|
|
}
|
|
|
|
static inline void net_pkt_set_queued(struct net_pkt *pkt, bool send)
|
|
{
|
|
pkt->pkt_queued = send;
|
|
}
|
|
|
|
static inline uint8_t net_pkt_tcp_1st_msg(struct net_pkt *pkt)
|
|
{
|
|
#if defined(CONFIG_NET_TCP)
|
|
return pkt->tcp_first_msg;
|
|
#else
|
|
return true;
|
|
#endif
|
|
}
|
|
|
|
static inline void net_pkt_set_tcp_1st_msg(struct net_pkt *pkt, bool is_1st)
|
|
{
|
|
#if defined(CONFIG_NET_TCP)
|
|
pkt->tcp_first_msg = is_1st;
|
|
#else
|
|
ARG_UNUSED(pkt);
|
|
ARG_UNUSED(is_1st);
|
|
#endif
|
|
}
|
|
|
|
#if defined(CONFIG_NET_SOCKETS)
|
|
static inline uint8_t net_pkt_eof(struct net_pkt *pkt)
|
|
{
|
|
return pkt->sent_or_eof;
|
|
}
|
|
|
|
static inline void net_pkt_set_eof(struct net_pkt *pkt, bool eof)
|
|
{
|
|
pkt->sent_or_eof = eof;
|
|
}
|
|
#endif
|
|
|
|
#if defined(CONFIG_NET_ROUTE)
|
|
static inline bool net_pkt_forwarding(struct net_pkt *pkt)
|
|
{
|
|
return pkt->forwarding;
|
|
}
|
|
|
|
static inline void net_pkt_set_forwarding(struct net_pkt *pkt, bool forward)
|
|
{
|
|
pkt->forwarding = forward;
|
|
}
|
|
#else
|
|
static inline bool net_pkt_forwarding(struct net_pkt *pkt)
|
|
{
|
|
return false;
|
|
}
|
|
#endif
|
|
|
|
#if defined(CONFIG_NET_IPV4)
|
|
static inline uint8_t net_pkt_ipv4_ttl(struct net_pkt *pkt)
|
|
{
|
|
return pkt->ipv4_ttl;
|
|
}
|
|
|
|
static inline void net_pkt_set_ipv4_ttl(struct net_pkt *pkt,
|
|
uint8_t ttl)
|
|
{
|
|
pkt->ipv4_ttl = ttl;
|
|
}
|
|
|
|
static inline uint8_t net_pkt_ipv4_opts_len(struct net_pkt *pkt)
|
|
{
|
|
return pkt->ipv4_opts_len;
|
|
}
|
|
|
|
static inline void net_pkt_set_ipv4_opts_len(struct net_pkt *pkt,
|
|
uint8_t opts_len)
|
|
{
|
|
pkt->ipv4_opts_len = opts_len;
|
|
}
|
|
#else
|
|
static inline uint8_t net_pkt_ipv4_ttl(struct net_pkt *pkt)
|
|
{
|
|
ARG_UNUSED(pkt);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static inline void net_pkt_set_ipv4_ttl(struct net_pkt *pkt,
|
|
uint8_t ttl)
|
|
{
|
|
ARG_UNUSED(pkt);
|
|
ARG_UNUSED(ttl);
|
|
}
|
|
|
|
static inline uint8_t net_pkt_ipv4_opts_len(struct net_pkt *pkt)
|
|
{
|
|
ARG_UNUSED(pkt);
|
|
return 0;
|
|
}
|
|
|
|
static inline void net_pkt_set_ipv4_opts_len(struct net_pkt *pkt,
|
|
uint8_t opts_len)
|
|
{
|
|
ARG_UNUSED(pkt);
|
|
ARG_UNUSED(opts_len);
|
|
}
|
|
#endif
|
|
|
|
#if defined(CONFIG_NET_IPV6)
|
|
static inline uint8_t net_pkt_ipv6_ext_opt_len(struct net_pkt *pkt)
|
|
{
|
|
return pkt->ipv6_ext_opt_len;
|
|
}
|
|
|
|
static inline void net_pkt_set_ipv6_ext_opt_len(struct net_pkt *pkt,
|
|
uint8_t len)
|
|
{
|
|
pkt->ipv6_ext_opt_len = len;
|
|
}
|
|
|
|
static inline uint8_t net_pkt_ipv6_next_hdr(struct net_pkt *pkt)
|
|
{
|
|
return pkt->ipv6_next_hdr;
|
|
}
|
|
|
|
static inline void net_pkt_set_ipv6_next_hdr(struct net_pkt *pkt,
|
|
uint8_t next_hdr)
|
|
{
|
|
pkt->ipv6_next_hdr = next_hdr;
|
|
}
|
|
|
|
static inline uint16_t net_pkt_ipv6_ext_len(struct net_pkt *pkt)
|
|
{
|
|
return pkt->ipv6_ext_len;
|
|
}
|
|
|
|
static inline void net_pkt_set_ipv6_ext_len(struct net_pkt *pkt, uint16_t len)
|
|
{
|
|
pkt->ipv6_ext_len = len;
|
|
}
|
|
|
|
static inline uint16_t net_pkt_ipv6_hdr_prev(struct net_pkt *pkt)
|
|
{
|
|
return pkt->ipv6_prev_hdr_start;
|
|
}
|
|
|
|
static inline void net_pkt_set_ipv6_hdr_prev(struct net_pkt *pkt,
|
|
uint16_t offset)
|
|
{
|
|
pkt->ipv6_prev_hdr_start = offset;
|
|
}
|
|
|
|
static inline uint8_t net_pkt_ipv6_hop_limit(struct net_pkt *pkt)
|
|
{
|
|
return pkt->ipv6_hop_limit;
|
|
}
|
|
|
|
static inline void net_pkt_set_ipv6_hop_limit(struct net_pkt *pkt,
|
|
uint8_t hop_limit)
|
|
{
|
|
pkt->ipv6_hop_limit = hop_limit;
|
|
}
|
|
#else /* CONFIG_NET_IPV6 */
|
|
static inline uint8_t net_pkt_ipv6_ext_opt_len(struct net_pkt *pkt)
|
|
{
|
|
ARG_UNUSED(pkt);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static inline void net_pkt_set_ipv6_ext_opt_len(struct net_pkt *pkt,
|
|
uint8_t len)
|
|
{
|
|
ARG_UNUSED(pkt);
|
|
ARG_UNUSED(len);
|
|
}
|
|
|
|
static inline uint8_t net_pkt_ipv6_next_hdr(struct net_pkt *pkt)
|
|
{
|
|
ARG_UNUSED(pkt);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static inline void net_pkt_set_ipv6_next_hdr(struct net_pkt *pkt,
|
|
uint8_t next_hdr)
|
|
{
|
|
ARG_UNUSED(pkt);
|
|
ARG_UNUSED(next_hdr);
|
|
}
|
|
|
|
static inline uint16_t net_pkt_ipv6_ext_len(struct net_pkt *pkt)
|
|
{
|
|
ARG_UNUSED(pkt);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static inline void net_pkt_set_ipv6_ext_len(struct net_pkt *pkt, uint16_t len)
|
|
{
|
|
ARG_UNUSED(pkt);
|
|
ARG_UNUSED(len);
|
|
}
|
|
|
|
static inline uint16_t net_pkt_ipv6_hdr_prev(struct net_pkt *pkt)
|
|
{
|
|
ARG_UNUSED(pkt);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static inline void net_pkt_set_ipv6_hdr_prev(struct net_pkt *pkt,
|
|
uint16_t offset)
|
|
{
|
|
ARG_UNUSED(pkt);
|
|
ARG_UNUSED(offset);
|
|
}
|
|
|
|
static inline uint8_t net_pkt_ipv6_hop_limit(struct net_pkt *pkt)
|
|
{
|
|
ARG_UNUSED(pkt);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static inline void net_pkt_set_ipv6_hop_limit(struct net_pkt *pkt,
|
|
uint8_t hop_limit)
|
|
{
|
|
ARG_UNUSED(pkt);
|
|
ARG_UNUSED(hop_limit);
|
|
}
|
|
#endif /* CONFIG_NET_IPV6 */
|
|
|
|
static inline uint16_t net_pkt_ip_opts_len(struct net_pkt *pkt)
|
|
{
|
|
#if defined(CONFIG_NET_IPV6)
|
|
return pkt->ipv6_ext_len;
|
|
#elif defined(CONFIG_NET_IPV4)
|
|
return pkt->ipv4_opts_len;
|
|
#else
|
|
ARG_UNUSED(pkt);
|
|
|
|
return 0;
|
|
#endif
|
|
}
|
|
|
|
#if defined(CONFIG_NET_IPV6_FRAGMENT)
|
|
static inline uint16_t net_pkt_ipv6_fragment_start(struct net_pkt *pkt)
|
|
{
|
|
return pkt->ipv6_frag_hdr_start;
|
|
}
|
|
|
|
static inline void net_pkt_set_ipv6_fragment_start(struct net_pkt *pkt,
|
|
uint16_t start)
|
|
{
|
|
pkt->ipv6_frag_hdr_start = start;
|
|
}
|
|
|
|
static inline uint16_t net_pkt_ipv6_fragment_offset(struct net_pkt *pkt)
|
|
{
|
|
return pkt->ipv6_fragment_flags & NET_IPV6_FRAGH_OFFSET_MASK;
|
|
}
|
|
static inline bool net_pkt_ipv6_fragment_more(struct net_pkt *pkt)
|
|
{
|
|
return (pkt->ipv6_fragment_flags & 0x01) != 0;
|
|
}
|
|
|
|
static inline void net_pkt_set_ipv6_fragment_flags(struct net_pkt *pkt,
|
|
uint16_t flags)
|
|
{
|
|
pkt->ipv6_fragment_flags = flags;
|
|
}
|
|
|
|
static inline uint32_t net_pkt_ipv6_fragment_id(struct net_pkt *pkt)
|
|
{
|
|
return pkt->ipv6_fragment_id;
|
|
}
|
|
|
|
static inline void net_pkt_set_ipv6_fragment_id(struct net_pkt *pkt,
|
|
uint32_t id)
|
|
{
|
|
pkt->ipv6_fragment_id = id;
|
|
}
|
|
#else /* CONFIG_NET_IPV6_FRAGMENT */
|
|
static inline uint16_t net_pkt_ipv6_fragment_start(struct net_pkt *pkt)
|
|
{
|
|
ARG_UNUSED(pkt);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static inline void net_pkt_set_ipv6_fragment_start(struct net_pkt *pkt,
|
|
uint16_t start)
|
|
{
|
|
ARG_UNUSED(pkt);
|
|
ARG_UNUSED(start);
|
|
}
|
|
|
|
static inline uint16_t net_pkt_ipv6_fragment_offset(struct net_pkt *pkt)
|
|
{
|
|
ARG_UNUSED(pkt);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static inline bool net_pkt_ipv6_fragment_more(struct net_pkt *pkt)
|
|
{
|
|
ARG_UNUSED(pkt);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static inline void net_pkt_set_ipv6_fragment_flags(struct net_pkt *pkt,
|
|
uint16_t flags)
|
|
{
|
|
ARG_UNUSED(pkt);
|
|
ARG_UNUSED(flags);
|
|
}
|
|
|
|
static inline uint32_t net_pkt_ipv6_fragment_id(struct net_pkt *pkt)
|
|
{
|
|
ARG_UNUSED(pkt);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static inline void net_pkt_set_ipv6_fragment_id(struct net_pkt *pkt,
|
|
uint32_t id)
|
|
{
|
|
ARG_UNUSED(pkt);
|
|
ARG_UNUSED(id);
|
|
}
|
|
#endif /* CONFIG_NET_IPV6_FRAGMENT */
|
|
|
|
static inline uint8_t net_pkt_priority(struct net_pkt *pkt)
|
|
{
|
|
return pkt->priority;
|
|
}
|
|
|
|
static inline void net_pkt_set_priority(struct net_pkt *pkt,
|
|
uint8_t priority)
|
|
{
|
|
pkt->priority = priority;
|
|
}
|
|
|
|
#if defined(CONFIG_NET_VLAN)
|
|
static inline uint16_t net_pkt_vlan_tag(struct net_pkt *pkt)
|
|
{
|
|
return net_eth_vlan_get_vid(pkt->vlan_tci);
|
|
}
|
|
|
|
static inline void net_pkt_set_vlan_tag(struct net_pkt *pkt, uint16_t tag)
|
|
{
|
|
pkt->vlan_tci = net_eth_vlan_set_vid(pkt->vlan_tci, tag);
|
|
}
|
|
|
|
static inline uint8_t net_pkt_vlan_priority(struct net_pkt *pkt)
|
|
{
|
|
return net_eth_vlan_get_pcp(pkt->vlan_tci);
|
|
}
|
|
|
|
static inline void net_pkt_set_vlan_priority(struct net_pkt *pkt,
|
|
uint8_t priority)
|
|
{
|
|
pkt->vlan_tci = net_eth_vlan_set_pcp(pkt->vlan_tci, priority);
|
|
}
|
|
|
|
static inline bool net_pkt_vlan_dei(struct net_pkt *pkt)
|
|
{
|
|
return net_eth_vlan_get_dei(pkt->vlan_tci);
|
|
}
|
|
|
|
static inline void net_pkt_set_vlan_dei(struct net_pkt *pkt, bool dei)
|
|
{
|
|
pkt->vlan_tci = net_eth_vlan_set_dei(pkt->vlan_tci, dei);
|
|
}
|
|
|
|
static inline void net_pkt_set_vlan_tci(struct net_pkt *pkt, uint16_t tci)
|
|
{
|
|
pkt->vlan_tci = tci;
|
|
}
|
|
|
|
static inline uint16_t net_pkt_vlan_tci(struct net_pkt *pkt)
|
|
{
|
|
return pkt->vlan_tci;
|
|
}
|
|
#else
|
|
static inline uint16_t net_pkt_vlan_tag(struct net_pkt *pkt)
|
|
{
|
|
return NET_VLAN_TAG_UNSPEC;
|
|
}
|
|
|
|
static inline void net_pkt_set_vlan_tag(struct net_pkt *pkt, uint16_t tag)
|
|
{
|
|
ARG_UNUSED(pkt);
|
|
ARG_UNUSED(tag);
|
|
}
|
|
|
|
static inline uint8_t net_pkt_vlan_priority(struct net_pkt *pkt)
|
|
{
|
|
ARG_UNUSED(pkt);
|
|
return 0;
|
|
}
|
|
|
|
static inline bool net_pkt_vlan_dei(struct net_pkt *pkt)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
static inline void net_pkt_set_vlan_dei(struct net_pkt *pkt, bool dei)
|
|
{
|
|
ARG_UNUSED(pkt);
|
|
ARG_UNUSED(dei);
|
|
}
|
|
|
|
static inline uint16_t net_pkt_vlan_tci(struct net_pkt *pkt)
|
|
{
|
|
return NET_VLAN_TAG_UNSPEC; /* assumes priority is 0 */
|
|
}
|
|
|
|
static inline void net_pkt_set_vlan_tci(struct net_pkt *pkt, uint16_t tci)
|
|
{
|
|
ARG_UNUSED(pkt);
|
|
ARG_UNUSED(tci);
|
|
}
|
|
#endif
|
|
|
|
#if defined(CONFIG_NET_PKT_TIMESTAMP)
|
|
static inline struct net_ptp_time *net_pkt_timestamp(struct net_pkt *pkt)
|
|
{
|
|
return &pkt->timestamp;
|
|
}
|
|
|
|
static inline void net_pkt_set_timestamp(struct net_pkt *pkt,
|
|
struct net_ptp_time *timestamp)
|
|
{
|
|
pkt->timestamp.second = timestamp->second;
|
|
pkt->timestamp.nanosecond = timestamp->nanosecond;
|
|
}
|
|
#else
|
|
static inline struct net_ptp_time *net_pkt_timestamp(struct net_pkt *pkt)
|
|
{
|
|
ARG_UNUSED(pkt);
|
|
|
|
return NULL;
|
|
}
|
|
|
|
static inline void net_pkt_set_timestamp(struct net_pkt *pkt,
|
|
struct net_ptp_time *timestamp)
|
|
{
|
|
ARG_UNUSED(pkt);
|
|
ARG_UNUSED(timestamp);
|
|
}
|
|
#endif /* CONFIG_NET_PKT_TIMESTAMP */
|
|
|
|
#if defined(CONFIG_NET_PKT_RXTIME_STATS) || defined(CONFIG_NET_PKT_TXTIME_STATS)
|
|
static inline uint32_t net_pkt_create_time(struct net_pkt *pkt)
|
|
{
|
|
return pkt->create_time;
|
|
}
|
|
|
|
static inline void net_pkt_set_create_time(struct net_pkt *pkt,
|
|
uint32_t create_time)
|
|
{
|
|
pkt->create_time = create_time;
|
|
}
|
|
#else
|
|
static inline uint32_t net_pkt_create_time(struct net_pkt *pkt)
|
|
{
|
|
ARG_UNUSED(pkt);
|
|
|
|
return 0U;
|
|
}
|
|
|
|
static inline void net_pkt_set_create_time(struct net_pkt *pkt,
|
|
uint32_t create_time)
|
|
{
|
|
ARG_UNUSED(pkt);
|
|
ARG_UNUSED(create_time);
|
|
}
|
|
#endif /* CONFIG_NET_PKT_RXTIME_STATS || CONFIG_NET_PKT_TXTIME_STATS */
|
|
|
|
#if defined(CONFIG_NET_PKT_TXTIME)
|
|
static inline uint64_t net_pkt_txtime(struct net_pkt *pkt)
|
|
{
|
|
return pkt->txtime;
|
|
}
|
|
|
|
static inline void net_pkt_set_txtime(struct net_pkt *pkt, uint64_t txtime)
|
|
{
|
|
pkt->txtime = txtime;
|
|
}
|
|
#else
|
|
static inline uint64_t net_pkt_txtime(struct net_pkt *pkt)
|
|
{
|
|
ARG_UNUSED(pkt);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static inline void net_pkt_set_txtime(struct net_pkt *pkt, uint64_t txtime)
|
|
{
|
|
ARG_UNUSED(pkt);
|
|
ARG_UNUSED(txtime);
|
|
}
|
|
#endif /* CONFIG_NET_PKT_TXTIME */
|
|
|
|
#if defined(CONFIG_NET_PKT_TXTIME_STATS_DETAIL) || \
|
|
defined(CONFIG_NET_PKT_RXTIME_STATS_DETAIL)
|
|
static inline uint32_t *net_pkt_stats_tick(struct net_pkt *pkt)
|
|
{
|
|
return pkt->detail.stat;
|
|
}
|
|
|
|
static inline int net_pkt_stats_tick_count(struct net_pkt *pkt)
|
|
{
|
|
return pkt->detail.count;
|
|
}
|
|
|
|
static inline void net_pkt_stats_tick_reset(struct net_pkt *pkt)
|
|
{
|
|
memset(&pkt->detail, 0, sizeof(pkt->detail));
|
|
}
|
|
|
|
static ALWAYS_INLINE void net_pkt_set_stats_tick(struct net_pkt *pkt,
|
|
uint32_t tick)
|
|
{
|
|
if (pkt->detail.count >= NET_PKT_DETAIL_STATS_COUNT) {
|
|
NET_ERR("Detail stats count overflow (%d >= %d)",
|
|
pkt->detail.count, NET_PKT_DETAIL_STATS_COUNT);
|
|
return;
|
|
}
|
|
|
|
pkt->detail.stat[pkt->detail.count++] = tick;
|
|
}
|
|
|
|
#define net_pkt_set_tx_stats_tick(pkt, tick) net_pkt_set_stats_tick(pkt, tick)
|
|
#define net_pkt_set_rx_stats_tick(pkt, tick) net_pkt_set_stats_tick(pkt, tick)
|
|
#else
|
|
static inline uint32_t *net_pkt_stats_tick(struct net_pkt *pkt)
|
|
{
|
|
ARG_UNUSED(pkt);
|
|
|
|
return NULL;
|
|
}
|
|
|
|
static inline int net_pkt_stats_tick_count(struct net_pkt *pkt)
|
|
{
|
|
ARG_UNUSED(pkt);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static inline void net_pkt_stats_tick_reset(struct net_pkt *pkt)
|
|
{
|
|
ARG_UNUSED(pkt);
|
|
}
|
|
|
|
static inline void net_pkt_set_stats_tick(struct net_pkt *pkt, uint32_t tick)
|
|
{
|
|
ARG_UNUSED(pkt);
|
|
ARG_UNUSED(tick);
|
|
}
|
|
|
|
#define net_pkt_set_tx_stats_tick(pkt, tick)
|
|
#define net_pkt_set_rx_stats_tick(pkt, tick)
|
|
#endif /* CONFIG_NET_PKT_TXTIME_STATS_DETAIL ||
|
|
CONFIG_NET_PKT_RXTIME_STATS_DETAIL */
|
|
|
|
static inline size_t net_pkt_get_len(struct net_pkt *pkt)
|
|
{
|
|
return net_buf_frags_len(pkt->frags);
|
|
}
|
|
|
|
static inline uint8_t *net_pkt_data(struct net_pkt *pkt)
|
|
{
|
|
return pkt->frags->data;
|
|
}
|
|
|
|
static inline uint8_t *net_pkt_ip_data(struct net_pkt *pkt)
|
|
{
|
|
return pkt->frags->data;
|
|
}
|
|
|
|
static inline bool net_pkt_is_empty(struct net_pkt *pkt)
|
|
{
|
|
return !pkt->buffer || !net_pkt_data(pkt) || pkt->buffer->len == 0;
|
|
}
|
|
|
|
static inline struct net_linkaddr *net_pkt_lladdr_src(struct net_pkt *pkt)
|
|
{
|
|
return &pkt->lladdr_src;
|
|
}
|
|
|
|
static inline struct net_linkaddr *net_pkt_lladdr_dst(struct net_pkt *pkt)
|
|
{
|
|
return &pkt->lladdr_dst;
|
|
}
|
|
|
|
static inline void net_pkt_lladdr_swap(struct net_pkt *pkt)
|
|
{
|
|
uint8_t *addr = net_pkt_lladdr_src(pkt)->addr;
|
|
|
|
net_pkt_lladdr_src(pkt)->addr = net_pkt_lladdr_dst(pkt)->addr;
|
|
net_pkt_lladdr_dst(pkt)->addr = addr;
|
|
}
|
|
|
|
static inline void net_pkt_lladdr_clear(struct net_pkt *pkt)
|
|
{
|
|
net_pkt_lladdr_src(pkt)->addr = NULL;
|
|
net_pkt_lladdr_src(pkt)->len = 0U;
|
|
}
|
|
|
|
#if defined(CONFIG_IEEE802154) || defined(CONFIG_IEEE802154_RAW_MODE)
|
|
static inline uint8_t net_pkt_ieee802154_rssi(struct net_pkt *pkt)
|
|
{
|
|
return pkt->ieee802154_rssi;
|
|
}
|
|
|
|
static inline void net_pkt_set_ieee802154_rssi(struct net_pkt *pkt,
|
|
uint8_t rssi)
|
|
{
|
|
pkt->ieee802154_rssi = rssi;
|
|
}
|
|
|
|
static inline uint8_t net_pkt_ieee802154_lqi(struct net_pkt *pkt)
|
|
{
|
|
return pkt->ieee802154_lqi;
|
|
}
|
|
|
|
static inline void net_pkt_set_ieee802154_lqi(struct net_pkt *pkt,
|
|
uint8_t lqi)
|
|
{
|
|
pkt->ieee802154_lqi = lqi;
|
|
}
|
|
|
|
static inline bool net_pkt_ieee802154_arb(struct net_pkt *pkt)
|
|
{
|
|
return pkt->ieee802154_arb;
|
|
}
|
|
|
|
static inline void net_pkt_set_ieee802154_arb(struct net_pkt *pkt, bool arb)
|
|
{
|
|
pkt->ieee802154_arb = arb;
|
|
}
|
|
|
|
static inline bool net_pkt_ieee802154_ack_fpb(struct net_pkt *pkt)
|
|
{
|
|
return pkt->ieee802154_ack_fpb;
|
|
}
|
|
|
|
static inline void net_pkt_set_ieee802154_ack_fpb(struct net_pkt *pkt,
|
|
bool fpb)
|
|
{
|
|
pkt->ieee802154_ack_fpb = fpb;
|
|
}
|
|
|
|
static inline bool net_pkt_ieee802154_frame_secured(struct net_pkt *pkt)
|
|
{
|
|
return pkt->ieee802154_frame_secured;
|
|
}
|
|
|
|
static inline void net_pkt_set_ieee802154_frame_secured(struct net_pkt *pkt,
|
|
bool secured)
|
|
{
|
|
pkt->ieee802154_frame_secured = secured;
|
|
}
|
|
|
|
static inline bool net_pkt_ieee802154_mac_hdr_rdy(struct net_pkt *pkt)
|
|
{
|
|
return pkt->ieee802154_mac_hdr_rdy;
|
|
}
|
|
|
|
static inline void net_pkt_set_ieee802154_mac_hdr_rdy(struct net_pkt *pkt,
|
|
bool rdy)
|
|
{
|
|
pkt->ieee802154_mac_hdr_rdy = rdy;
|
|
}
|
|
|
|
#if defined(CONFIG_IEEE802154_2015)
|
|
static inline bool net_pkt_ieee802154_fv2015(struct net_pkt *pkt)
|
|
{
|
|
return pkt->ieee802154_fv2015;
|
|
}
|
|
|
|
static inline void net_pkt_set_ieee802154_fv2015(struct net_pkt *pkt, bool fv2015)
|
|
{
|
|
pkt->ieee802154_fv2015 = fv2015;
|
|
}
|
|
|
|
static inline bool net_pkt_ieee802154_ack_seb(struct net_pkt *pkt)
|
|
{
|
|
return pkt->ieee802154_ack_seb;
|
|
}
|
|
|
|
static inline void net_pkt_set_ieee802154_ack_seb(struct net_pkt *pkt, bool seb)
|
|
{
|
|
pkt->ieee802154_ack_seb = seb;
|
|
}
|
|
|
|
static inline uint32_t net_pkt_ieee802154_ack_fc(struct net_pkt *pkt)
|
|
{
|
|
return pkt->ieee802154_ack_fc;
|
|
}
|
|
|
|
static inline void net_pkt_set_ieee802154_ack_fc(struct net_pkt *pkt,
|
|
uint32_t fc)
|
|
{
|
|
pkt->ieee802154_ack_fc = fc;
|
|
}
|
|
|
|
static inline uint8_t net_pkt_ieee802154_ack_keyid(struct net_pkt *pkt)
|
|
{
|
|
return pkt->ieee802154_ack_keyid;
|
|
}
|
|
|
|
static inline void net_pkt_set_ieee802154_ack_keyid(struct net_pkt *pkt,
|
|
uint8_t keyid)
|
|
{
|
|
pkt->ieee802154_ack_keyid = keyid;
|
|
}
|
|
#endif /* CONFIG_IEEE802154_2015 */
|
|
#endif /* CONFIG_IEEE802154 || CONFIG_IEEE802154_RAW_MODE */
|
|
|
|
#if defined(CONFIG_NET_IPV4_AUTO)
|
|
static inline bool net_pkt_ipv4_auto(struct net_pkt *pkt)
|
|
{
|
|
return pkt->ipv4_auto_arp_msg;
|
|
}
|
|
|
|
static inline void net_pkt_set_ipv4_auto(struct net_pkt *pkt,
|
|
bool is_auto_arp_msg)
|
|
{
|
|
pkt->ipv4_auto_arp_msg = is_auto_arp_msg;
|
|
}
|
|
#else /* CONFIG_NET_IPV4_AUTO */
|
|
static inline bool net_pkt_ipv4_auto(struct net_pkt *pkt)
|
|
{
|
|
ARG_UNUSED(pkt);
|
|
|
|
return false;
|
|
}
|
|
|
|
static inline void net_pkt_set_ipv4_auto(struct net_pkt *pkt,
|
|
bool is_auto_arp_msg)
|
|
{
|
|
ARG_UNUSED(pkt);
|
|
ARG_UNUSED(is_auto_arp_msg);
|
|
}
|
|
#endif /* CONFIG_NET_IPV4_AUTO */
|
|
|
|
#if defined(CONFIG_NET_LLDP)
|
|
static inline bool net_pkt_is_lldp(struct net_pkt *pkt)
|
|
{
|
|
return pkt->lldp_pkt;
|
|
}
|
|
|
|
static inline void net_pkt_set_lldp(struct net_pkt *pkt, bool is_lldp)
|
|
{
|
|
pkt->lldp_pkt = is_lldp;
|
|
}
|
|
#else
|
|
static inline bool net_pkt_is_lldp(struct net_pkt *pkt)
|
|
{
|
|
ARG_UNUSED(pkt);
|
|
|
|
return false;
|
|
}
|
|
|
|
static inline void net_pkt_set_lldp(struct net_pkt *pkt, bool is_lldp)
|
|
{
|
|
ARG_UNUSED(pkt);
|
|
ARG_UNUSED(is_lldp);
|
|
}
|
|
#endif /* CONFIG_NET_LLDP */
|
|
|
|
#if defined(CONFIG_NET_PPP)
|
|
static inline bool net_pkt_is_ppp(struct net_pkt *pkt)
|
|
{
|
|
return pkt->ppp_msg;
|
|
}
|
|
|
|
static inline void net_pkt_set_ppp(struct net_pkt *pkt,
|
|
bool is_ppp_msg)
|
|
{
|
|
pkt->ppp_msg = is_ppp_msg;
|
|
}
|
|
#else /* CONFIG_NET_PPP */
|
|
static inline bool net_pkt_is_ppp(struct net_pkt *pkt)
|
|
{
|
|
ARG_UNUSED(pkt);
|
|
|
|
return false;
|
|
}
|
|
|
|
static inline void net_pkt_set_ppp(struct net_pkt *pkt,
|
|
bool is_ppp_msg)
|
|
{
|
|
ARG_UNUSED(pkt);
|
|
ARG_UNUSED(is_ppp_msg);
|
|
}
|
|
#endif /* CONFIG_NET_PPP */
|
|
|
|
#define NET_IPV6_HDR(pkt) ((struct net_ipv6_hdr *)net_pkt_ip_data(pkt))
|
|
#define NET_IPV4_HDR(pkt) ((struct net_ipv4_hdr *)net_pkt_ip_data(pkt))
|
|
|
|
static inline void net_pkt_set_src_ipv6_addr(struct net_pkt *pkt)
|
|
{
|
|
net_if_ipv6_select_src_addr(net_context_get_iface(
|
|
net_pkt_context(pkt)),
|
|
(struct in6_addr *)NET_IPV6_HDR(pkt)->src);
|
|
}
|
|
|
|
static inline void net_pkt_set_overwrite(struct net_pkt *pkt, bool overwrite)
|
|
{
|
|
pkt->overwrite = overwrite;
|
|
}
|
|
|
|
static inline bool net_pkt_is_being_overwritten(struct net_pkt *pkt)
|
|
{
|
|
return pkt->overwrite;
|
|
}
|
|
|
|
#ifdef CONFIG_NET_PKT_FILTER
|
|
|
|
bool net_pkt_filter_send_ok(struct net_pkt *pkt);
|
|
bool net_pkt_filter_recv_ok(struct net_pkt *pkt);
|
|
|
|
#else
|
|
|
|
static inline bool net_pkt_filter_send_ok(struct net_pkt *pkt)
|
|
{
|
|
ARG_UNUSED(pkt);
|
|
|
|
return true;
|
|
}
|
|
|
|
static inline bool net_pkt_filter_recv_ok(struct net_pkt *pkt)
|
|
{
|
|
ARG_UNUSED(pkt);
|
|
|
|
return true;
|
|
}
|
|
|
|
#endif /* CONFIG_NET_PKT_FILTER */
|
|
|
|
/* @endcond */
|
|
|
|
/**
|
|
* @brief Create a net_pkt slab
|
|
*
|
|
* A net_pkt slab is used to store meta-information about
|
|
* network packets. It must be coupled with a data fragment pool
|
|
* (:c:macro:`NET_PKT_DATA_POOL_DEFINE`) used to store the actual
|
|
* packet data. The macro can be used by an application to define
|
|
* additional custom per-context TX packet slabs (see
|
|
* :c:func:`net_context_setup_pools`).
|
|
*
|
|
* @param name Name of the slab.
|
|
* @param count Number of net_pkt in this slab.
|
|
*/
|
|
#define NET_PKT_SLAB_DEFINE(name, count) \
|
|
K_MEM_SLAB_DEFINE(name, sizeof(struct net_pkt), count, 4)
|
|
|
|
/* Backward compatibility macro */
|
|
#define NET_PKT_TX_SLAB_DEFINE(name, count) NET_PKT_SLAB_DEFINE(name, count)
|
|
|
|
/**
|
|
* @brief Create a data fragment net_buf pool
|
|
*
|
|
* A net_buf pool is used to store actual data for
|
|
* network packets. It must be coupled with a net_pkt slab
|
|
* (:c:macro:`NET_PKT_SLAB_DEFINE`) used to store the packet
|
|
* meta-information. The macro can be used by an application to
|
|
* define additional custom per-context TX packet pools (see
|
|
* :c:func:`net_context_setup_pools`).
|
|
*
|
|
* @param name Name of the pool.
|
|
* @param count Number of net_buf in this pool.
|
|
*/
|
|
#define NET_PKT_DATA_POOL_DEFINE(name, count) \
|
|
NET_BUF_POOL_DEFINE(name, count, CONFIG_NET_BUF_DATA_SIZE, \
|
|
0, NULL)
|
|
|
|
/** @cond INTERNAL_HIDDEN */
|
|
|
|
#if defined(CONFIG_NET_DEBUG_NET_PKT_ALLOC) || \
|
|
(CONFIG_NET_PKT_LOG_LEVEL >= LOG_LEVEL_DBG)
|
|
#define NET_PKT_DEBUG_ENABLED
|
|
#endif
|
|
|
|
#if defined(NET_PKT_DEBUG_ENABLED)
|
|
|
|
/* Debug versions of the net_pkt functions that are used when tracking
|
|
* buffer usage.
|
|
*/
|
|
|
|
struct net_buf *net_pkt_get_reserve_data_debug(struct net_buf_pool *pool,
|
|
k_timeout_t timeout,
|
|
const char *caller,
|
|
int line);
|
|
|
|
#define net_pkt_get_reserve_data(pool, timeout) \
|
|
net_pkt_get_reserve_data_debug(pool, timeout, __func__, __LINE__)
|
|
|
|
struct net_buf *net_pkt_get_reserve_rx_data_debug(k_timeout_t timeout,
|
|
const char *caller,
|
|
int line);
|
|
#define net_pkt_get_reserve_rx_data(timeout) \
|
|
net_pkt_get_reserve_rx_data_debug(timeout, __func__, __LINE__)
|
|
|
|
struct net_buf *net_pkt_get_reserve_tx_data_debug(k_timeout_t timeout,
|
|
const char *caller,
|
|
int line);
|
|
#define net_pkt_get_reserve_tx_data(timeout) \
|
|
net_pkt_get_reserve_tx_data_debug(timeout, __func__, __LINE__)
|
|
|
|
struct net_buf *net_pkt_get_frag_debug(struct net_pkt *pkt,
|
|
k_timeout_t timeout,
|
|
const char *caller, int line);
|
|
#define net_pkt_get_frag(pkt, timeout) \
|
|
net_pkt_get_frag_debug(pkt, timeout, __func__, __LINE__)
|
|
|
|
void net_pkt_unref_debug(struct net_pkt *pkt, const char *caller, int line);
|
|
#define net_pkt_unref(pkt) net_pkt_unref_debug(pkt, __func__, __LINE__)
|
|
|
|
struct net_pkt *net_pkt_ref_debug(struct net_pkt *pkt, const char *caller,
|
|
int line);
|
|
#define net_pkt_ref(pkt) net_pkt_ref_debug(pkt, __func__, __LINE__)
|
|
|
|
struct net_buf *net_pkt_frag_ref_debug(struct net_buf *frag,
|
|
const char *caller, int line);
|
|
#define net_pkt_frag_ref(frag) net_pkt_frag_ref_debug(frag, __func__, __LINE__)
|
|
|
|
void net_pkt_frag_unref_debug(struct net_buf *frag,
|
|
const char *caller, int line);
|
|
#define net_pkt_frag_unref(frag) \
|
|
net_pkt_frag_unref_debug(frag, __func__, __LINE__)
|
|
|
|
struct net_buf *net_pkt_frag_del_debug(struct net_pkt *pkt,
|
|
struct net_buf *parent,
|
|
struct net_buf *frag,
|
|
const char *caller, int line);
|
|
#define net_pkt_frag_del(pkt, parent, frag) \
|
|
net_pkt_frag_del_debug(pkt, parent, frag, __func__, __LINE__)
|
|
|
|
void net_pkt_frag_add_debug(struct net_pkt *pkt, struct net_buf *frag,
|
|
const char *caller, int line);
|
|
#define net_pkt_frag_add(pkt, frag) \
|
|
net_pkt_frag_add_debug(pkt, frag, __func__, __LINE__)
|
|
|
|
void net_pkt_frag_insert_debug(struct net_pkt *pkt, struct net_buf *frag,
|
|
const char *caller, int line);
|
|
#define net_pkt_frag_insert(pkt, frag) \
|
|
net_pkt_frag_insert_debug(pkt, frag, __func__, __LINE__)
|
|
#endif /* CONFIG_NET_DEBUG_NET_PKT_ALLOC ||
|
|
* CONFIG_NET_PKT_LOG_LEVEL >= LOG_LEVEL_DBG
|
|
*/
|
|
/** @endcond */
|
|
|
|
/**
|
|
* @brief Print fragment list and the fragment sizes
|
|
*
|
|
* @details Only available if debugging is activated.
|
|
*
|
|
* @param pkt Network pkt.
|
|
*/
|
|
#if defined(NET_PKT_DEBUG_ENABLED)
|
|
void net_pkt_print_frags(struct net_pkt *pkt);
|
|
#else
|
|
#define net_pkt_print_frags(pkt)
|
|
#endif
|
|
|
|
/**
|
|
* @brief Get RX DATA buffer from pool.
|
|
* Normally you should use net_pkt_get_frag() instead.
|
|
*
|
|
* @details Normally this version is not useful for applications
|
|
* but is mainly used by network fragmentation code.
|
|
*
|
|
* @param timeout Affects the action taken should the net buf pool be empty.
|
|
* If K_NO_WAIT, then return immediately. If K_FOREVER, then
|
|
* wait as long as necessary. Otherwise, wait up to the specified time.
|
|
*
|
|
* @return Network buffer if successful, NULL otherwise.
|
|
*/
|
|
#if !defined(NET_PKT_DEBUG_ENABLED)
|
|
struct net_buf *net_pkt_get_reserve_rx_data(k_timeout_t timeout);
|
|
#endif
|
|
|
|
/**
|
|
* @brief Get TX DATA buffer from pool.
|
|
* Normally you should use net_pkt_get_frag() instead.
|
|
*
|
|
* @details Normally this version is not useful for applications
|
|
* but is mainly used by network fragmentation code.
|
|
*
|
|
* @param timeout Affects the action taken should the net buf pool be empty.
|
|
* If K_NO_WAIT, then return immediately. If K_FOREVER, then
|
|
* wait as long as necessary. Otherwise, wait up to the specified time.
|
|
*
|
|
* @return Network buffer if successful, NULL otherwise.
|
|
*/
|
|
#if !defined(NET_PKT_DEBUG_ENABLED)
|
|
struct net_buf *net_pkt_get_reserve_tx_data(k_timeout_t timeout);
|
|
#endif
|
|
|
|
/**
|
|
* @brief Get a data fragment that might be from user specific
|
|
* buffer pool or from global DATA pool.
|
|
*
|
|
* @param pkt Network packet.
|
|
* @param timeout Affects the action taken should the net buf pool be empty.
|
|
* If K_NO_WAIT, then return immediately. If K_FOREVER, then
|
|
* wait as long as necessary. Otherwise, wait up to the specified time.
|
|
*
|
|
* @return Network buffer if successful, NULL otherwise.
|
|
*/
|
|
#if !defined(NET_PKT_DEBUG_ENABLED)
|
|
struct net_buf *net_pkt_get_frag(struct net_pkt *pkt, k_timeout_t timeout);
|
|
#endif
|
|
|
|
/**
|
|
* @brief Place packet back into the available packets slab
|
|
*
|
|
* @details Releases the packet to other use. This needs to be
|
|
* called by application after it has finished with the packet.
|
|
*
|
|
* @param pkt Network packet to release.
|
|
*
|
|
*/
|
|
#if !defined(NET_PKT_DEBUG_ENABLED)
|
|
void net_pkt_unref(struct net_pkt *pkt);
|
|
#endif
|
|
|
|
/**
|
|
* @brief Increase the packet ref count
|
|
*
|
|
* @details Mark the packet to be used still.
|
|
*
|
|
* @param pkt Network packet to ref.
|
|
*
|
|
* @return Network packet if successful, NULL otherwise.
|
|
*/
|
|
#if !defined(NET_PKT_DEBUG_ENABLED)
|
|
struct net_pkt *net_pkt_ref(struct net_pkt *pkt);
|
|
#endif
|
|
|
|
/**
|
|
* @brief Increase the packet fragment ref count
|
|
*
|
|
* @details Mark the fragment to be used still.
|
|
*
|
|
* @param frag Network fragment to ref.
|
|
*
|
|
* @return a pointer on the referenced Network fragment.
|
|
*/
|
|
#if !defined(NET_PKT_DEBUG_ENABLED)
|
|
struct net_buf *net_pkt_frag_ref(struct net_buf *frag);
|
|
#endif
|
|
|
|
/**
|
|
* @brief Decrease the packet fragment ref count
|
|
*
|
|
* @param frag Network fragment to unref.
|
|
*/
|
|
#if !defined(NET_PKT_DEBUG_ENABLED)
|
|
void net_pkt_frag_unref(struct net_buf *frag);
|
|
#endif
|
|
|
|
/**
|
|
* @brief Delete existing fragment from a packet
|
|
*
|
|
* @param pkt Network packet from which frag belongs to.
|
|
* @param parent parent fragment of frag, or NULL if none.
|
|
* @param frag Fragment to delete.
|
|
*
|
|
* @return Pointer to the following fragment, or NULL if it had no
|
|
* further fragments.
|
|
*/
|
|
#if !defined(NET_PKT_DEBUG_ENABLED)
|
|
struct net_buf *net_pkt_frag_del(struct net_pkt *pkt,
|
|
struct net_buf *parent,
|
|
struct net_buf *frag);
|
|
#endif
|
|
|
|
/**
|
|
* @brief Add a fragment to a packet at the end of its fragment list
|
|
*
|
|
* @param pkt pkt Network packet where to add the fragment
|
|
* @param frag Fragment to add
|
|
*/
|
|
#if !defined(NET_PKT_DEBUG_ENABLED)
|
|
void net_pkt_frag_add(struct net_pkt *pkt, struct net_buf *frag);
|
|
#endif
|
|
|
|
/**
|
|
* @brief Insert a fragment to a packet at the beginning of its fragment list
|
|
*
|
|
* @param pkt pkt Network packet where to insert the fragment
|
|
* @param frag Fragment to insert
|
|
*/
|
|
#if !defined(NET_PKT_DEBUG_ENABLED)
|
|
void net_pkt_frag_insert(struct net_pkt *pkt, struct net_buf *frag);
|
|
#endif
|
|
|
|
/**
|
|
* @brief Compact the fragment list of a packet.
|
|
*
|
|
* @details After this there is no more any free space in individual fragments.
|
|
* @param pkt Network packet.
|
|
*
|
|
* @return True if compact success, False otherwise.
|
|
*/
|
|
bool net_pkt_compact(struct net_pkt *pkt);
|
|
|
|
/**
|
|
* @brief Get information about predefined RX, TX and DATA pools.
|
|
*
|
|
* @param rx Pointer to RX pool is returned.
|
|
* @param tx Pointer to TX pool is returned.
|
|
* @param rx_data Pointer to RX DATA pool is returned.
|
|
* @param tx_data Pointer to TX DATA pool is returned.
|
|
*/
|
|
void net_pkt_get_info(struct k_mem_slab **rx,
|
|
struct k_mem_slab **tx,
|
|
struct net_buf_pool **rx_data,
|
|
struct net_buf_pool **tx_data);
|
|
|
|
/** @cond INTERNAL_HIDDEN */
|
|
|
|
#if defined(CONFIG_NET_DEBUG_NET_PKT_ALLOC)
|
|
/**
|
|
* @brief Debug helper to print out the buffer allocations
|
|
*/
|
|
void net_pkt_print(void);
|
|
|
|
typedef void (*net_pkt_allocs_cb_t)(struct net_pkt *pkt,
|
|
struct net_buf *buf,
|
|
const char *func_alloc,
|
|
int line_alloc,
|
|
const char *func_free,
|
|
int line_free,
|
|
bool in_use,
|
|
void *user_data);
|
|
|
|
void net_pkt_allocs_foreach(net_pkt_allocs_cb_t cb, void *user_data);
|
|
|
|
const char *net_pkt_slab2str(struct k_mem_slab *slab);
|
|
const char *net_pkt_pool2str(struct net_buf_pool *pool);
|
|
|
|
#else
|
|
#define net_pkt_print(...)
|
|
#endif /* CONFIG_NET_DEBUG_NET_PKT_ALLOC */
|
|
|
|
/* New allocator, and API are defined below.
|
|
* This will be simpler when time will come to get rid of former API above.
|
|
*/
|
|
#if defined(NET_PKT_DEBUG_ENABLED)
|
|
|
|
struct net_pkt *net_pkt_alloc_debug(k_timeout_t timeout,
|
|
const char *caller, int line);
|
|
#define net_pkt_alloc(_timeout) \
|
|
net_pkt_alloc_debug(_timeout, __func__, __LINE__)
|
|
|
|
struct net_pkt *net_pkt_alloc_from_slab_debug(struct k_mem_slab *slab,
|
|
k_timeout_t timeout,
|
|
const char *caller, int line);
|
|
#define net_pkt_alloc_from_slab(_slab, _timeout) \
|
|
net_pkt_alloc_from_slab_debug(_slab, _timeout, __func__, __LINE__)
|
|
|
|
struct net_pkt *net_pkt_rx_alloc_debug(k_timeout_t timeout,
|
|
const char *caller, int line);
|
|
#define net_pkt_rx_alloc(_timeout) \
|
|
net_pkt_rx_alloc_debug(_timeout, __func__, __LINE__)
|
|
|
|
struct net_pkt *net_pkt_alloc_on_iface_debug(struct net_if *iface,
|
|
k_timeout_t timeout,
|
|
const char *caller,
|
|
int line);
|
|
#define net_pkt_alloc_on_iface(_iface, _timeout) \
|
|
net_pkt_alloc_on_iface_debug(_iface, _timeout, __func__, __LINE__)
|
|
|
|
struct net_pkt *net_pkt_rx_alloc_on_iface_debug(struct net_if *iface,
|
|
k_timeout_t timeout,
|
|
const char *caller,
|
|
int line);
|
|
#define net_pkt_rx_alloc_on_iface(_iface, _timeout) \
|
|
net_pkt_rx_alloc_on_iface_debug(_iface, _timeout, \
|
|
__func__, __LINE__)
|
|
|
|
int net_pkt_alloc_buffer_debug(struct net_pkt *pkt,
|
|
size_t size,
|
|
enum net_ip_protocol proto,
|
|
k_timeout_t timeout,
|
|
const char *caller, int line);
|
|
#define net_pkt_alloc_buffer(_pkt, _size, _proto, _timeout) \
|
|
net_pkt_alloc_buffer_debug(_pkt, _size, _proto, _timeout, \
|
|
__func__, __LINE__)
|
|
|
|
struct net_pkt *net_pkt_alloc_with_buffer_debug(struct net_if *iface,
|
|
size_t size,
|
|
sa_family_t family,
|
|
enum net_ip_protocol proto,
|
|
k_timeout_t timeout,
|
|
const char *caller,
|
|
int line);
|
|
#define net_pkt_alloc_with_buffer(_iface, _size, _family, \
|
|
_proto, _timeout) \
|
|
net_pkt_alloc_with_buffer_debug(_iface, _size, _family, \
|
|
_proto, _timeout, \
|
|
__func__, __LINE__)
|
|
|
|
struct net_pkt *net_pkt_rx_alloc_with_buffer_debug(struct net_if *iface,
|
|
size_t size,
|
|
sa_family_t family,
|
|
enum net_ip_protocol proto,
|
|
k_timeout_t timeout,
|
|
const char *caller,
|
|
int line);
|
|
#define net_pkt_rx_alloc_with_buffer(_iface, _size, _family, \
|
|
_proto, _timeout) \
|
|
net_pkt_rx_alloc_with_buffer_debug(_iface, _size, _family, \
|
|
_proto, _timeout, \
|
|
__func__, __LINE__)
|
|
#endif /* NET_PKT_DEBUG_ENABLED */
|
|
/** @endcond */
|
|
|
|
/**
|
|
* @brief Allocate an initialized net_pkt
|
|
*
|
|
* @details for the time being, 2 pools are used. One for TX and one for RX.
|
|
* This allocator has to be used for TX.
|
|
*
|
|
* @param timeout Maximum time to wait for an allocation.
|
|
*
|
|
* @return a pointer to a newly allocated net_pkt on success, NULL otherwise.
|
|
*/
|
|
#if !defined(NET_PKT_DEBUG_ENABLED)
|
|
struct net_pkt *net_pkt_alloc(k_timeout_t timeout);
|
|
#endif
|
|
|
|
/**
|
|
* @brief Allocate an initialized net_pkt from a specific slab
|
|
*
|
|
* @details unlike net_pkt_alloc() which uses core slabs, this one will use
|
|
* an external slab (see NET_PKT_SLAB_DEFINE()).
|
|
* Do _not_ use it unless you know what you are doing. Basically, only
|
|
* net_context should be using this, in order to allocate packet and
|
|
* then buffer on its local slab/pool (if any).
|
|
*
|
|
* @param slab The slab to use for allocating the packet
|
|
* @param timeout Maximum time to wait for an allocation.
|
|
*
|
|
* @return a pointer to a newly allocated net_pkt on success, NULL otherwise.
|
|
*/
|
|
#if !defined(NET_PKT_DEBUG_ENABLED)
|
|
struct net_pkt *net_pkt_alloc_from_slab(struct k_mem_slab *slab,
|
|
k_timeout_t timeout);
|
|
#endif
|
|
|
|
/**
|
|
* @brief Allocate an initialized net_pkt for RX
|
|
*
|
|
* @details for the time being, 2 pools are used. One for TX and one for RX.
|
|
* This allocator has to be used for RX.
|
|
*
|
|
* @param timeout Maximum time to wait for an allocation.
|
|
*
|
|
* @return a pointer to a newly allocated net_pkt on success, NULL otherwise.
|
|
*/
|
|
#if !defined(NET_PKT_DEBUG_ENABLED)
|
|
struct net_pkt *net_pkt_rx_alloc(k_timeout_t timeout);
|
|
#endif
|
|
|
|
/**
|
|
* @brief Allocate a network packet for a specific network interface.
|
|
*
|
|
* @param iface The network interface the packet is supposed to go through.
|
|
* @param timeout Maximum time to wait for an allocation.
|
|
*
|
|
* @return a pointer to a newly allocated net_pkt on success, NULL otherwise.
|
|
*/
|
|
#if !defined(NET_PKT_DEBUG_ENABLED)
|
|
struct net_pkt *net_pkt_alloc_on_iface(struct net_if *iface,
|
|
k_timeout_t timeout);
|
|
|
|
/* Same as above but specifically for RX packet */
|
|
struct net_pkt *net_pkt_rx_alloc_on_iface(struct net_if *iface,
|
|
k_timeout_t timeout);
|
|
#endif
|
|
|
|
/**
|
|
* @brief Allocate buffer for a net_pkt
|
|
*
|
|
* @details: such allocator will take into account space necessary for headers,
|
|
* MTU, and existing buffer (if any). Beware that, due to all these
|
|
* criteria, the allocated size might be smaller/bigger than
|
|
* requested one.
|
|
*
|
|
* @param pkt The network packet requiring buffer to be allocated.
|
|
* @param size The size of buffer being requested.
|
|
* @param proto The IP protocol type (can be 0 for none).
|
|
* @param timeout Maximum time to wait for an allocation.
|
|
*
|
|
* @return 0 on success, negative errno code otherwise.
|
|
*/
|
|
#if !defined(NET_PKT_DEBUG_ENABLED)
|
|
int net_pkt_alloc_buffer(struct net_pkt *pkt,
|
|
size_t size,
|
|
enum net_ip_protocol proto,
|
|
k_timeout_t timeout);
|
|
#endif
|
|
|
|
/**
|
|
* @brief Allocate a network packet and buffer at once
|
|
*
|
|
* @param iface The network interface the packet is supposed to go through.
|
|
* @param size The size of buffer.
|
|
* @param family The family to which the packet belongs.
|
|
* @param proto The IP protocol type (can be 0 for none).
|
|
* @param timeout Maximum time to wait for an allocation.
|
|
*
|
|
* @return a pointer to a newly allocated net_pkt on success, NULL otherwise.
|
|
*/
|
|
#if !defined(NET_PKT_DEBUG_ENABLED)
|
|
struct net_pkt *net_pkt_alloc_with_buffer(struct net_if *iface,
|
|
size_t size,
|
|
sa_family_t family,
|
|
enum net_ip_protocol proto,
|
|
k_timeout_t timeout);
|
|
|
|
/* Same as above but specifically for RX packet */
|
|
struct net_pkt *net_pkt_rx_alloc_with_buffer(struct net_if *iface,
|
|
size_t size,
|
|
sa_family_t family,
|
|
enum net_ip_protocol proto,
|
|
k_timeout_t timeout);
|
|
#endif
|
|
|
|
/**
|
|
* @brief Append a buffer in packet
|
|
*
|
|
* @param pkt Network packet where to append the buffer
|
|
* @param buffer Buffer to append
|
|
*/
|
|
void net_pkt_append_buffer(struct net_pkt *pkt, struct net_buf *buffer);
|
|
|
|
/**
|
|
* @brief Get available buffer space from a pkt
|
|
*
|
|
* @note Reserved bytes (headroom) in any of the fragments are not considered to
|
|
* be available.
|
|
*
|
|
* @param pkt The net_pkt which buffer availability should be evaluated
|
|
*
|
|
* @return the amount of buffer available
|
|
*/
|
|
size_t net_pkt_available_buffer(struct net_pkt *pkt);
|
|
|
|
/**
|
|
* @brief Get available buffer space for payload from a pkt
|
|
*
|
|
* @note Reserved bytes (headroom) in any of the fragments are not considered to
|
|
* be available.
|
|
*
|
|
* @details Unlike net_pkt_available_buffer(), this will take into account
|
|
* the headers space.
|
|
*
|
|
* @param pkt The net_pkt which payload buffer availability should
|
|
* be evaluated
|
|
* @param proto The IP protocol type (can be 0 for none).
|
|
*
|
|
* @return the amount of buffer available for payload
|
|
*/
|
|
size_t net_pkt_available_payload_buffer(struct net_pkt *pkt,
|
|
enum net_ip_protocol proto);
|
|
|
|
/**
|
|
* @brief Trim net_pkt buffer
|
|
*
|
|
* @details This will basically check for unused buffers and deallocates
|
|
* them relevantly
|
|
*
|
|
* @param pkt The net_pkt which buffer will be trimmed
|
|
*/
|
|
void net_pkt_trim_buffer(struct net_pkt *pkt);
|
|
|
|
/**
|
|
* @brief Remove @a length bytes from tail of packet
|
|
*
|
|
* @details This function does not take packet cursor into account. It is a
|
|
* helper to remove unneeded bytes from tail of packet (like appended
|
|
* CRC). It takes care of buffer deallocation if removed bytes span
|
|
* whole buffer(s).
|
|
*
|
|
* @param pkt Network packet
|
|
* @param length Number of bytes to be removed
|
|
*
|
|
* @retval 0 On success.
|
|
* @retval -EINVAL If packet length is shorter than @a length.
|
|
*/
|
|
int net_pkt_remove_tail(struct net_pkt *pkt, size_t length);
|
|
|
|
/**
|
|
* @brief Initialize net_pkt cursor
|
|
*
|
|
* @details This will initialize the net_pkt cursor from its buffer.
|
|
*
|
|
* @param pkt The net_pkt whose cursor is going to be initialized
|
|
*/
|
|
void net_pkt_cursor_init(struct net_pkt *pkt);
|
|
|
|
/**
|
|
* @brief Backup net_pkt cursor
|
|
*
|
|
* @param pkt The net_pkt whose cursor is going to be backed up
|
|
* @param backup The cursor where to backup net_pkt cursor
|
|
*/
|
|
static inline void net_pkt_cursor_backup(struct net_pkt *pkt,
|
|
struct net_pkt_cursor *backup)
|
|
{
|
|
backup->buf = pkt->cursor.buf;
|
|
backup->pos = pkt->cursor.pos;
|
|
}
|
|
|
|
/**
|
|
* @brief Restore net_pkt cursor from a backup
|
|
*
|
|
* @param pkt The net_pkt whose cursor is going to be restored
|
|
* @param backup The cursor from where to restore net_pkt cursor
|
|
*/
|
|
static inline void net_pkt_cursor_restore(struct net_pkt *pkt,
|
|
struct net_pkt_cursor *backup)
|
|
{
|
|
pkt->cursor.buf = backup->buf;
|
|
pkt->cursor.pos = backup->pos;
|
|
}
|
|
|
|
/**
|
|
* @brief Returns current position of the cursor
|
|
*
|
|
* @param pkt The net_pkt whose cursor position is going to be returned
|
|
*
|
|
* @return cursor's position
|
|
*/
|
|
static inline void *net_pkt_cursor_get_pos(struct net_pkt *pkt)
|
|
{
|
|
return pkt->cursor.pos;
|
|
}
|
|
|
|
/**
|
|
* @brief Skip some data from a net_pkt
|
|
*
|
|
* @details net_pkt's cursor should be properly initialized
|
|
* Cursor position will be updated after the operation.
|
|
* Depending on the value of pkt->overwrite bit, this function
|
|
* will affect the buffer length or not. If it's true, it will
|
|
* advance the cursor to the requested length. If it's false,
|
|
* it will do the same but if the cursor was already also at the
|
|
* end of existing data, it will increment the buffer length.
|
|
* So in this case, its behavior is just like net_pkt_write or
|
|
* net_pkt_memset, difference being that it will not affect the
|
|
* buffer content itself (which may be just garbage then).
|
|
*
|
|
* @param pkt The net_pkt whose cursor will be updated to skip given
|
|
* amount of data from the buffer.
|
|
* @param length Amount of data to skip in the buffer
|
|
*
|
|
* @return 0 in success, negative errno code otherwise.
|
|
*/
|
|
int net_pkt_skip(struct net_pkt *pkt, size_t length);
|
|
|
|
/**
|
|
* @brief Memset some data in a net_pkt
|
|
*
|
|
* @details net_pkt's cursor should be properly initialized and,
|
|
* if needed, positioned using net_pkt_skip.
|
|
* Cursor position will be updated after the operation.
|
|
*
|
|
* @param pkt The net_pkt whose buffer to fill starting at the current
|
|
* cursor position.
|
|
* @param byte The byte to write in memory
|
|
* @param length Amount of data to memset with given byte
|
|
*
|
|
* @return 0 in success, negative errno code otherwise.
|
|
*/
|
|
int net_pkt_memset(struct net_pkt *pkt, int byte, size_t length);
|
|
|
|
/**
|
|
* @brief Copy data from a packet into another one.
|
|
*
|
|
* @details Both net_pkt cursors should be properly initialized and,
|
|
* if needed, positioned using net_pkt_skip.
|
|
* The cursors will be updated after the operation.
|
|
*
|
|
* @param pkt_dst Destination network packet.
|
|
* @param pkt_src Source network packet.
|
|
* @param length Length of data to be copied.
|
|
*
|
|
* @return 0 on success, negative errno code otherwise.
|
|
*/
|
|
int net_pkt_copy(struct net_pkt *pkt_dst,
|
|
struct net_pkt *pkt_src,
|
|
size_t length);
|
|
|
|
/**
|
|
* @brief Clone pkt and its buffer.
|
|
*
|
|
* @param pkt Original pkt to be cloned
|
|
* @param timeout Timeout to wait for free buffer
|
|
*
|
|
* @return NULL if error, cloned packet otherwise.
|
|
*/
|
|
struct net_pkt *net_pkt_clone(struct net_pkt *pkt, k_timeout_t timeout);
|
|
|
|
/**
|
|
* @brief Clone pkt and increase the refcount of its buffer.
|
|
*
|
|
* @param pkt Original pkt to be shallow cloned
|
|
* @param timeout Timeout to wait for free packet
|
|
*
|
|
* @return NULL if error, cloned packet otherwise.
|
|
*/
|
|
struct net_pkt *net_pkt_shallow_clone(struct net_pkt *pkt,
|
|
k_timeout_t timeout);
|
|
|
|
/**
|
|
* @brief Read some data from a net_pkt
|
|
*
|
|
* @details net_pkt's cursor should be properly initialized and,
|
|
* if needed, positioned using net_pkt_skip.
|
|
* Cursor position will be updated after the operation.
|
|
*
|
|
* @param pkt The network packet from where to read some data
|
|
* @param data The destination buffer where to copy the data
|
|
* @param length The amount of data to copy
|
|
*
|
|
* @return 0 on success, negative errno code otherwise.
|
|
*/
|
|
int net_pkt_read(struct net_pkt *pkt, void *data, size_t length);
|
|
|
|
/* Read uint8_t data data a net_pkt */
|
|
static inline int net_pkt_read_u8(struct net_pkt *pkt, uint8_t *data)
|
|
{
|
|
return net_pkt_read(pkt, data, 1);
|
|
}
|
|
|
|
/**
|
|
* @brief Read uint16_t big endian data from a net_pkt
|
|
*
|
|
* @details net_pkt's cursor should be properly initialized and,
|
|
* if needed, positioned using net_pkt_skip.
|
|
* Cursor position will be updated after the operation.
|
|
*
|
|
* @param pkt The network packet from where to read
|
|
* @param data The destination uint16_t where to copy the data
|
|
*
|
|
* @return 0 on success, negative errno code otherwise.
|
|
*/
|
|
int net_pkt_read_be16(struct net_pkt *pkt, uint16_t *data);
|
|
|
|
/**
|
|
* @brief Read uint16_t little endian data from a net_pkt
|
|
*
|
|
* @details net_pkt's cursor should be properly initialized and,
|
|
* if needed, positioned using net_pkt_skip.
|
|
* Cursor position will be updated after the operation.
|
|
*
|
|
* @param pkt The network packet from where to read
|
|
* @param data The destination uint16_t where to copy the data
|
|
*
|
|
* @return 0 on success, negative errno code otherwise.
|
|
*/
|
|
int net_pkt_read_le16(struct net_pkt *pkt, uint16_t *data);
|
|
|
|
/**
|
|
* @brief Read uint32_t big endian data from a net_pkt
|
|
*
|
|
* @details net_pkt's cursor should be properly initialized and,
|
|
* if needed, positioned using net_pkt_skip.
|
|
* Cursor position will be updated after the operation.
|
|
*
|
|
* @param pkt The network packet from where to read
|
|
* @param data The destination uint32_t where to copy the data
|
|
*
|
|
* @return 0 on success, negative errno code otherwise.
|
|
*/
|
|
int net_pkt_read_be32(struct net_pkt *pkt, uint32_t *data);
|
|
|
|
/**
|
|
* @brief Write data into a net_pkt
|
|
*
|
|
* @details net_pkt's cursor should be properly initialized and,
|
|
* if needed, positioned using net_pkt_skip.
|
|
* Cursor position will be updated after the operation.
|
|
*
|
|
* @param pkt The network packet where to write
|
|
* @param data Data to be written
|
|
* @param length Length of the data to be written
|
|
*
|
|
* @return 0 on success, negative errno code otherwise.
|
|
*/
|
|
int net_pkt_write(struct net_pkt *pkt, const void *data, size_t length);
|
|
|
|
/* Write uint8_t data into a net_pkt. */
|
|
static inline int net_pkt_write_u8(struct net_pkt *pkt, uint8_t data)
|
|
{
|
|
return net_pkt_write(pkt, &data, sizeof(uint8_t));
|
|
}
|
|
|
|
/* Write uint16_t big endian data into a net_pkt. */
|
|
static inline int net_pkt_write_be16(struct net_pkt *pkt, uint16_t data)
|
|
{
|
|
uint16_t data_be16 = htons(data);
|
|
|
|
return net_pkt_write(pkt, &data_be16, sizeof(uint16_t));
|
|
}
|
|
|
|
/* Write uint32_t big endian data into a net_pkt. */
|
|
static inline int net_pkt_write_be32(struct net_pkt *pkt, uint32_t data)
|
|
{
|
|
uint32_t data_be32 = htonl(data);
|
|
|
|
return net_pkt_write(pkt, &data_be32, sizeof(uint32_t));
|
|
}
|
|
|
|
/* Write uint32_t little endian data into a net_pkt. */
|
|
static inline int net_pkt_write_le32(struct net_pkt *pkt, uint32_t data)
|
|
{
|
|
uint32_t data_le32 = sys_cpu_to_le32(data);
|
|
|
|
return net_pkt_write(pkt, &data_le32, sizeof(uint32_t));
|
|
}
|
|
|
|
/* Write uint16_t little endian data into a net_pkt. */
|
|
static inline int net_pkt_write_le16(struct net_pkt *pkt, uint16_t data)
|
|
{
|
|
uint16_t data_le16 = sys_cpu_to_le16(data);
|
|
|
|
return net_pkt_write(pkt, &data_le16, sizeof(uint16_t));
|
|
}
|
|
|
|
/**
|
|
* @brief Get the amount of data which can be read from current cursor position
|
|
*
|
|
* @param pkt Network packet
|
|
*
|
|
* @return Amount of data which can be read from current pkt cursor
|
|
*/
|
|
size_t net_pkt_remaining_data(struct net_pkt *pkt);
|
|
|
|
/**
|
|
* @brief Update the overall length of a packet
|
|
*
|
|
* @details Unlike net_pkt_pull() below, this does not take packet cursor
|
|
* into account. It's mainly a helper dedicated for ipv4 and ipv6
|
|
* input functions. It shrinks the overall length by given parameter.
|
|
*
|
|
* @param pkt Network packet
|
|
* @param length The new length of the packet
|
|
*
|
|
* @return 0 on success, negative errno code otherwise.
|
|
*/
|
|
int net_pkt_update_length(struct net_pkt *pkt, size_t length);
|
|
|
|
/**
|
|
* @brief Remove data from the packet at current location
|
|
*
|
|
* @details net_pkt's cursor should be properly initialized and,
|
|
* eventually, properly positioned using net_pkt_skip/read/write.
|
|
* Note that net_pkt's cursor is reset by this function.
|
|
*
|
|
* @param pkt Network packet
|
|
* @param length Number of bytes to be removed
|
|
*
|
|
* @return 0 on success, negative errno code otherwise.
|
|
*/
|
|
int net_pkt_pull(struct net_pkt *pkt, size_t length);
|
|
|
|
/**
|
|
* @brief Get the actual offset in the packet from its cursor
|
|
*
|
|
* @param pkt Network packet.
|
|
*
|
|
* @return a valid offset on success, 0 otherwise as there is nothing that
|
|
* can be done to evaluate the offset.
|
|
*/
|
|
uint16_t net_pkt_get_current_offset(struct net_pkt *pkt);
|
|
|
|
/**
|
|
* @brief Check if a data size could fit contiguously
|
|
*
|
|
* @details net_pkt's cursor should be properly initialized and,
|
|
* if needed, positioned using net_pkt_skip.
|
|
*
|
|
* @param pkt Network packet.
|
|
* @param size The size to check for contiguity
|
|
*
|
|
* @return true if that is the case, false otherwise.
|
|
*/
|
|
bool net_pkt_is_contiguous(struct net_pkt *pkt, size_t size);
|
|
|
|
/**
|
|
* Get the contiguous buffer space
|
|
*
|
|
* @param pkt Network packet
|
|
*
|
|
* @return The available contiguous buffer space in bytes starting from the
|
|
* current cursor position. 0 in case of an error.
|
|
*/
|
|
size_t net_pkt_get_contiguous_len(struct net_pkt *pkt);
|
|
|
|
struct net_pkt_data_access {
|
|
#if !defined(CONFIG_NET_HEADERS_ALWAYS_CONTIGUOUS)
|
|
void *data;
|
|
#endif
|
|
const size_t size;
|
|
};
|
|
|
|
#if defined(CONFIG_NET_HEADERS_ALWAYS_CONTIGUOUS)
|
|
#define NET_PKT_DATA_ACCESS_DEFINE(_name, _type) \
|
|
struct net_pkt_data_access _name = { \
|
|
.size = sizeof(_type), \
|
|
}
|
|
|
|
#define NET_PKT_DATA_ACCESS_CONTIGUOUS_DEFINE(_name, _type) \
|
|
NET_PKT_DATA_ACCESS_DEFINE(_name, _type)
|
|
|
|
#else
|
|
#define NET_PKT_DATA_ACCESS_DEFINE(_name, _type) \
|
|
_type _hdr_##_name; \
|
|
struct net_pkt_data_access _name = { \
|
|
.data = &_hdr_##_name, \
|
|
.size = sizeof(_type), \
|
|
}
|
|
|
|
#define NET_PKT_DATA_ACCESS_CONTIGUOUS_DEFINE(_name, _type) \
|
|
struct net_pkt_data_access _name = { \
|
|
.data = NULL, \
|
|
.size = sizeof(_type), \
|
|
}
|
|
|
|
#endif /* CONFIG_NET_HEADERS_ALWAYS_CONTIGUOUS */
|
|
|
|
/**
|
|
* @brief Get data from a network packet in a contiguous way
|
|
*
|
|
* @details net_pkt's cursor should be properly initialized and,
|
|
* if needed, positioned using net_pkt_skip.
|
|
* Cursor position will be updated after the operation.
|
|
*
|
|
* @param pkt The network packet from where to get the data.
|
|
* @param access A pointer to a valid net_pkt_data_access describing the
|
|
* data to get in a contiguous way.
|
|
*
|
|
* @return a pointer to the requested contiguous data, NULL otherwise.
|
|
*/
|
|
void *net_pkt_get_data(struct net_pkt *pkt,
|
|
struct net_pkt_data_access *access);
|
|
|
|
/**
|
|
* @brief Set contiguous data into a network packet
|
|
*
|
|
* @details net_pkt's cursor should be properly initialized and,
|
|
* if needed, positioned using net_pkt_skip.
|
|
* Cursor position will be updated after the operation.
|
|
*
|
|
* @param pkt The network packet to where the data should be set.
|
|
* @param access A pointer to a valid net_pkt_data_access describing the
|
|
* data to set.
|
|
*
|
|
* @return 0 on success, a negative errno otherwise.
|
|
*/
|
|
int net_pkt_set_data(struct net_pkt *pkt,
|
|
struct net_pkt_data_access *access);
|
|
|
|
/**
|
|
* Acknowledge previously contiguous data taken from a network packet
|
|
* Packet needs to be set to overwrite mode.
|
|
*/
|
|
static inline int net_pkt_acknowledge_data(struct net_pkt *pkt,
|
|
struct net_pkt_data_access *access)
|
|
{
|
|
return net_pkt_skip(pkt, access->size);
|
|
}
|
|
|
|
/**
|
|
* @}
|
|
*/
|
|
|
|
#ifdef __cplusplus
|
|
}
|
|
#endif
|
|
|
|
#endif /* ZEPHYR_INCLUDE_NET_NET_PKT_H_ */
|