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>
 
#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/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_ROUTING) || defined(CONFIG_NET_ETHERNET_BRIDGE)
        struct net_if *orig_iface; /* Original network interface */
#endif
 
#if defined(CONFIG_NET_PKT_TIMESTAMP)
        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 */
 
#if defined(CONFIG_NET_PKT_TXTIME)
        uint64_t txtime;
#endif /* CONFIG_NET_PKT_TXTIME */
 
        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)
        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).
                                 */
 
        uint8_t l2_processed : 1; /* Set to 1 if this packet has already been
                                   * processed by the L2
                                   */
 
        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
        };
 
        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
        /* @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) {
                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 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 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 */
 
#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,
                                               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
        */
#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_rx_data(k_timeout_t timeout);
#endif
 
#if !defined(NET_PKT_DEBUG_ENABLED)
struct net_buf *net_pkt_get_reserve_tx_data(k_timeout_t timeout);
#endif
 
#if !defined(NET_PKT_DEBUG_ENABLED)
struct net_buf *net_pkt_get_frag(struct net_pkt *pkt, 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
 
bool 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__)
 
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)
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);
 
/* 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);
}
 
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);
 
/* 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));
}
 
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_ */