buf.h

Go to the documentation of this file.

 
/*
 * Copyright (c) 2015 Intel Corporation
 *
 * SPDX-License-Identifier: Apache-2.0
 */
#ifndef ZEPHYR_INCLUDE_NET_BUF_H_
#define ZEPHYR_INCLUDE_NET_BUF_H_
 
#include <stddef.h>
#include <zephyr/types.h>
#include <sys/util.h>
#include <zephyr.h>
 
#ifndef CONFIG_NET_BUF_USER_DATA_SIZE
#define CONFIG_NET_BUF_USER_DATA_SIZE 0
#endif
 
#ifdef __cplusplus
extern "C" {
#endif
 
/* Alignment needed for various parts of the buffer definition */
#define __net_buf_align __aligned(sizeof(void *))
 
#define NET_BUF_SIMPLE_DEFINE(_name, _size)     \
        uint8_t net_buf_data_##_name[_size];       \
        struct net_buf_simple _name = {         \
                .data   = net_buf_data_##_name, \
                .len    = 0,                    \
                .size   = _size,                \
                .__buf  = net_buf_data_##_name, \
        }
 
#define NET_BUF_SIMPLE_DEFINE_STATIC(_name, _size)        \
        static __noinit uint8_t net_buf_data_##_name[_size]; \
        static struct net_buf_simple _name = {            \
                .data   = net_buf_data_##_name,           \
                .len    = 0,                              \
                .size   = _size,                          \
                .__buf  = net_buf_data_##_name,           \
        }
 
struct net_buf_simple {
        uint8_t *data;
 
        uint16_t len;
 
        uint16_t size;
 
        uint8_t *__buf;
};
 
#define NET_BUF_SIMPLE(_size)                        \
        ((struct net_buf_simple *)(&(struct {        \
                struct net_buf_simple buf;           \
                uint8_t data[_size];                 \
        }) {                                         \
                .buf.size = _size,                   \
        }))
 
static inline void net_buf_simple_init(struct net_buf_simple *buf,
                                       size_t reserve_head)
{
        if (!buf->__buf) {
                buf->__buf = (uint8_t *)buf + sizeof(*buf);
        }
 
        buf->data = buf->__buf + reserve_head;
        buf->len = 0U;
}
 
void net_buf_simple_init_with_data(struct net_buf_simple *buf,
                                   void *data, size_t size);
 
static inline void net_buf_simple_reset(struct net_buf_simple *buf)
{
        buf->len  = 0U;
        buf->data = buf->__buf;
}
 
void net_buf_simple_clone(const struct net_buf_simple *original,
                          struct net_buf_simple *clone);
 
void *net_buf_simple_add(struct net_buf_simple *buf, size_t len);
 
void *net_buf_simple_add_mem(struct net_buf_simple *buf, const void *mem,
                             size_t len);
 
uint8_t *net_buf_simple_add_u8(struct net_buf_simple *buf, uint8_t val);
 
void net_buf_simple_add_le16(struct net_buf_simple *buf, uint16_t val);
 
void net_buf_simple_add_be16(struct net_buf_simple *buf, uint16_t val);
 
void net_buf_simple_add_le24(struct net_buf_simple *buf, uint32_t val);
 
void net_buf_simple_add_be24(struct net_buf_simple *buf, uint32_t val);
 
void net_buf_simple_add_le32(struct net_buf_simple *buf, uint32_t val);
 
void net_buf_simple_add_be32(struct net_buf_simple *buf, uint32_t val);
 
void net_buf_simple_add_le48(struct net_buf_simple *buf, uint64_t val);
 
void net_buf_simple_add_be48(struct net_buf_simple *buf, uint64_t val);
 
void net_buf_simple_add_le64(struct net_buf_simple *buf, uint64_t val);
 
void net_buf_simple_add_be64(struct net_buf_simple *buf, uint64_t val);
 
void *net_buf_simple_remove_mem(struct net_buf_simple *buf, size_t len);
 
uint8_t net_buf_simple_remove_u8(struct net_buf_simple *buf);
 
uint16_t net_buf_simple_remove_le16(struct net_buf_simple *buf);
 
uint16_t net_buf_simple_remove_be16(struct net_buf_simple *buf);
 
uint32_t net_buf_simple_remove_le24(struct net_buf_simple *buf);
 
uint32_t net_buf_simple_remove_be24(struct net_buf_simple *buf);
 
uint32_t net_buf_simple_remove_le32(struct net_buf_simple *buf);
 
uint32_t net_buf_simple_remove_be32(struct net_buf_simple *buf);
 
uint64_t net_buf_simple_remove_le48(struct net_buf_simple *buf);
 
uint64_t net_buf_simple_remove_be48(struct net_buf_simple *buf);
 
uint64_t net_buf_simple_remove_le64(struct net_buf_simple *buf);
 
uint64_t net_buf_simple_remove_be64(struct net_buf_simple *buf);
 
void *net_buf_simple_push(struct net_buf_simple *buf, size_t len);
 
void *net_buf_simple_push_mem(struct net_buf_simple *buf, const void *mem,
                              size_t len);
 
void net_buf_simple_push_le16(struct net_buf_simple *buf, uint16_t val);
 
void net_buf_simple_push_be16(struct net_buf_simple *buf, uint16_t val);
 
void net_buf_simple_push_u8(struct net_buf_simple *buf, uint8_t val);
 
void net_buf_simple_push_le24(struct net_buf_simple *buf, uint32_t val);
 
void net_buf_simple_push_be24(struct net_buf_simple *buf, uint32_t val);
 
void net_buf_simple_push_le32(struct net_buf_simple *buf, uint32_t val);
 
void net_buf_simple_push_be32(struct net_buf_simple *buf, uint32_t val);
 
void net_buf_simple_push_le48(struct net_buf_simple *buf, uint64_t val);
 
void net_buf_simple_push_be48(struct net_buf_simple *buf, uint64_t val);
 
void net_buf_simple_push_le64(struct net_buf_simple *buf, uint64_t val);
 
void net_buf_simple_push_be64(struct net_buf_simple *buf, uint64_t val);
 
void *net_buf_simple_pull(struct net_buf_simple *buf, size_t len);
 
void *net_buf_simple_pull_mem(struct net_buf_simple *buf, size_t len);
 
uint8_t net_buf_simple_pull_u8(struct net_buf_simple *buf);
 
uint16_t net_buf_simple_pull_le16(struct net_buf_simple *buf);
 
uint16_t net_buf_simple_pull_be16(struct net_buf_simple *buf);
 
uint32_t net_buf_simple_pull_le24(struct net_buf_simple *buf);
 
uint32_t net_buf_simple_pull_be24(struct net_buf_simple *buf);
 
uint32_t net_buf_simple_pull_le32(struct net_buf_simple *buf);
 
uint32_t net_buf_simple_pull_be32(struct net_buf_simple *buf);
 
uint64_t net_buf_simple_pull_le48(struct net_buf_simple *buf);
 
uint64_t net_buf_simple_pull_be48(struct net_buf_simple *buf);
 
uint64_t net_buf_simple_pull_le64(struct net_buf_simple *buf);
 
uint64_t net_buf_simple_pull_be64(struct net_buf_simple *buf);
 
static inline uint8_t *net_buf_simple_tail(struct net_buf_simple *buf)
{
        return buf->data + buf->len;
}
 
size_t net_buf_simple_headroom(struct net_buf_simple *buf);
 
size_t net_buf_simple_tailroom(struct net_buf_simple *buf);
 
uint16_t net_buf_simple_max_len(struct net_buf_simple *buf);
 
struct net_buf_simple_state {
        uint16_t offset;
        uint16_t len;
};
 
static inline void net_buf_simple_save(struct net_buf_simple *buf,
                                       struct net_buf_simple_state *state)
{
        state->offset = net_buf_simple_headroom(buf);
        state->len = buf->len;
}
 
static inline void net_buf_simple_restore(struct net_buf_simple *buf,
                                          struct net_buf_simple_state *state)
{
        buf->data = buf->__buf + state->offset;
        buf->len = state->len;
}
 
#define NET_BUF_FRAGS        BIT(0)
#define NET_BUF_EXTERNAL_DATA  BIT(1)
 
struct net_buf {
        union {
                sys_snode_t node;
 
                struct net_buf *frags;
        };
 
        uint8_t ref;
 
        uint8_t flags;
 
        uint8_t pool_id;
 
        /* Union for convenience access to the net_buf_simple members, also
         * preserving the old API.
         */
        union {
                /* The ABI of this struct must match net_buf_simple */
                struct {
                        uint8_t *data;
 
                        uint16_t len;
 
                        uint16_t size;
 
                        uint8_t *__buf;
                };
 
                struct net_buf_simple b;
        };
 
        uint8_t user_data[CONFIG_NET_BUF_USER_DATA_SIZE] __net_buf_align;
};
 
struct net_buf_data_cb {
        uint8_t * (*alloc)(struct net_buf *buf, size_t *size,
                           k_timeout_t timeout);
        uint8_t * (*ref)(struct net_buf *buf, uint8_t *data);
        void   (*unref)(struct net_buf *buf, uint8_t *data);
};
 
struct net_buf_data_alloc {
        const struct net_buf_data_cb *cb;
        void *alloc_data;
};
 
struct net_buf_pool {
        struct k_lifo free;
 
        const uint16_t buf_count;
 
        uint16_t uninit_count;
 
#if defined(CONFIG_NET_BUF_POOL_USAGE)
        atomic_t avail_count;
 
        const uint16_t pool_size;
 
        const char *name;
#endif /* CONFIG_NET_BUF_POOL_USAGE */
 
        void (*const destroy)(struct net_buf *buf);
 
        const struct net_buf_data_alloc *alloc;
 
        struct net_buf * const __bufs;
};
 
#if defined(CONFIG_NET_BUF_POOL_USAGE)
#define NET_BUF_POOL_INITIALIZER(_pool, _alloc, _bufs, _count, _destroy) \
        {                                                                    \
                .free = Z_LIFO_INITIALIZER(_pool.free),                      \
                .buf_count = _count,                                         \
                .uninit_count = _count,                                      \
                .avail_count = ATOMIC_INIT(_count),                          \
                .name = STRINGIFY(_pool),                                    \
                .destroy = _destroy,                                         \
                .alloc = _alloc,                                             \
                .__bufs = _bufs,                                             \
        }
#else
#define NET_BUF_POOL_INITIALIZER(_pool, _alloc, _bufs, _count, _destroy)     \
        {                                                                    \
                .free = Z_LIFO_INITIALIZER(_pool.free),                      \
                .buf_count = _count,                                         \
                .uninit_count = _count,                                      \
                .destroy = _destroy,                                         \
                .alloc = _alloc,                                             \
                .__bufs = _bufs,                                             \
        }
#endif /* CONFIG_NET_BUF_POOL_USAGE */
 
extern const struct net_buf_data_alloc net_buf_heap_alloc;
#define NET_BUF_POOL_HEAP_DEFINE(_name, _count, _destroy)                     \
        static struct net_buf net_buf_##_name[_count] __noinit;               \
        static struct net_buf_pool _name __net_buf_align                      \
                        __in_section(_net_buf_pool, static, _name) =          \
                NET_BUF_POOL_INITIALIZER(_name, &net_buf_heap_alloc,          \
                                         net_buf_##_name, _count, _destroy)
 
struct net_buf_pool_fixed {
        size_t data_size;
        uint8_t *data_pool;
};
 
extern const struct net_buf_data_cb net_buf_fixed_cb;
#define NET_BUF_POOL_FIXED_DEFINE(_name, _count, _data_size, _destroy)        \
        static struct net_buf net_buf_##_name[_count] __noinit;               \
        static uint8_t __noinit net_buf_data_##_name[_count][_data_size];     \
        static const struct net_buf_pool_fixed net_buf_fixed_##_name = {      \
                .data_size = _data_size,                                      \
                .data_pool = (uint8_t *)net_buf_data_##_name,                 \
        };                                                                    \
        static const struct net_buf_data_alloc net_buf_fixed_alloc_##_name = {\
                .cb = &net_buf_fixed_cb,                                      \
                .alloc_data = (void *)&net_buf_fixed_##_name,                 \
        };                                                                    \
        static struct net_buf_pool _name __net_buf_align                      \
                        __in_section(_net_buf_pool, static, _name) =          \
                NET_BUF_POOL_INITIALIZER(_name, &net_buf_fixed_alloc_##_name, \
                                         net_buf_##_name, _count, _destroy)
 
extern const struct net_buf_data_cb net_buf_var_cb;
#define NET_BUF_POOL_VAR_DEFINE(_name, _count, _data_size, _destroy)          \
        static struct net_buf _net_buf_##_name[_count] __noinit;              \
        K_HEAP_DEFINE(net_buf_mem_pool_##_name, _data_size); \
        static const struct net_buf_data_alloc net_buf_data_alloc_##_name = { \
                .cb = &net_buf_var_cb,                                        \
                .alloc_data = &net_buf_mem_pool_##_name,                      \
        };                                                                    \
        static struct net_buf_pool _name __net_buf_align                      \
                        __in_section(_net_buf_pool, static, _name) =          \
                NET_BUF_POOL_INITIALIZER(_name, &net_buf_data_alloc_##_name,  \
                                         _net_buf_##_name, _count, _destroy)
 
#define NET_BUF_POOL_DEFINE(_name, _count, _size, _ud_size, _destroy)        \
        BUILD_ASSERT(_ud_size <= CONFIG_NET_BUF_USER_DATA_SIZE);             \
        NET_BUF_POOL_FIXED_DEFINE(_name, _count, _size, _destroy)
 
struct net_buf_pool *net_buf_pool_get(int id);
 
int net_buf_id(struct net_buf *buf);
 
#if defined(CONFIG_NET_BUF_LOG)
struct net_buf *net_buf_alloc_fixed_debug(struct net_buf_pool *pool,
                                          k_timeout_t timeout, const char *func,
                                          int line);
#define net_buf_alloc_fixed(_pool, _timeout) \
        net_buf_alloc_fixed_debug(_pool, _timeout, __func__, __LINE__)
#else
struct net_buf *net_buf_alloc_fixed(struct net_buf_pool *pool,
                                    k_timeout_t timeout);
#endif
 
static inline struct net_buf *net_buf_alloc(struct net_buf_pool *pool,
                                            k_timeout_t timeout)
{
        return net_buf_alloc_fixed(pool, timeout);
}
 
#if defined(CONFIG_NET_BUF_LOG)
struct net_buf *net_buf_alloc_len_debug(struct net_buf_pool *pool, size_t size,
                                        k_timeout_t timeout, const char *func,
                                        int line);
#define net_buf_alloc_len(_pool, _size, _timeout) \
        net_buf_alloc_len_debug(_pool, _size, _timeout, __func__, __LINE__)
#else
struct net_buf *net_buf_alloc_len(struct net_buf_pool *pool, size_t size,
                                  k_timeout_t timeout);
#endif
 
#if defined(CONFIG_NET_BUF_LOG)
struct net_buf *net_buf_alloc_with_data_debug(struct net_buf_pool *pool,
                                              void *data, size_t size,
                                              k_timeout_t timeout,
                                              const char *func, int line);
#define net_buf_alloc_with_data(_pool, _data_, _size, _timeout)         \
        net_buf_alloc_with_data_debug(_pool, _data_, _size, _timeout,   \
                                      __func__, __LINE__)
#else
struct net_buf *net_buf_alloc_with_data(struct net_buf_pool *pool,
                                        void *data, size_t size,
                                        k_timeout_t timeout);
#endif
 
#if defined(CONFIG_NET_BUF_LOG)
struct net_buf *net_buf_get_debug(struct k_fifo *fifo, k_timeout_t timeout,
                                  const char *func, int line);
#define net_buf_get(_fifo, _timeout) \
        net_buf_get_debug(_fifo, _timeout, __func__, __LINE__)
#else
struct net_buf *net_buf_get(struct k_fifo *fifo, k_timeout_t timeout);
#endif
 
static inline void net_buf_destroy(struct net_buf *buf)
{
        struct net_buf_pool *pool = net_buf_pool_get(buf->pool_id);
 
        k_lifo_put(&pool->free, buf);
}
 
void net_buf_reset(struct net_buf *buf);
 
void net_buf_simple_reserve(struct net_buf_simple *buf, size_t reserve);
 
void net_buf_slist_put(sys_slist_t *list, struct net_buf *buf);
 
struct net_buf *net_buf_slist_get(sys_slist_t *list);
 
void net_buf_put(struct k_fifo *fifo, struct net_buf *buf);
 
#if defined(CONFIG_NET_BUF_LOG)
void net_buf_unref_debug(struct net_buf *buf, const char *func, int line);
#define net_buf_unref(_buf) \
        net_buf_unref_debug(_buf, __func__, __LINE__)
#else
void net_buf_unref(struct net_buf *buf);
#endif
 
struct net_buf *net_buf_ref(struct net_buf *buf);
 
struct net_buf *net_buf_clone(struct net_buf *buf, k_timeout_t timeout);
 
static inline void *net_buf_user_data(const struct net_buf *buf)
{
        return (void *)buf->user_data;
}
 
static inline void net_buf_reserve(struct net_buf *buf, size_t reserve)
{
        net_buf_simple_reserve(&buf->b, reserve);
}
 
static inline void *net_buf_add(struct net_buf *buf, size_t len)
{
        return net_buf_simple_add(&buf->b, len);
}
 
static inline void *net_buf_add_mem(struct net_buf *buf, const void *mem,
                                    size_t len)
{
        return net_buf_simple_add_mem(&buf->b, mem, len);
}
 
static inline uint8_t *net_buf_add_u8(struct net_buf *buf, uint8_t val)
{
        return net_buf_simple_add_u8(&buf->b, val);
}
 
static inline void net_buf_add_le16(struct net_buf *buf, uint16_t val)
{
        net_buf_simple_add_le16(&buf->b, val);
}
 
static inline void net_buf_add_be16(struct net_buf *buf, uint16_t val)
{
        net_buf_simple_add_be16(&buf->b, val);
}
 
static inline void net_buf_add_le24(struct net_buf *buf, uint32_t val)
{
        net_buf_simple_add_le24(&buf->b, val);
}
 
static inline void net_buf_add_be24(struct net_buf *buf, uint32_t val)
{
        net_buf_simple_add_be24(&buf->b, val);
}
 
static inline void net_buf_add_le32(struct net_buf *buf, uint32_t val)
{
        net_buf_simple_add_le32(&buf->b, val);
}
 
static inline void net_buf_add_be32(struct net_buf *buf, uint32_t val)
{
        net_buf_simple_add_be32(&buf->b, val);
}
 
static inline void net_buf_add_le48(struct net_buf *buf, uint64_t val)
{
        net_buf_simple_add_le48(&buf->b, val);
}
 
static inline void net_buf_add_be48(struct net_buf *buf, uint64_t val)
{
        net_buf_simple_add_be48(&buf->b, val);
}
 
static inline void net_buf_add_le64(struct net_buf *buf, uint64_t val)
{
        net_buf_simple_add_le64(&buf->b, val);
}
 
static inline void net_buf_add_be64(struct net_buf *buf, uint64_t val)
{
        net_buf_simple_add_be64(&buf->b, val);
}
 
static inline void *net_buf_remove_mem(struct net_buf *buf, size_t len)
{
        return net_buf_simple_remove_mem(&buf->b, len);
}
 
static inline uint8_t net_buf_remove_u8(struct net_buf *buf)
{
        return net_buf_simple_remove_u8(&buf->b);
}
 
static inline uint16_t net_buf_remove_le16(struct net_buf *buf)
{
        return net_buf_simple_remove_le16(&buf->b);
}
 
static inline uint16_t net_buf_remove_be16(struct net_buf *buf)
{
        return net_buf_simple_remove_be16(&buf->b);
}
 
static inline uint32_t net_buf_remove_be24(struct net_buf *buf)
{
        return net_buf_simple_remove_be24(&buf->b);
}
 
static inline uint32_t net_buf_remove_le24(struct net_buf *buf)
{
        return net_buf_simple_remove_le24(&buf->b);
}
 
static inline uint32_t net_buf_remove_le32(struct net_buf *buf)
{
        return net_buf_simple_remove_le32(&buf->b);
}
 
static inline uint32_t net_buf_remove_be32(struct net_buf *buf)
{
        return net_buf_simple_remove_be32(&buf->b);
}
 
static inline uint64_t net_buf_remove_le48(struct net_buf *buf)
{
        return net_buf_simple_remove_le48(&buf->b);
}
 
static inline uint64_t net_buf_remove_be48(struct net_buf *buf)
{
        return net_buf_simple_remove_be48(&buf->b);
}
 
static inline uint64_t net_buf_remove_le64(struct net_buf *buf)
{
        return net_buf_simple_remove_le64(&buf->b);
}
 
static inline uint64_t net_buf_remove_be64(struct net_buf *buf)
{
        return net_buf_simple_remove_be64(&buf->b);
}
 
static inline void *net_buf_push(struct net_buf *buf, size_t len)
{
        return net_buf_simple_push(&buf->b, len);
}
 
static inline void *net_buf_push_mem(struct net_buf *buf, const void *mem,
                                     size_t len)
{
        return net_buf_simple_push_mem(&buf->b, mem, len);
}
 
static inline void net_buf_push_u8(struct net_buf *buf, uint8_t val)
{
        net_buf_simple_push_u8(&buf->b, val);
}
 
static inline void net_buf_push_le16(struct net_buf *buf, uint16_t val)
{
        net_buf_simple_push_le16(&buf->b, val);
}
 
static inline void net_buf_push_be16(struct net_buf *buf, uint16_t val)
{
        net_buf_simple_push_be16(&buf->b, val);
}
 
static inline void net_buf_push_le24(struct net_buf *buf, uint32_t val)
{
        net_buf_simple_push_le24(&buf->b, val);
}
 
static inline void net_buf_push_be24(struct net_buf *buf, uint32_t val)
{
        net_buf_simple_push_be24(&buf->b, val);
}
 
static inline void net_buf_push_le32(struct net_buf *buf, uint32_t val)
{
        net_buf_simple_push_le32(&buf->b, val);
}
 
static inline void net_buf_push_be32(struct net_buf *buf, uint32_t val)
{
        net_buf_simple_push_be32(&buf->b, val);
}
 
static inline void net_buf_push_le48(struct net_buf *buf, uint64_t val)
{
        net_buf_simple_push_le48(&buf->b, val);
}
 
static inline void net_buf_push_be48(struct net_buf *buf, uint64_t val)
{
        net_buf_simple_push_be48(&buf->b, val);
}
 
static inline void net_buf_push_le64(struct net_buf *buf, uint64_t val)
{
        net_buf_simple_push_le64(&buf->b, val);
}
 
static inline void net_buf_push_be64(struct net_buf *buf, uint64_t val)
{
        net_buf_simple_push_be64(&buf->b, val);
}
 
static inline void *net_buf_pull(struct net_buf *buf, size_t len)
{
        return net_buf_simple_pull(&buf->b, len);
}
 
static inline void *net_buf_pull_mem(struct net_buf *buf, size_t len)
{
        return net_buf_simple_pull_mem(&buf->b, len);
}
 
static inline uint8_t net_buf_pull_u8(struct net_buf *buf)
{
        return net_buf_simple_pull_u8(&buf->b);
}
 
static inline uint16_t net_buf_pull_le16(struct net_buf *buf)
{
        return net_buf_simple_pull_le16(&buf->b);
}
 
static inline uint16_t net_buf_pull_be16(struct net_buf *buf)
{
        return net_buf_simple_pull_be16(&buf->b);
}
 
static inline uint32_t net_buf_pull_le24(struct net_buf *buf)
{
        return net_buf_simple_pull_le24(&buf->b);
}
 
static inline uint32_t net_buf_pull_be24(struct net_buf *buf)
{
        return net_buf_simple_pull_be24(&buf->b);
}
 
static inline uint32_t net_buf_pull_le32(struct net_buf *buf)
{
        return net_buf_simple_pull_le32(&buf->b);
}
 
static inline uint32_t net_buf_pull_be32(struct net_buf *buf)
{
        return net_buf_simple_pull_be32(&buf->b);
}
 
static inline uint64_t net_buf_pull_le48(struct net_buf *buf)
{
        return net_buf_simple_pull_le48(&buf->b);
}
 
static inline uint64_t net_buf_pull_be48(struct net_buf *buf)
{
        return net_buf_simple_pull_be48(&buf->b);
}
 
static inline uint64_t net_buf_pull_le64(struct net_buf *buf)
{
        return net_buf_simple_pull_le64(&buf->b);
}
 
static inline uint64_t net_buf_pull_be64(struct net_buf *buf)
{
        return net_buf_simple_pull_be64(&buf->b);
}
 
static inline size_t net_buf_tailroom(struct net_buf *buf)
{
        return net_buf_simple_tailroom(&buf->b);
}
 
static inline size_t net_buf_headroom(struct net_buf *buf)
{
        return net_buf_simple_headroom(&buf->b);
}
 
static inline uint16_t net_buf_max_len(struct net_buf *buf)
{
        return net_buf_simple_max_len(&buf->b);
}
 
static inline uint8_t *net_buf_tail(struct net_buf *buf)
{
        return net_buf_simple_tail(&buf->b);
}
 
struct net_buf *net_buf_frag_last(struct net_buf *frags);
 
void net_buf_frag_insert(struct net_buf *parent, struct net_buf *frag);
 
struct net_buf *net_buf_frag_add(struct net_buf *head, struct net_buf *frag);
 
#if defined(CONFIG_NET_BUF_LOG)
struct net_buf *net_buf_frag_del_debug(struct net_buf *parent,
                                       struct net_buf *frag,
                                       const char *func, int line);
#define net_buf_frag_del(_parent, _frag) \
        net_buf_frag_del_debug(_parent, _frag, __func__, __LINE__)
#else
struct net_buf *net_buf_frag_del(struct net_buf *parent, struct net_buf *frag);
#endif
 
size_t net_buf_linearize(void *dst, size_t dst_len,
                         struct net_buf *src, size_t offset, size_t len);
 
typedef struct net_buf *(*net_buf_allocator_cb)(k_timeout_t timeout,
                                                void *user_data);
 
size_t net_buf_append_bytes(struct net_buf *buf, size_t len,
                            const void *value, k_timeout_t timeout,
                            net_buf_allocator_cb allocate_cb, void *user_data);
 
static inline struct net_buf *net_buf_skip(struct net_buf *buf, size_t len)
{
        while (buf && len--) {
                net_buf_pull_u8(buf);
                if (!buf->len) {
                        buf = net_buf_frag_del(NULL, buf);
                }
        }
 
        return buf;
}
 
static inline size_t net_buf_frags_len(struct net_buf *buf)
{
        size_t bytes = 0;
 
        while (buf) {
                bytes += buf->len;
                buf = buf->frags;
        }
 
        return bytes;
}
 
#ifdef __cplusplus
}
#endif
 
#endif /* ZEPHYR_INCLUDE_NET_BUF_H_ */