net_pkt.h

Go to the documentation of this file.

 
/*
 * 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 <zephyr/net/buf.h>
 
#if defined(CONFIG_IEEE802154)
#include <zephyr/net/ieee802154_pkt.h>
#endif
#include <zephyr/net/net_core.h>
#include <zephyr/net/net_linkaddr.h>
#include <zephyr/net/net_ip.h>
#include <zephyr/net/net_if.h>
#include <zephyr/net/net_context.h>
#include <zephyr/net/net_time.h>
#include <zephyr/net/ethernet_vlan.h>
#include <zephyr/net/ptp_time.h>
 
#ifdef __cplusplus
extern "C" {
#endif
 
struct net_context;
 
/* buffer cursor used in net_pkt */
struct net_pkt_cursor {
 struct net_buf *buf;
 uint8_t *pos;
};
 
struct net_pkt {
 intptr_t fifo;
 
 struct k_mem_slab *slab;
 
 union {
 struct net_buf *frags; 
 struct net_buf *buffer; 
 };
 
 struct net_pkt_cursor cursor;
 
 struct net_context *context;
 
 struct net_if *iface;
 
#if defined(CONFIG_NET_TCP)
 sys_snode_t next;
#endif
#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) || defined(CONFIG_NET_PKT_TXTIME)
 struct net_ptp_time timestamp;
#endif
 
#if defined(CONFIG_NET_PKT_RXTIME_STATS) || defined(CONFIG_NET_PKT_TXTIME_STATS)
 struct {
 uint32_t create_time;
 
#if defined(CONFIG_NET_PKT_TXTIME_STATS_DETAIL) || \
 defined(CONFIG_NET_PKT_RXTIME_STATS_DETAIL)
 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 */
 
 atomic_t atomic_ref;
 
 /* Filled by layer 2 when network packet is received. */
 struct net_linkaddr lladdr_src;
 struct net_linkaddr lladdr_dst;
 uint16_t ll_proto_type;
 
#if defined(CONFIG_NET_IP)
 uint8_t ip_hdr_len; /* pre-filled in order to avoid func call */
#endif
 
 uint8_t overwrite : 1; /* Is packet content being overwritten? */
 uint8_t eof : 1; /* Last packet before EOF */
 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; /* Address family, see net_ip.h */
 
 /* bitfield byte alignment boundary */
 
#if defined(CONFIG_NET_IPV4_AUTO)
 uint8_t ipv4_auto_arp_msg : 1; /* Is this pkt IPv4 autoconf ARP
 * message.
 * Note: family needs to be
 * AF_INET.
 */
#endif
#if defined(CONFIG_NET_LLDP)
 uint8_t lldp_pkt : 1; /* Is this pkt an LLDP message.
 * Note: family needs to be
 * AF_UNSPEC.
 */
#endif
 uint8_t ppp_msg : 1; /* This is a PPP message */
 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).
 */
 uint8_t l2_processed : 1; /* Set to 1 if this packet has already been
 * processed by the L2
 */
 uint8_t chksum_done : 1; /* Checksum has already been computed for
 * the packet.
 */
#if defined(CONFIG_NET_IP_FRAGMENT)
 uint8_t ip_reassembled : 1; /* Packet is a reassembled IP packet. */
#endif
 /* bitfield byte alignment boundary */
 
#if defined(CONFIG_NET_IP)
 union {
 /* IPv6 hop limit or IPv4 ttl for this network packet.
 * The value is shared between IPv6 and IPv4.
 */
#if defined(CONFIG_NET_IPV6)
 uint8_t ipv6_hop_limit;
#endif
#if defined(CONFIG_NET_IPV4)
 uint8_t ipv4_ttl;
#endif
 };
 
