| /** @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 __NET_PKT_H__ |
| #define __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> |
| |
| #ifdef __cplusplus |
| extern "C" { |
| #endif |
| |
| /** |
| * @brief Network packet management library |
| * @defgroup net_pkt Network Packet Library |
| * @{ |
| */ |
| |
| struct net_context; |
| |
| struct net_pkt { |
| /** FIFO uses first 4 bytes itself, reserve space */ |
| int _reserved; |
| |
| /** Slab pointer from where it belongs to */ |
| struct k_mem_slab *slab; |
| |
| /** List of buffer fragments holding the packet */ |
| struct net_buf *frags; |
| |
| /** Network connection context */ |
| struct net_context *context; |
| |
| /** Network context token that user can set. This is passed |
| * to user callback when data has been sent. |
| */ |
| void *token; |
| |
| /** Network interface */ |
| struct net_if *iface; |
| |
| /** @cond ignore */ |
| |
| u8_t *appdata; /* application data starts here */ |
| u8_t *next_hdr; /* where is the next header */ |
| |
| /* Filled by layer 2 when network packet is received. */ |
| struct net_linkaddr lladdr_src; |
| struct net_linkaddr lladdr_dst; |
| |
| u16_t appdatalen; |
| u8_t ll_reserve; /* link layer header length */ |
| u8_t ip_hdr_len; /* pre-filled in order to avoid func call */ |
| |
| #if defined(CONFIG_NET_TCP) |
| sys_snode_t sent_list; |
| #endif |
| |
| u8_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) |
| */ |
| u8_t forwarding : 1; /* Are we forwarding this pkt |
| * Used only if defined(CONFIG_NET_ROUTE) |
| */ |
| u8_t family : 4; /* IPv4 vs IPv6 */ |
| u8_t _unused : 4; |
| |
| #if defined(CONFIG_NET_IPV6) |
| u8_t ipv6_hop_limit; /* IPv6 hop limit for this network packet. */ |
| u8_t ipv6_ext_len; /* length of extension headers */ |
| u8_t ipv6_ext_opt_len; /* IPv6 ND option length */ |
| |
| /* 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. |
| */ |
| u16_t ipv6_prev_hdr_start; |
| |
| #if defined(CONFIG_NET_IPV6_FRAGMENT) |
| u16_t ipv6_fragment_offset; /* Fragment offset of this packet */ |
| u32_t ipv6_fragment_id; /* Fragment id */ |
| u8_t *ipv6_frag_hdr_start; /* Where starts the fragment header */ |
| #endif /* CONFIG_NET_IPV6_FRAGMENT */ |
| #endif /* CONFIG_NET_IPV6 */ |
| |
| #if defined(CONFIG_NET_L2_IEEE802154) |
| u8_t ieee802154_rssi; |
| #endif |
| /* @endcond */ |
| |
| /** Reference counter */ |
| u8_t ref; |
| }; |
| |
| /** @cond ignore */ |
| |
| |
| /* The interface real ll address */ |
| static inline struct net_linkaddr *net_pkt_ll_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 void *net_pkt_token(struct net_pkt *pkt) |
| { |
| return pkt->token; |
| } |
| |
| static inline void net_pkt_set_token(struct net_pkt *pkt, void *token) |
| { |
| pkt->token = token; |
| } |
| |
| 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. |
| */ |
| pkt->lladdr_src.type = iface->link_addr.type; |
| pkt->lladdr_dst.type = iface->link_addr.type; |
| } |
| |
| static inline u8_t net_pkt_family(struct net_pkt *pkt) |
| { |
| return pkt->family; |
| } |
| |
| static inline void net_pkt_set_family(struct net_pkt *pkt, u8_t family) |
| { |
| pkt->family = family; |
| } |
| |
| static inline u8_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, u8_t len) |
| { |
| pkt->ip_hdr_len = len; |
| } |
| |
| static inline u8_t *net_pkt_next_hdr(struct net_pkt *pkt) |
| { |
| return pkt->next_hdr; |
| } |
| |
| static inline void net_pkt_set_next_hdr(struct net_pkt *pkt, u8_t *hdr) |
| { |
| pkt->next_hdr = hdr; |
| } |
| |
| static inline u8_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; |
| } |
| |
| #if defined(CONFIG_NET_SOCKETS) |
| static inline u8_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_IPV6) |
| static inline u8_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, |
| u8_t len) |
| { |
| pkt->ipv6_ext_opt_len = len; |
| } |
| |
| static inline u8_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, u8_t len) |
| { |
| pkt->ipv6_ext_len = len; |
| } |
| |
| static inline u16_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, |
| u16_t offset) |
| { |
| pkt->ipv6_prev_hdr_start = offset; |
| } |
| |
| static inline u8_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, |
| u8_t hop_limit) |
| { |
| pkt->ipv6_hop_limit = hop_limit; |
| } |
| |
| #if defined(CONFIG_NET_IPV6_FRAGMENT) |
| static inline u8_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, |
| u8_t *start) |
| { |
| pkt->ipv6_frag_hdr_start = start; |
| } |
| |
| static inline u16_t net_pkt_ipv6_fragment_offset(struct net_pkt *pkt) |
| { |
| return pkt->ipv6_fragment_offset; |
| } |
| |
| static inline void net_pkt_set_ipv6_fragment_offset(struct net_pkt *pkt, |
| u16_t offset) |
| { |
| pkt->ipv6_fragment_offset = offset; |
| } |
| |
| static inline u32_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, |
| u32_t id) |
| { |
| pkt->ipv6_fragment_id = id; |
| } |
| #endif /* CONFIG_NET_IPV6_FRAGMENT */ |
| #else /* CONFIG_NET_IPV6 */ |
| #define net_pkt_ipv6_ext_len(...) 0 |
| #define net_pkt_set_ipv6_ext_len(...) |
| #endif /* CONFIG_NET_IPV6 */ |
| |
| static inline size_t net_pkt_get_len(struct net_pkt *pkt) |
| { |
| return net_buf_frags_len(pkt->frags); |
| } |
| |
| static inline u8_t *net_pkt_ip_data(struct net_pkt *pkt) |
| { |
| return pkt->frags->data; |
| } |
| |
| static inline u8_t *net_pkt_appdata(struct net_pkt *pkt) |
| { |
| return pkt->appdata; |
| } |
| |
| static inline void net_pkt_set_appdata(struct net_pkt *pkt, u8_t *data) |
| { |
| pkt->appdata = data; |
| } |
| |
| static inline u16_t net_pkt_appdatalen(struct net_pkt *pkt) |
| { |
| return pkt->appdatalen; |
| } |
| |
| static inline void net_pkt_set_appdatalen(struct net_pkt *pkt, u16_t len) |
| { |
| pkt->appdatalen = len; |
| } |
| |
| static inline u8_t net_pkt_ll_reserve(struct net_pkt *pkt) |
| { |
| return pkt->ll_reserve; |
| } |
| |
| static inline void net_pkt_set_ll_reserve(struct net_pkt *pkt, u8_t len) |
| { |
| pkt->ll_reserve = len; |
| } |
| |
| static inline u8_t *net_pkt_ll(struct net_pkt *pkt) |
| { |
| return net_pkt_ip_data(pkt) - net_pkt_ll_reserve(pkt); |
| } |
| |
| static inline struct net_linkaddr *net_pkt_ll_src(struct net_pkt *pkt) |
| { |
| return &pkt->lladdr_src; |
| } |
| |
| static inline struct net_linkaddr *net_pkt_ll_dst(struct net_pkt *pkt) |
| { |
| return &pkt->lladdr_dst; |
| } |
| |
| static inline void net_pkt_ll_clear(struct net_pkt *pkt) |
| { |
| memset(net_pkt_ll(pkt), 0, net_pkt_ll_reserve(pkt)); |
| net_pkt_ll_src(pkt)->addr = NULL; |
| net_pkt_ll_src(pkt)->len = 0; |
| } |
| |
| static inline void net_pkt_ll_swap(struct net_pkt *pkt) |
| { |
| u8_t *addr = net_pkt_ll_src(pkt)->addr; |
| |
| net_pkt_ll_src(pkt)->addr = net_pkt_ll_dst(pkt)->addr; |
| net_pkt_ll_dst(pkt)->addr = addr; |
| } |
| |
| #if defined(CONFIG_NET_L2_IEEE802154) |
| static inline u8_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, |
| u8_t rssi) |
| { |
| pkt->ieee802154_rssi = rssi; |
| } |
| #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)), |
| &NET_IPV6_HDR(pkt)->src); |
| } |
| |
| /* @endcond */ |
| |
| /** |
| * @brief Create a TX net_pkt slab that is used when sending user |
| * specified data to network. |
| * |
| * @param name Name of the pool. |
| * @param count Number of net_pkt in this slab. |
| */ |
| #define NET_PKT_TX_SLAB_DEFINE(name, count) \ |
| K_MEM_SLAB_DEFINE(name, sizeof(struct net_pkt), count, 4) |
| |
| /** |
| * @brief Create a DATA net_buf pool that is used when sending user |
| * specified data to network. |
| * |
| * @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, \ |
| CONFIG_NET_BUF_USER_DATA_SIZE, NULL) |
| |
| #if defined(CONFIG_NET_DEBUG_NET_PKT) |
| |
| /* Debug versions of the net_pkt functions that are used when tracking |
| * buffer usage. |
| */ |
| |
| struct net_pkt *net_pkt_get_reserve_debug(struct k_mem_slab *slab, |
| u16_t reserve_head, |
| s32_t timeout, |
| const char *caller, |
| int line); |
| #define net_pkt_get_reserve(slab, reserve_head, timeout) \ |
| net_pkt_get_reserve_debug(slab, reserve_head, timeout, \ |
| __func__, __LINE__) |
| |
| struct net_buf *net_pkt_get_reserve_data_debug(struct net_buf_pool *pool, |
| u16_t reserve_head, |
| s32_t timeout, |
| const char *caller, |
| int line); |
| |
| #define net_pkt_get_reserve_data(pool, reserve_head, timeout) \ |
| net_pkt_get_reserve_debug(pool, reserve_head, timeout, \ |
| __func__, __LINE__) |
| |
| struct net_pkt *net_pkt_get_rx_debug(struct net_context *context, |
| s32_t timeout, |
| const char *caller, int line); |
| #define net_pkt_get_rx(context, timeout) \ |
| net_pkt_get_rx_debug(context, timeout, __func__, __LINE__) |
| |
| struct net_pkt *net_pkt_get_tx_debug(struct net_context *context, |
| s32_t timeout, |
| const char *caller, int line); |
| #define net_pkt_get_tx(context, timeout) \ |
| net_pkt_get_tx_debug(context, timeout, __func__, __LINE__) |
| |
| struct net_buf *net_pkt_get_data_debug(struct net_context *context, |
| s32_t timeout, |
| const char *caller, int line); |
| #define net_pkt_get_data(context, timeout) \ |
| net_pkt_get_data_debug(context, timeout, __func__, __LINE__) |
| |
| struct net_pkt *net_pkt_get_reserve_rx_debug(u16_t reserve_head, |
| s32_t timeout, |
| const char *caller, int line); |
| #define net_pkt_get_reserve_rx(res, timeout) \ |
| net_pkt_get_reserve_rx_debug(res, timeout, __func__, __LINE__) |
| |
| struct net_pkt *net_pkt_get_reserve_tx_debug(u16_t reserve_head, |
| s32_t timeout, |
| const char *caller, int line); |
| #define net_pkt_get_reserve_tx(res, timeout) \ |
| net_pkt_get_reserve_tx_debug(res, timeout, __func__, __LINE__) |
| |
| struct net_buf *net_pkt_get_reserve_rx_data_debug(u16_t reserve_head, |
| s32_t timeout, |
| const char *caller, |
| int line); |
| #define net_pkt_get_reserve_rx_data(res, timeout) \ |
| net_pkt_get_reserve_rx_data_debug(res, timeout, __func__, __LINE__) |
| |
| struct net_buf *net_pkt_get_reserve_tx_data_debug(u16_t reserve_head, |
| s32_t timeout, |
| const char *caller, |
| int line); |
| #define net_pkt_get_reserve_tx_data(res, timeout) \ |
| net_pkt_get_reserve_tx_data_debug(res, timeout, __func__, __LINE__) |
| |
| struct net_buf *net_pkt_get_frag_debug(struct net_pkt *pkt, |
| s32_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__) |
| |
| /** |
| * @brief Print fragment list and the fragment sizes |
| * |
| * @details Only available if debugging is activated. |
| * |
| * @param pkt Network pkt. |
| */ |
| void net_pkt_print_frags(struct net_pkt *pkt); |
| |
| #else /* CONFIG_NET_DEBUG_NET_PKT */ |
| |
| #define net_pkt_print_frags(...) |
| |
| /** |
| * @brief Get packet from the given packet slab. |
| * |
| * @details Get network packet from the specific packet slab. |
| * |
| * @param slab Network packet slab. |
| * @param reserve_head How many bytes to reserve for headroom. |
| * @param timeout Affects the action taken should the net pkt slab be empty. |
| * If K_NO_WAIT, then return immediately. If K_FOREVER, then |
| * wait as long as necessary. Otherwise, wait up to the specified |
| * number of milliseconds before timing out. |
| * |
| * @return Network packet if successful, NULL otherwise. |
| */ |
| struct net_pkt *net_pkt_get_reserve(struct k_mem_slab *slab, |
| u16_t reserve_head, |
| s32_t timeout); |
| |
| /** |
| * @brief Get packet from the RX packet slab. |
| * |
| * @details Get network packet from RX packet slab. You must have |
| * network context before able to use this function. |
| * |
| * @param context Network context that will be related to this packet. |
| * @param timeout Affects the action taken should the net pkt slab be empty. |
| * If K_NO_WAIT, then return immediately. If K_FOREVER, then |
| * wait as long as necessary. Otherwise, wait up to the specified |
| * number of milliseconds before timing out. |
| * |
| * @return Network packet if successful, NULL otherwise. |
| */ |
| struct net_pkt *net_pkt_get_rx(struct net_context *context, |
| s32_t timeout); |
| |
| /** |
| * @brief Get packet from the TX packets slab. |
| * |
| * @details Get network packet from TX packet slab. You must have |
| * network context before able to use this function. |
| * |
| * @param context Network context that will be related to |
| * this packet. |
| * @param timeout Affects the action taken should the net pkt slab be empty. |
| * If K_NO_WAIT, then return immediately. If K_FOREVER, then |
| * wait as long as necessary. Otherwise, wait up to the specified |
| * number of milliseconds before timing out. |
| * |
| * @return Network packet if successful, NULL otherwise. |
| */ |
| struct net_pkt *net_pkt_get_tx(struct net_context *context, |
| s32_t timeout); |
| |
| /** |
| * @brief Get buffer from the DATA buffers pool. |
| * |
| * @details Get network buffer from DATA buffer pool. You must have |
| * network context before able to use this function. |
| * |
| * @param context Network context that will be related to |
| * this buffer. |
| * @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 |
| * number of milliseconds before timing out. |
| * |
| * @return Network buffer if successful, NULL otherwise. |
| */ |
| struct net_buf *net_pkt_get_data(struct net_context *context, |
| s32_t timeout); |
| |
| /** |
| * @brief Get RX packet from slab but also reserve headroom for |
| * potential headers. |
| * |
| * @details Normally this version is not useful for applications |
| * but is mainly used by network fragmentation code. |
| * |
| * @param reserve_head How many bytes to reserve for headroom. |
| * @param timeout Affects the action taken should the net pkt slab be empty. |
| * If K_NO_WAIT, then return immediately. If K_FOREVER, then |
| * wait as long as necessary. Otherwise, wait up to the specified |
| * number of milliseconds before timing out. |
| * |
| * @return Network packet if successful, NULL otherwise. |
| */ |
| struct net_pkt *net_pkt_get_reserve_rx(u16_t reserve_head, |
| s32_t timeout); |
| |
| /** |
| * @brief Get TX packet from slab but also reserve headroom for |
| * potential headers. |
| * |
| * @details Normally this version is not useful for applications |
| * but is mainly used by network fragmentation code. |
| * |
| * @param reserve_head How many bytes to reserve for headroom. |
| * @param timeout Affects the action taken should the net pkt slab be empty. |
| * If K_NO_WAIT, then return immediately. If K_FOREVER, then |
| * wait as long as necessary. Otherwise, wait up to the specified |
| * number of milliseconds before timing out. |
| * |
| * @return Network packet if successful, NULL otherwise. |
| */ |
| struct net_pkt *net_pkt_get_reserve_tx(u16_t reserve_head, |
| s32_t timeout); |
| |
| /** |
| * @brief Get RX DATA buffer from pool but also reserve headroom for |
| * potential headers. 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 reserve_head How many bytes to reserve for headroom. |
| * @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 |
| * number of milliseconds before timing out. |
| * |
| * @return Network buffer if successful, NULL otherwise. |
| */ |
| struct net_buf *net_pkt_get_reserve_rx_data(u16_t reserve_head, |
| s32_t timeout); |
| |
| /** |
| * @brief Get TX DATA buffer from pool but also reserve headroom for |
| * potential headers. 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 reserve_head How many bytes to reserve for headroom. |
| * @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 |
| * number of milliseconds before timing out. |
| * |
| * @return Network buffer if successful, NULL otherwise. |
| */ |
| struct net_buf *net_pkt_get_reserve_tx_data(u16_t reserve_head, |
| s32_t timeout); |
| |
| /** |
| * @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 |
| * number of milliseconds before timing out. |
| * |
| * @return Network buffer if successful, NULL otherwise. |
| */ |
| struct net_buf *net_pkt_get_frag(struct net_pkt *pkt, s32_t timeout); |
| |
| /** |
| * @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. |
| * |
| */ |
| void net_pkt_unref(struct net_pkt *pkt); |
| |
| /** |
| * @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. |
| */ |
| struct net_pkt *net_pkt_ref(struct net_pkt *pkt); |
| |
| /** |
| * @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. |
| */ |
| struct net_buf *net_pkt_frag_ref(struct net_buf *frag); |
| |
| /** |
| * @brief Decrease the packet fragment ref count |
| * |
| * @param frag Network fragment to unref. |
| */ |
| void net_pkt_frag_unref(struct net_buf *frag); |
| |
| /** |
| * @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. |
| */ |
| struct net_buf *net_pkt_frag_del(struct net_pkt *pkt, |
| struct net_buf *parent, |
| struct net_buf *frag); |
| |
| /** |
| * @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 |
| */ |
| void net_pkt_frag_add(struct net_pkt *pkt, struct net_buf *frag); |
| |
| /** |
| * @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 |
| */ |
| void net_pkt_frag_insert(struct net_pkt *pkt, struct net_buf *frag); |
| |
| #endif /* CONFIG_NET_DEBUG_NET_PKT */ |
| |
| /** |
| * @brief Copy a packet fragment list while reserving some extra space |
| * in destination buffer before a copy. |
| * |
| * @param pkt Network packet. |
| * @param amount Max amount of data to be copied. |
| * @param reserve Amount of extra data (this is not link layer header) in the |
| * first data fragment that is returned. The function will copy the original |
| * buffer right after the reserved bytes in the first destination fragment. |
| * @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 |
| * number of milliseconds before timing out. |
| * |
| * @return New fragment list if successful, NULL otherwise. |
| */ |
| struct net_buf *net_pkt_copy(struct net_pkt *pkt, size_t amount, |
| size_t reserve, s32_t timeout); |
| |
| /** |
| * @brief Copy a packet fragment list while reserving some extra space |
| * in destination buffer before a copy. |
| * |
| * @param pkt Network packet. |
| * @param reserve Amount of extra data (this is not link layer header) in the |
| * first data fragment that is returned. The function will copy the original |
| * buffer right after the reserved bytes in the first destination fragment. |
| * @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 |
| * number of milliseconds before timing out. |
| * |
| * @return New fragment list if successful, NULL otherwise. |
| */ |
| static inline struct net_buf *net_pkt_copy_all(struct net_pkt *pkt, |
| size_t reserve, |
| s32_t timeout) |
| { |
| return net_pkt_copy(pkt, net_buf_frags_len(pkt->frags), |
| reserve, timeout); |
| } |
| |
| /** |
| * @brief Copy len bytes from src starting from offset to dst |
| * |
| * This routine assumes that dst is formed of one fragment with enough space |
| * to store @a len bytes starting from offset at src. |
| * |
| * @param dst Destination buffer |
| * @param src Source buffer that may be fragmented |
| * @param offset Starting point to copy from |
| * @param len Number of bytes to copy |
| * @return 0 on success |
| * @return -ENOMEM on error |
| */ |
| int net_frag_linear_copy(struct net_buf *dst, struct net_buf *src, |
| u16_t offset, u16_t len); |
| |
| /** |
| * @brief Copy len bytes from src starting from offset to dst buffer |
| * |
| * This routine assumes that dst is large enough to store @a len bytes |
| * starting from offset at src. |
| * |
| * @param dst Destination buffer |
| * @param dst_len Destination buffer max length |
| * @param src Source buffer that may be fragmented |
| * @param offset Starting point to copy from |
| * @param len Number of bytes to copy |
| * @return number of bytes copied if everything is ok |
| * @return -ENOMEM on error |
| */ |
| int net_frag_linearize(u8_t *dst, size_t dst_len, |
| struct net_pkt *src, u16_t offset, u16_t len); |
| |
| /** |
| * @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 Append data to fragment list of a packet |
| * |
| * @details Append data to last fragment. If there is not enough space in |
| * last fragment then more data fragments will be added, unless there are |
| * no free fragments and timeout occurs. |
| * |
| * @param pkt Network packet. |
| * @param len Total length of input data |
| * @param data Data to be added |
| * @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 |
| * number of milliseconds before timing out. |
| * |
| * @return Length of data actually added. This may be less than input |
| * length if other timeout than K_FOREVER was used, and there |
| * were no free fragments in a pool to accommodate all data. |
| */ |
| u16_t net_pkt_append(struct net_pkt *pkt, u16_t len, const u8_t *data, |
| s32_t timeout); |
| |
| /** |
| * @brief Append all data to fragment list of a packet (or fail) |
| * |
| * @details Append data to last fragment. If there is not enough space in |
| * last fragment then more data fragments will be added. Return unsuccessful |
| * status if there are no free fragments to accommodate all data and timeout |
| * occurs. |
| * |
| * @param pkt Network packet. |
| * @param len Total length of input data |
| * @param data Data to be added |
| * @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 |
| * number of milliseconds before timing out. |
| * |
| * @return True if all the data is placed at end of fragment list, |
| * false otherwise (in which case packet may contain incomplete |
| * input data). |
| */ |
| static inline bool net_pkt_append_all(struct net_pkt *pkt, u16_t len, |
| const u8_t *data, s32_t timeout) |
| { |
| return net_pkt_append(pkt, len, data, timeout) == len; |
| } |
| |
| /** |
| * @brief Append u8_t data to last fragment in fragment list of a packet |
| * |
| * @details Append data to last fragment. If there is not enough space in last |
| * fragment then new data fragment will be created and will be added to |
| * fragment list. Caller has to take care of endianness if needed. |
| * |
| * @param pkt Network packet. |
| * @param data Data to be added |
| * |
| * @return True if all the data is placed at end of fragment list, |
| * False otherwise (In-case of false pkt might contain input |
| * data in the process of placing into fragments). |
| */ |
| static inline bool net_pkt_append_u8(struct net_pkt *pkt, u8_t data) |
| { |
| return net_pkt_append_all(pkt, 1, &data, K_FOREVER); |
| } |
| |
| /** |
| * @brief Append u16_t data to last fragment in fragment list of a packet |
| * |
| * @details Append data to last fragment. If there is not enough space in last |
| * fragment then new data fragment will be created and will be added to |
| * fragment list. Caller has to take care of endianness if needed. |
| * |
| * @param pkt Network packet. |
| * @param data Data to be added |
| * |
| * @return True if all the data is placed at end of fragment list, |
| * False otherwise (In-case of false pkt might contain input data |
| * in the process of placing into fragments). |
| */ |
| static inline bool net_pkt_append_be16(struct net_pkt *pkt, u16_t data) |
| { |
| u16_t value = sys_cpu_to_be16(data); |
| |
| return net_pkt_append_all(pkt, sizeof(u16_t), (u8_t *)&value, |
| K_FOREVER); |
| } |
| |
| /** |
| * @brief Append u32_t data to last fragment in fragment list of a packet |
| * |
| * @details Append data to last fragment. If there is not enough space in last |
| * fragment then new data fragment will be created and will be added to |
| * fragment list. Caller has to take care of endianness if needed. |
| * |
| * @param pkt Network packet. |
| * @param data Data to be added |
| * |
| * @return True if all the data is placed at end of fragment list, |
| * False otherwise (In-case of false pkt might contain input data |
| * in the process of placing into fragments). |
| */ |
| static inline bool net_pkt_append_be32(struct net_pkt *pkt, u32_t data) |
| { |
| u32_t value = sys_cpu_to_be32(data); |
| |
| return net_pkt_append_all(pkt, sizeof(u32_t), (u8_t *)&value, |
| K_FOREVER); |
| } |
| |
| /** |
| * @brief Append u32_t data to last fragment in fragment list |
| * |
| * @details Append data to last fragment. If there is not enough space in last |
| * fragment then new data fragment will be created and will be added to |
| * fragment list. Convert data to LE. |
| * |
| * @param pkt Network packet fragment list. |
| * @param data Data to be added |
| * |
| * @return True if all the data is placed at end of fragment list, |
| * False otherwise (In-case of false pkt might contain input data |
| * in the process of placing into fragments). |
| */ |
| static inline bool net_pkt_append_le32(struct net_pkt *pkt, u32_t data) |
| { |
| u32_t value = sys_cpu_to_le32(data); |
| |
| return net_pkt_append_all(pkt, sizeof(u32_t), (u8_t *)&value, |
| K_FOREVER); |
| } |
| |
| /** |
| * @brief Get data from buffer |
| * |
| * @details Get N number of bytes starting from fragment's offset. If the total |
| * length of data is placed in multiple fragments, this function will read from |
| * all fragments until it reaches N number of bytes. Caller has to take care of |
| * endianness if needed. |
| * |
| * @param frag Network buffer fragment. |
| * @param offset Offset of input buffer. |
| * @param pos Pointer to position of offset after reading n number of bytes, |
| * this is with respect to return buffer(fragment). |
| * @param len Total length of data to be read. |
| * @param data Data will be copied here. |
| * |
| * @return Pointer to the fragment or |
| * NULL and pos is 0 after successful read, |
| * NULL and pos is 0xffff otherwise. |
| */ |
| struct net_buf *net_frag_read(struct net_buf *frag, u16_t offset, |
| u16_t *pos, u16_t len, u8_t *data); |
| |
| /** |
| * @brief Skip N number of bytes while reading buffer |
| * |
| * @details Skip N number of bytes starting from fragment's offset. If the total |
| * length of data is placed in multiple fragments, this function will skip from |
| * all fragments until it reaches N number of bytes. This function is useful |
| * when unwanted data (e.g. reserved or not supported data in message) is part |
| * of fragment and want to skip it. |
| * |
| * @param frag Network buffer fragment. |
| * @param offset Offset of input buffer. |
| * @param pos Pointer to position of offset after reading n number of bytes, |
| * this is with respect to return buffer(fragment). |
| * @param len Total length of data to be read. |
| * |
| * @return Pointer to the fragment or |
| * NULL and pos is 0 after successful skip, |
| * NULL and pos is 0xffff otherwise. |
| */ |
| static inline struct net_buf *net_frag_skip(struct net_buf *frag, |
| u16_t offset, |
| u16_t *pos, u16_t len) |
| { |
| return net_frag_read(frag, offset, pos, len, NULL); |
| } |
| |
| /** |
| * @brief Get a byte value from fragmented buffer |
| * |
| * @param frag Network buffer fragment. |
| * @param offset Offset of input buffer. |
| * @param pos Pointer to position of offset after reading 2 bytes, |
| * this is with respect to return buffer(fragment). |
| * @param value Value is returned |
| * |
| * @return Pointer to fragment after successful read, |
| * NULL otherwise (if pos is 0, NULL is not a failure case). |
| */ |
| static inline struct net_buf *net_frag_read_u8(struct net_buf *frag, |
| u16_t offset, |
| u16_t *pos, |
| u8_t *value) |
| { |
| return net_frag_read(frag, offset, pos, 1, value); |
| } |
| |
| /** |
| * @brief Get 16 bit big endian value from fragmented buffer |
| * |
| * @param frag Network buffer fragment. |
| * @param offset Offset of input buffer. |
| * @param pos Pointer to position of offset after reading 2 bytes, |
| * this is with respect to return buffer(fragment). |
| * @param value Value is returned |
| * |
| * @return Pointer to fragment after successful read, |
| * NULL otherwise (if pos is 0, NULL is not a failure case). |
| */ |
| struct net_buf *net_frag_read_be16(struct net_buf *frag, u16_t offset, |
| u16_t *pos, u16_t *value); |
| |
| /** |
| * @brief Get 32 bit big endian value from fragmented buffer |
| * |
| * @param frag Network buffer fragment. |
| * @param offset Offset of input buffer. |
| * @param pos Pointer to position of offset after reading 4 bytes, |
| * this is with respect to return buffer(fragment). |
| * @param value Value is returned |
| * |
| * @return Pointer to fragment after successful read, |
| * NULL otherwise (if pos is 0, NULL is not a failure case). |
| */ |
| struct net_buf *net_frag_read_be32(struct net_buf *frag, u16_t offset, |
| u16_t *pos, u32_t *value); |
| |
| /** |
| * @brief Write data to an arbitrary offset in fragments list of a packet. |
| * |
| * @details Write data to an arbitrary offset in a series of fragments. |
| * Offset is based on fragment 'size' and calculates from input fragment |
| * starting position. |
| * |
| * Size in this context refers the fragment full size without link layer header |
| * part. The fragment might have user written data in it, the amount of such |
| * data is stored in frag->len variable (the frag->len is always <= frag->size). |
| * If using this API, the tailroom in the fragments will be taken into use. |
| * |
| * If offset is more than already allocated length in fragment, then empty space |
| * or extra empty fragments is created to reach proper offset. |
| * If there is any data present on input fragment offset, then it will be |
| * 'overwritten'. Use net_pkt_insert() api if you don't want to overwrite. |
| * |
| * Offset is calculated from starting point of data area in input fragment. |
| * e.g. Pkt(Tx/Rx) - Frag1 - Frag2 - Frag3 - Frag4 |
| * (Assume FRAG DATA SIZE is 100 bytes after link layer header) |
| * |
| * 1) net_pkt_write(pkt, frag2, 20, &pos, 20, data, K_FOREVER) |
| * In this case write starts from "frag2->data + 20", |
| * returns frag2, pos = 40 |
| * |
| * 2) net_pkt_write(pkt, frag1, 150, &pos, 60, data, K_FOREVER) |
| * In this case write starts from "frag2->data + 50" |
| * returns frag3, pos = 10 |
| * |
| * 3) net_pkt_write(pkt, frag1, 350, &pos, 30, data, K_FOREVER) |
| * In this case write starts from "frag4->data + 50" |
| * returns frag4, pos = 80 |
| * |
| * 4) net_pkt_write(pkt, frag2, 110, &pos, 90, data, K_FOREVER) |
| * In this case write starts from "frag3->data + 10" |
| * returns frag4, pos = 0 |
| * |
| * 5) net_pkt_write(pkt, frag4, 110, &pos, 20, data, K_FOREVER) |
| * In this case write creates new data fragment and starts from |
| * "frag5->data + 10" |
| * returns frag5, pos = 30 |
| * |
| * If input argument frag is NULL, it will create new data fragment |
| * and append at the end of fragment list. |
| * |
| * @param pkt Network packet. |
| * @param frag Network buffer fragment. |
| * @param offset Offset |
| * @param pos Position of offset after write completed (this will be |
| * relative to return fragment) |
| * @param len Length of the data to be written. |
| * @param data Data to be written |
| * @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 |
| * number of milliseconds before timing out. |
| * |
| * @return Pointer to the fragment and position (*pos) where write ended, |
| * NULL and pos is 0xffff otherwise. |
| */ |
| struct net_buf *net_pkt_write(struct net_pkt *pkt, struct net_buf *frag, |
| u16_t offset, u16_t *pos, u16_t len, |
| u8_t *data, s32_t timeout); |
| |
| /* Write u8_t data to an arbitrary offset in fragment. */ |
| static inline struct net_buf *net_pkt_write_u8(struct net_pkt *pkt, |
| struct net_buf *frag, |
| u16_t offset, |
| u16_t *pos, |
| u8_t data) |
| { |
| return net_pkt_write(pkt, frag, offset, pos, sizeof(u8_t), |
| &data, K_FOREVER); |
| } |
| |
| /* Write u16_t big endian value to an arbitrary offset in fragment. */ |
| static inline struct net_buf *net_pkt_write_be16(struct net_pkt *pkt, |
| struct net_buf *frag, |
| u16_t offset, |
| u16_t *pos, |
| u16_t data) |
| { |
| u16_t value = htons(data); |
| |
| return net_pkt_write(pkt, frag, offset, pos, sizeof(u16_t), |
| (u8_t *)&value, K_FOREVER); |
| } |
| |
| /* Write u32_t big endian value to an arbitrary offset in fragment. */ |
| static inline struct net_buf *net_pkt_write_be32(struct net_pkt *pkt, |
| struct net_buf *frag, |
| u16_t offset, |
| u16_t *pos, |
| u32_t data) |
| { |
| u32_t value = htonl(data); |
| |
| return net_pkt_write(pkt, frag, offset, pos, sizeof(u32_t), |
| (u8_t *)&value, K_FOREVER); |
| } |
| |
| /** |
| * @brief Insert data at an arbitrary offset in a series of fragments. |
| * |
| * @details Insert data at an arbitrary offset in a series of fragments. Offset |
| * is based on fragment length (only user written data length, any tailroom |
| * in fragments does not come to consideration unlike net_pkt_write()) and |
| * calculates from input fragment starting position. |
| * |
| * Offset examples can be considered from net_pkt_write() api. |
| * If the offset is more than already allocated fragments length then it is an |
| * error case. |
| * |
| * @param pkt Network packet. |
| * @param frag Network buffer fragment. |
| * @param offset Offset of fragment where insertion will start. |
| * @param len Length of the data to be inserted. |
| * @param data Data to be inserted |
| * @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 |
| * number of milliseconds before timing out. |
| * |
| * @return True on success, False otherwise. |
| */ |
| bool net_pkt_insert(struct net_pkt *pkt, struct net_buf *frag, |
| u16_t offset, u16_t len, u8_t *data, |
| s32_t timeout); |
| |
| /* Insert u8_t data at an arbitrary offset in a series of fragments. */ |
| static inline bool net_pkt_insert_u8(struct net_pkt *pkt, |
| struct net_buf *frag, |
| u16_t offset, |
| u8_t data) |
| { |
| return net_pkt_insert(pkt, frag, offset, sizeof(u8_t), &data, |
| K_FOREVER); |
| } |
| |
| /* Insert u16_t big endian value at an arbitrary offset in a series of |
| * fragments. |
| */ |
| static inline bool net_pkt_insert_be16(struct net_pkt *pkt, |
| struct net_buf *frag, |
| u16_t offset, |
| u16_t data) |
| { |
| u16_t value = htons(data); |
| |
| return net_pkt_insert(pkt, frag, offset, sizeof(u16_t), |
| (u8_t *)&value, K_FOREVER); |
| } |
| |
| /* Insert u32_t big endian value at an arbitrary offset in a series of |
| * fragments. |
| */ |
| static inline bool net_pkt_insert_be32(struct net_pkt *pkt, |
| struct net_buf *frag, |
| u16_t offset, |
| u32_t data) |
| { |
| u32_t value = htonl(data); |
| |
| return net_pkt_insert(pkt, frag, offset, sizeof(u32_t), |
| (u8_t *)&value, K_FOREVER); |
| } |
| |
| /** |
| * @brief Split a fragment to two parts at arbitrary offset. |
| * |
| * @details This will generate two new fragments (fragA and fragB) from |
| * one (orig_frag). The original fragment is not modified but two new |
| * fragments are allocated and returned to the caller. The original fragment |
| * must be part of the packet pointed by the pkt parameter. If the len parameter |
| * is larger than the amount of data in the orig fragment, then the fragA will |
| * contain all the data and fragB will be empty. |
| * |
| * @param pkt Network packet |
| * @param orig_frag Original network buffer fragment which is to be split. |
| * @param len Amount of data in the first returned fragment. |
| * @param fragA A fragment is returned. This will contain len bytes that |
| * are copied from start of orig_frag. |
| * @param fragB Another fragment is returned. This will contain remaining |
| * bytes (orig_frag->len - len) from the orig_frag or NULL if all the data |
| * was copied into fragA. |
| * @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 number of milliseconds before |
| * timing out. |
| * |
| * @return 0 on success, <0 otherwise. |
| */ |
| int net_pkt_split(struct net_pkt *pkt, struct net_buf *orig_frag, |
| u16_t len, struct net_buf **fragA, |
| struct net_buf **fragB, s32_t timeout); |
| |
| /** |
| * @brief Return the fragment and offset within it according to network |
| * packet offset. |
| * |
| * @details This is typically used to get the protocol header pointer when |
| * we know the offset. According to this information, the corresponding fragment |
| * and position within that fragment is returned. |
| * |
| * @param pkt Network packet |
| * @param offset Offset of desired location in network packet. For example, if |
| * we want to know where UDP header is located after the IPv6 header, |
| * the offset could have a value of sizeof(struct net_ipv6_hdr). Note that this |
| * is a simplified example that does not take into account the possible IPv6 |
| * extension headers. |
| * @param pos Pointer to position within result fragment corresponding to |
| * offset param. For example, if the IPv6 header is split between two fragments, |
| * then if we want to know the start of UDP header, the returned pos variable |
| * would indicate how many bytes from second fragment the UDP header starts. |
| * |
| * @return Pointer to the fragment where the the offset is located or |
| * NULL if there is not enough bytes in the packet |
| */ |
| struct net_buf *net_frag_get_pos(struct net_pkt *pkt, |
| u16_t offset, |
| u16_t *pos); |
| |
| /** |
| * @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); |
| |
| #if defined(CONFIG_NET_DEBUG_NET_PKT) |
| /** |
| * @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 */ |
| |
| /** |
| * @} |
| */ |
| |
| #ifdef __cplusplus |
| } |
| #endif |
| |
| #endif /* __NET_PKT_H__ */ |