 union {
#if defined(CONFIG_NET_IPV4)
 uint8_t ipv4_opts_len; /* length of IPv4 header options */
#endif
#if defined(CONFIG_NET_IPV6)
 uint16_t ipv6_ext_len; /* length of extension headers */
#endif
 };
 
#if defined(CONFIG_NET_IP_FRAGMENT)
 union {
#if defined(CONFIG_NET_IPV4_FRAGMENT)
 struct {
 uint16_t flags; /* Fragment offset and M (More Fragment) flag */
 uint16_t id; /* Fragment ID */
 } ipv4_fragment;
#endif /* CONFIG_NET_IPV4_FRAGMENT */
#if defined(CONFIG_NET_IPV6_FRAGMENT)
 struct {
 uint16_t flags; /* Fragment offset and M (More Fragment) flag */
 uint32_t id; /* Fragment id */
 uint16_t hdr_start; /* Where starts the fragment header */
 } ipv6_fragment;
#endif /* CONFIG_NET_IPV6_FRAGMENT */
 };
#endif /* CONFIG_NET_IP_FRAGMENT */
 
#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;
 
 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_NET_IP_DSCP_ECN)
 uint8_t ip_dscp : 6;
 
 uint8_t ip_ecn : 2;
#endif /* CONFIG_NET_IP_DSCP_ECN */
#endif /* CONFIG_NET_IP */
 
#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(NET_PKT_HAS_CONTROL_BLOCK)
 /* TODO: Evolve this into a union of orthogonal
 * control block declarations if further L2
 * stacks require L2-specific attributes.
 */
#if defined(CONFIG_IEEE802154)
 /* The following structure requires a 4-byte alignment
 * boundary to avoid padding.
 */
 struct net_pkt_cb_ieee802154 cb;
#endif /* CONFIG_IEEE802154 */
#endif /* NET_PKT_HAS_CONTROL_BLOCK */
 
 uint8_t priority;
 
#if defined(CONFIG_NET_OFFLOAD) || defined(CONFIG_NET_L2_IPIP)
 /* Remote address of the recived packet. This is only used by
 * network interfaces with an offloaded TCP/IP stack, or if we
 * have network tunneling in use.
 */
 union {
 struct sockaddr remote;
 
 /* This will make sure that there is enough storage to store
 * the address struct. The access to value is via remote
 * address.
 */
 struct sockaddr_storage remote_storage;
 };
#endif /* CONFIG_NET_OFFLOAD */
 
#if defined(CONFIG_NET_CAPTURE_COOKED_MODE)
 /* Tell the capture api that this is a captured packet */
 uint8_t cooked_mode_pkt : 1;
#endif /* CONFIG_NET_CAPTURE_COOKED_MODE */
 
 /* @endcond */
};
 
/* 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) {
 uint8_t type = net_if_get_link_addr(iface)->type;
 
 pkt->lladdr_src.type = type;
 pkt->lladdr_dst.type = 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 bool net_pkt_is_l2_processed(struct net_pkt *pkt)
{
 return !!(pkt->l2_processed);
}
 
static inline void net_pkt_set_l2_processed(struct net_pkt *pkt,
 bool is_l2_processed)
{
 pkt->l2_processed = is_l2_processed;
}
 
static inline bool net_pkt_is_chksum_done(struct net_pkt *pkt)
{
 return !!(pkt->chksum_done);
}
 
static inline void net_pkt_set_chksum_done(struct net_pkt *pkt,
 bool is_chksum_done)
{
 pkt->chksum_done = is_chksum_done;
}
 
static inline uint8_t net_pkt_ip_hdr_len(struct net_pkt *pkt)
{
#if defined(CONFIG_NET_IP)
 return pkt->ip_hdr_len;
#else
 return 0;
#endif
}
 
static inline void net_pkt_set_ip_hdr_len(struct net_pkt *pkt, uint8_t len)
{
#if defined(CONFIG_NET_IP)
 pkt->ip_hdr_len = len;
#endif
}
 
static inline uint8_t net_pkt_ip_dscp(struct net_pkt *pkt)
{
#if defined(CONFIG_NET_IP_DSCP_ECN)
 return pkt->ip_dscp;
#else
 return 0;
#endif
}
 
static inline void net_pkt_set_ip_dscp(struct net_pkt *pkt, uint8_t dscp)
{
#if defined(CONFIG_NET_IP_DSCP_ECN)
 pkt->ip_dscp = dscp;
#endif
}
 
static inline uint8_t net_pkt_ip_ecn(struct net_pkt *pkt)
{
#if defined(CONFIG_NET_IP_DSCP_ECN)
 return pkt->ip_ecn;
#else
 return 0;
#endif
}
 
static inline void net_pkt_set_ip_ecn(struct net_pkt *pkt, uint8_t ecn)
{
#if defined(CONFIG_NET_IP_DSCP_ECN)
 pkt->ip_ecn = ecn;
#endif
}
 
static inline uint8_t net_pkt_eof(struct net_pkt *pkt)
{
 return pkt->eof;
}
 
static inline void net_pkt_set_eof(struct net_pkt *pkt, bool eof)
{
 pkt->eof = eof;
}
 
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;
}
 
#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_IPV4_FRAGMENT)
static inline uint16_t net_pkt_ipv4_fragment_offset(struct net_pkt *pkt)
{
 return (pkt->ipv4_fragment.flags & NET_IPV4_FRAGH_OFFSET_MASK) * 8;
}
 
static inline bool net_pkt_ipv4_fragment_more(struct net_pkt *pkt)
{
 return (pkt->ipv4_fragment.flags & NET_IPV4_MORE_FRAG_MASK) != 0;
}
 
static inline void net_pkt_set_ipv4_fragment_flags(struct net_pkt *pkt, uint16_t flags)
{
 pkt->ipv4_fragment.flags = flags;
}
 
static inline uint32_t net_pkt_ipv4_fragment_id(struct net_pkt *pkt)
{
 return pkt->ipv4_fragment.id;
}
 
static inline void net_pkt_set_ipv4_fragment_id(struct net_pkt *pkt, uint32_t id)
{
 pkt->ipv4_fragment.id = id;
}
#else /* CONFIG_NET_IPV4_FRAGMENT */
static inline uint16_t net_pkt_ipv4_fragment_offset(struct net_pkt *pkt)
{
 ARG_UNUSED(pkt);
 
 return 0;
}
 
static inline bool net_pkt_ipv4_fragment_more(struct net_pkt *pkt)
{
 ARG_UNUSED(pkt);
 
 return 0;
}
 
static inline void net_pkt_set_ipv4_fragment_flags(struct net_pkt *pkt, uint16_t flags)
{
 ARG_UNUSED(pkt);
 ARG_UNUSED(flags);
}
 
static inline uint32_t net_pkt_ipv4_fragment_id(struct net_pkt *pkt)
{
 ARG_UNUSED(pkt);
 
 return 0;
}
 
static inline void net_pkt_set_ipv4_fragment_id(struct net_pkt *pkt, uint32_t id)
{
 ARG_UNUSED(pkt);
 ARG_UNUSED(id);
}
#endif /* CONFIG_NET_IPV4_FRAGMENT */
 
#if defined(CONFIG_NET_IPV6_FRAGMENT)
static inline uint16_t net_pkt_ipv6_fragment_start(struct net_pkt *pkt)
{
 return pkt->ipv6_fragment.hdr_start;
}
 
static inline void net_pkt_set_ipv6_fragment_start(struct net_pkt *pkt,
 uint16_t start)
{
 pkt->ipv6_fragment.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 */
 
#if defined(CONFIG_NET_IP_FRAGMENT)
static inline bool net_pkt_is_ip_reassembled(struct net_pkt *pkt)
{
 return !!(pkt->ip_reassembled);
}
 
static inline void net_pkt_set_ip_reassembled(struct net_pkt *pkt,
 bool reassembled)
{
 pkt->ip_reassembled = reassembled;
}
#else /* CONFIG_NET_IP_FRAGMENT */
static inline bool net_pkt_is_ip_reassembled(struct net_pkt *pkt)
{
 ARG_UNUSED(pkt);
 
 return false;
}
 
static inline void net_pkt_set_ip_reassembled(struct net_pkt *pkt,
 bool reassembled)
{
 ARG_UNUSED(pkt);
 ARG_UNUSED(reassembled);
}
#endif /* CONFIG_NET_IP_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_CAPTURE_COOKED_MODE)
static inline bool net_pkt_is_cooked_mode(struct net_pkt *pkt)
{
 return pkt->cooked_mode_pkt;
}
 
static inline void net_pkt_set_cooked_mode(struct net_pkt *pkt, bool value)
{
 pkt->cooked_mode_pkt = value;
}
#else
static inline bool net_pkt_is_cooked_mode(struct net_pkt *pkt)
{
 ARG_UNUSED(pkt);
 
 return false;
}
 
static inline void net_pkt_set_cooked_mode(struct net_pkt *pkt, bool value)
{
 ARG_UNUSED(pkt);
 ARG_UNUSED(value);
}
#endif /* CONFIG_NET_CAPTURE_COOKED_MODE */
 
#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) || defined(CONFIG_NET_PKT_TXTIME)
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;
}
 
static inline net_time_t net_pkt_timestamp_ns(struct net_pkt *pkt)
{
 return net_ptp_time_to_ns(&pkt->timestamp);
}
 
static inline void net_pkt_set_timestamp_ns(struct net_pkt *pkt, net_time_t timestamp)
{
 pkt->timestamp = ns_to_net_ptp_time(timestamp);
}
#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);
}
 
static inline net_time_t net_pkt_timestamp_ns(struct net_pkt *pkt)
{
 ARG_UNUSED(pkt);
 
 return 0;
}
 
static inline void net_pkt_set_timestamp_ns(struct net_pkt *pkt, net_time_t timestamp)
{
 ARG_UNUSED(pkt);
 ARG_UNUSED(timestamp);
}
#endif /* CONFIG_NET_PKT_TIMESTAMP || CONFIG_NET_PKT_TXTIME */
 
#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 */
 
static inline uint64_t net_pkt_txtime(struct net_pkt *pkt)
{
#if defined(CONFIG_NET_PKT_TXTIME)
 return pkt->timestamp.second * NSEC_PER_SEC + pkt->timestamp.nanosecond;
#else
 ARG_UNUSED(pkt);
 
 return 0;
#endif /* CONFIG_NET_PKT_TXTIME */
}
 
static inline void net_pkt_set_txtime(struct net_pkt *pkt, uint64_t txtime)
{
#if defined(CONFIG_NET_PKT_TXTIME)
 pkt->timestamp.second = txtime / NSEC_PER_SEC;
 pkt->timestamp.nanosecond = txtime % NSEC_PER_SEC;
#else
 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;
}
 
static inline uint16_t net_pkt_ll_proto_type(struct net_pkt *pkt)
{
 return pkt->ll_proto_type;
}
 
static inline void net_pkt_set_ll_proto_type(struct net_pkt *pkt, uint16_t type)
{
 pkt->ll_proto_type = type;
}
 
#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_L2_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_L2_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_L2_PPP */
 
#if defined(NET_PKT_HAS_CONTROL_BLOCK)
static inline void *net_pkt_cb(struct net_pkt *pkt)
{
 return &pkt->cb;
}
#else
static inline void *net_pkt_cb(struct net_pkt *pkt)
{
 ARG_UNUSED(pkt);
 
 return NULL;
}
#endif
 
#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 */
 
#if defined(CONFIG_NET_PKT_FILTER) && \
 (defined(CONFIG_NET_PKT_FILTER_IPV4_HOOK) || defined(CONFIG_NET_PKT_FILTER_IPV6_HOOK))
 
bool net_pkt_filter_ip_recv_ok(struct net_pkt *pkt);
 
#else
 
static inline bool net_pkt_filter_ip_recv_ok(struct net_pkt *pkt)
{
 ARG_UNUSED(pkt);
 
 return true;
}
 
#endif /* CONFIG_NET_PKT_FILTER_IPV4_HOOK || CONFIG_NET_PKT_FILTER_IPV6_HOOK */
 
#if defined(CONFIG_NET_PKT_FILTER) && defined(CONFIG_NET_PKT_FILTER_LOCAL_IN_HOOK)
 
bool net_pkt_filter_local_in_recv_ok(struct net_pkt *pkt);
 
#else
 
static inline bool net_pkt_filter_local_in_recv_ok(struct net_pkt *pkt)
{
 ARG_UNUSED(pkt);
 
 return true;
}
 
#endif /* CONFIG_NET_PKT_FILTER && CONFIG_NET_PKT_FILTER_LOCAL_IN_HOOK */
 
#if defined(CONFIG_NET_OFFLOAD) || defined(CONFIG_NET_L2_IPIP)
static inline struct sockaddr *net_pkt_remote_address(struct net_pkt *pkt)
{
 return &pkt->remote;
}
 
static inline void net_pkt_set_remote_address(struct net_pkt *pkt,
 struct sockaddr *address,
 socklen_t len)
{
 memcpy(&pkt->remote, address, len);
}
#endif /* CONFIG_NET_OFFLOAD || CONFIG_NET_L2_IPIP */
 
/* @endcond */
 
#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)
 
#define NET_PKT_DATA_POOL_DEFINE(name, count) \
 NET_BUF_POOL_DEFINE(name, count, CONFIG_NET_BUF_DATA_SIZE, \
 0, NULL)
 
#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,
 size_t min_len,
 k_timeout_t timeout,
 const char *caller,
 int line);
 
#define net_pkt_get_reserve_data(pool, min_len, timeout) \
 net_pkt_get_reserve_data_debug(pool, min_len, timeout, __func__, __LINE__)
 
struct net_buf *net_pkt_get_reserve_rx_data_debug(size_t min_len,
 k_timeout_t timeout,
 const char *caller,
 int line);
#define net_pkt_get_reserve_rx_data(min_len, timeout) \
 net_pkt_get_reserve_rx_data_debug(min_len, timeout, __func__, __LINE__)
 
struct net_buf *net_pkt_get_reserve_tx_data_debug(size_t min_len,
 k_timeout_t timeout,
 const char *caller,
 int line);
#define net_pkt_get_reserve_tx_data(min_len, timeout) \
 net_pkt_get_reserve_tx_data_debug(min_len, timeout, __func__, __LINE__)
 
struct net_buf *net_pkt_get_frag_debug(struct net_pkt *pkt, size_t min_len,
 k_timeout_t timeout,
 const char *caller, int line);
#define net_pkt_get_frag(pkt, min_len, timeout) \
 net_pkt_get_frag_debug(pkt, min_len, 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
 */
#if defined(NET_PKT_DEBUG_ENABLED)
void net_pkt_print_frags(struct net_pkt *pkt);
#else
#define net_pkt_print_frags(pkt)
#endif
 
#if !defined(NET_PKT_DEBUG_ENABLED)
struct net_buf *net_pkt_get_reserve_data(struct net_buf_pool *pool,
 size_t min_len, k_timeout_t timeout);
#endif
 
#if !defined(NET_PKT_DEBUG_ENABLED)
struct net_buf *net_pkt_get_reserve_rx_data(size_t min_len, k_timeout_t timeout);
#endif
 
#if !defined(NET_PKT_DEBUG_ENABLED)
struct net_buf *net_pkt_get_reserve_tx_data(size_t min_len, k_timeout_t timeout);
#endif
 
#if !defined(NET_PKT_DEBUG_ENABLED)
struct net_buf *net_pkt_get_frag(struct net_pkt *pkt, size_t min_len,
 k_timeout_t timeout);
#endif
 
#if !defined(NET_PKT_DEBUG_ENABLED)
void net_pkt_unref(struct net_pkt *pkt);
#endif
 
#if !defined(NET_PKT_DEBUG_ENABLED)
struct net_pkt *net_pkt_ref(struct net_pkt *pkt);
#endif
 
#if !defined(NET_PKT_DEBUG_ENABLED)
struct net_buf *net_pkt_frag_ref(struct net_buf *frag);
#endif
 
#if !defined(NET_PKT_DEBUG_ENABLED)
void net_pkt_frag_unref(struct net_buf *frag);
#endif
 
#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
 
#if !defined(NET_PKT_DEBUG_ENABLED)
void net_pkt_frag_add(struct net_pkt *pkt, struct net_buf *frag);
#endif
 
#if !defined(NET_PKT_DEBUG_ENABLED)
void net_pkt_frag_insert(struct net_pkt *pkt, struct net_buf *frag);
#endif
 
void net_pkt_compact(struct net_pkt *pkt);
 
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);
 
#if defined(CONFIG_NET_DEBUG_NET_PKT_ALLOC)
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__)
 
int net_pkt_alloc_buffer_raw_debug(struct net_pkt *pkt, size_t size,
 k_timeout_t timeout,
 const char *caller, int line);
#define net_pkt_alloc_buffer_raw(_pkt, _size, _timeout) \
 net_pkt_alloc_buffer_raw_debug(_pkt, _size, _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 */
#if !defined(NET_PKT_DEBUG_ENABLED)
struct net_pkt *net_pkt_alloc(k_timeout_t timeout);
#endif
 
#if !defined(NET_PKT_DEBUG_ENABLED)
struct net_pkt *net_pkt_alloc_from_slab(struct k_mem_slab *slab,
 k_timeout_t timeout);
#endif
 
#if !defined(NET_PKT_DEBUG_ENABLED)
struct net_pkt *net_pkt_rx_alloc(k_timeout_t timeout);
#endif
 
#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
 
#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
 
#if !defined(NET_PKT_DEBUG_ENABLED)
int net_pkt_alloc_buffer_raw(struct net_pkt *pkt, size_t size,
 k_timeout_t timeout);
#endif
 
#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
 
void net_pkt_append_buffer(struct net_pkt *pkt, struct net_buf *buffer);
 
size_t net_pkt_available_buffer(struct net_pkt *pkt);
 
size_t net_pkt_available_payload_buffer(struct net_pkt *pkt,
 enum net_ip_protocol proto);
 
void net_pkt_trim_buffer(struct net_pkt *pkt);
 
int net_pkt_remove_tail(struct net_pkt *pkt, size_t length);
 
void net_pkt_cursor_init(struct net_pkt *pkt);
 
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;
}
 
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;
}
 
static inline void *net_pkt_cursor_get_pos(struct net_pkt *pkt)
{
 return pkt->cursor.pos;
}
 
int net_pkt_skip(struct net_pkt *pkt, size_t length);
 
int net_pkt_memset(struct net_pkt *pkt, int byte, size_t length);
 
int net_pkt_copy(struct net_pkt *pkt_dst,
 struct net_pkt *pkt_src,
 size_t length);
 
struct net_pkt *net_pkt_clone(struct net_pkt *pkt, k_timeout_t timeout);
 
struct net_pkt *net_pkt_rx_clone(struct net_pkt *pkt, k_timeout_t timeout);
 
struct net_pkt *net_pkt_shallow_clone(struct net_pkt *pkt,
 k_timeout_t timeout);
 
int net_pkt_read(struct net_pkt *pkt, void *data, size_t length);
 
static inline int net_pkt_read_u8(struct net_pkt *pkt, uint8_t *data)
{
 return net_pkt_read(pkt, data, 1);
}
 
int net_pkt_read_be16(struct net_pkt *pkt, uint16_t *data);
 
int net_pkt_read_le16(struct net_pkt *pkt, uint16_t *data);
 
int net_pkt_read_be32(struct net_pkt *pkt, uint32_t *data);
 
int net_pkt_write(struct net_pkt *pkt, const void *data, size_t length);
 
static inline int net_pkt_write_u8(struct net_pkt *pkt, uint8_t data)
{
 return net_pkt_write(pkt, &data, sizeof(uint8_t));
}
 
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));
}
 
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));
}
 
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));
}
 
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));
}
 
size_t net_pkt_remaining_data(struct net_pkt *pkt);
 
int net_pkt_update_length(struct net_pkt *pkt, size_t length);
 
int net_pkt_pull(struct net_pkt *pkt, size_t length);
 
uint16_t net_pkt_get_current_offset(struct net_pkt *pkt);
 
bool net_pkt_is_contiguous(struct net_pkt *pkt, size_t size);
 
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 */
 
void *net_pkt_get_data(struct net_pkt *pkt,
 struct net_pkt_data_access *access);
 
int net_pkt_set_data(struct net_pkt *pkt,
 struct net_pkt_data_access *access);
 
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_ */