net_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 <zephyr/sys/util.h>
#include <zephyr/kernel.h>
#include <zephyr/sys/iterable_sections.h>
 
#ifdef __cplusplus
extern "C" {
#endif

 
/* Alignment needed for various parts of the buffer definition */
#if CONFIG_NET_BUF_ALIGNMENT == 0
#define __net_buf_align __aligned(sizeof(void *))
#else
#define __net_buf_align __aligned(CONFIG_NET_BUF_ALIGNMENT)
#endif

#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_le40(struct net_buf_simple *buf, uint64_t val);

void net_buf_simple_add_be40(struct net_buf_simple *buf, uint64_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_le40(struct net_buf_simple *buf);

uint64_t net_buf_simple_remove_be40(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_le40(struct net_buf_simple *buf, uint64_t val);

void net_buf_simple_push_be40(struct net_buf_simple *buf, uint64_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_le40(struct net_buf_simple *buf);

uint64_t net_buf_simple_pull_be40(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(const struct net_buf_simple *buf)
{
        return buf->data + buf->len;
}

static inline size_t net_buf_simple_headroom(const struct net_buf_simple *buf)
{
        return buf->data - buf->__buf;
}

static inline size_t net_buf_simple_tailroom(const struct net_buf_simple *buf)
{
        return buf->size - net_buf_simple_headroom(buf) - buf->len;
}

__deprecated static inline uint16_t net_buf_simple_max_len(const struct net_buf_simple *buf)
{
        return buf->size - net_buf_simple_headroom(buf);
}

static inline bool net_buf_simple_is_valid(const struct net_buf_simple *buf)
{
        size_t headroom;
 
        if (buf == NULL || buf->__buf == NULL || buf->data < buf->__buf) {
                return false;
        }
 
        headroom = net_buf_simple_headroom(buf);
        if (headroom > buf->size) {
                return false;
        }
 
        return (size_t)buf->len <= (size_t)(buf->size - headroom);
}

struct net_buf_simple_state {
        uint16_t offset;
        uint16_t len;
};

static inline void net_buf_simple_save(const struct net_buf_simple *buf,
                                       struct net_buf_simple_state *state)
{
        state->offset = (uint16_t)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_EXTERNAL_DATA  BIT(0)

struct net_buf {
        sys_snode_t node;

        struct net_buf *frags;

        union {
                atomic_t ref_word;
                struct {
#if defined(CONFIG_BIG_ENDIAN)
                        /* atomic_t is typedef'd as long (BUILD_ASSERTed in
                         * lib/net_buf/buf.c); on a 64-bit big-endian build
                         * the byte struct needs 4 bytes of padding so that
                         * `ref` lands on the least-significant byte of
                         * ref_word.
                         */
#if (__SIZEOF_LONG__ == 8)
                        uint8_t _ref_word_pad[4];
#endif
                        uint8_t user_data_size;

                        uint8_t pool_id;

                        uint8_t flags;

                        uint8_t ref;
#else
                        uint8_t ref;

                        uint8_t flags;

                        uint8_t pool_id;

                        uint8_t user_data_size;
#endif
                };
        };

        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[] __net_buf_align;
};

 
struct net_buf_data_cb {
        uint8_t * __must_check (*alloc)(struct net_buf *buf, size_t *size,
                           k_timeout_t timeout);
        uint8_t * __must_check (*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;
        size_t max_alloc_size;
        size_t alignment;
};


struct net_buf_pool {
        struct k_lifo free;

        struct k_spinlock lock;

        const uint16_t buf_count;

        uint16_t uninit_count;

        uint8_t user_data_size;
 
#if defined(CONFIG_NET_BUF_POOL_USAGE)
        atomic_t avail_count;

        const uint16_t pool_size;

        uint16_t max_used;

        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;
};

#define NET_BUF_POOL_USAGE_INIT(_pool, _count) \
        IF_ENABLED(CONFIG_NET_BUF_POOL_USAGE, (.avail_count = ATOMIC_INIT(_count),)) \
        IF_ENABLED(CONFIG_NET_BUF_POOL_USAGE, (.max_used = 0,)) \
        IF_ENABLED(CONFIG_NET_BUF_POOL_USAGE, (.name = STRINGIFY(_pool),))
 
#define NET_BUF_POOL_INITIALIZER(_pool, _alloc, _bufs, _count, _ud_size, _destroy) \
        {                                                                          \
                .free = Z_LIFO_INITIALIZER(_pool.free),                            \
                .lock = { },                                                       \
                .buf_count = _count,                                               \
                .uninit_count = _count,                                            \
                .user_data_size = _ud_size,                                        \
                NET_BUF_POOL_USAGE_INIT(_pool, _count)                             \
                .destroy = _destroy,                                               \
                .alloc = _alloc,                                                   \
                .__bufs = (struct net_buf *)_bufs,                                 \
        }
 
#define _NET_BUF_ARRAY_DEFINE(_name, _count, _ud_size)                                         \
        struct _net_buf_##_name { uint8_t b[sizeof(struct net_buf)];                           \
                                  uint8_t ud[_ud_size]; } __net_buf_align;                     \
        BUILD_ASSERT(_ud_size <= UINT8_MAX);                                                   \
        BUILD_ASSERT(offsetof(struct net_buf, user_data) ==                                    \
                     offsetof(struct _net_buf_##_name, ud), "Invalid offset");                 \
        BUILD_ASSERT(__alignof__(struct net_buf) ==                                            \
                     __alignof__(struct _net_buf_##_name), "Invalid alignment");               \
        BUILD_ASSERT(sizeof(struct _net_buf_##_name) ==                                        \
                     ROUND_UP(sizeof(struct net_buf) + _ud_size, __alignof__(struct net_buf)), \
                     "Size cannot be determined");                                             \
        static struct _net_buf_##_name _net_buf_##_name[_count] __noinit
 
extern const struct net_buf_data_alloc net_buf_heap_alloc;

#define NET_BUF_POOL_HEAP_DEFINE(_name, _count, _ud_size, _destroy)          \
        _NET_BUF_ARRAY_DEFINE(_name, _count, _ud_size);                      \
        static STRUCT_SECTION_ITERABLE(net_buf_pool, _name) =                \
                NET_BUF_POOL_INITIALIZER(_name, &net_buf_heap_alloc,         \
                                         _net_buf_##_name, _count, _ud_size, \
                                         _destroy)

 
struct net_buf_pool_fixed {
        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, _ud_size, _destroy) \
        _NET_BUF_ARRAY_DEFINE(_name, _count, _ud_size);                        \
        static uint8_t __noinit net_buf_data_##_name[_count][_data_size] __net_buf_align; \
        static const struct net_buf_pool_fixed net_buf_fixed_##_name = {       \
                .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,                  \
                .max_alloc_size = _data_size,                                  \
        };                                                                     \
        static STRUCT_SECTION_ITERABLE(net_buf_pool, _name) =                  \
                NET_BUF_POOL_INITIALIZER(_name, &net_buf_fixed_alloc_##_name,  \
                                         _net_buf_##_name, _count, _ud_size,   \
                                         _destroy)

extern const struct net_buf_data_cb net_buf_var_cb;

#define NET_BUF_POOL_VAR_DEFINE(_name, _count, _data_size, _ud_size, _destroy) \
        _NET_BUF_ARRAY_DEFINE(_name, _count, _ud_size);                        \
        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,                       \
                .max_alloc_size = 0,                                           \
        };                                                                     \
        static STRUCT_SECTION_ITERABLE(net_buf_pool, _name) =                  \
                NET_BUF_POOL_INITIALIZER(_name, &net_buf_data_alloc_##_name,   \
                                         _net_buf_##_name, _count, _ud_size,   \
                                         _destroy)

#define NET_BUF_POOL_VAR_ALIGN_DEFINE(_name, _count, _data_size, _ud_size,     \
                                      _destroy, _align)                        \
        _NET_BUF_ARRAY_DEFINE(_name, _count, _ud_size);                        \
        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,                       \
                .max_alloc_size = 0,                                           \
                .alignment = _align,                                           \
        };                                                                     \
        static STRUCT_SECTION_ITERABLE(net_buf_pool, _name) =                  \
                NET_BUF_POOL_INITIALIZER(_name, &net_buf_data_alloc_##_name,   \
                                         _net_buf_##_name, _count, _ud_size,   \
                                         _destroy)

#define NET_BUF_POOL_DEFINE(_name, _count, _size, _ud_size, _destroy)        \
        NET_BUF_POOL_FIXED_DEFINE(_name, _count, _size, _ud_size, _destroy)

struct net_buf_pool *net_buf_pool_get(int id);

int net_buf_id(const struct net_buf *buf);
 
#if defined(CONFIG_NET_BUF_POOL_USAGE) || defined(__DOXYGEN__)
static inline size_t net_buf_get_available(struct net_buf_pool *pool)
{
        return (size_t)atomic_get(&pool->avail_count);
}

static inline size_t net_buf_get_max_used(struct net_buf_pool *pool)
{
        return (size_t)pool->max_used;
}
#endif /* defined(CONFIG_NET_BUF_POOL_USAGE) || defined(__DOXYGEN__) */

#if defined(CONFIG_NET_BUF_LOG)
struct net_buf * __must_check 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 * __must_check net_buf_alloc_fixed(struct net_buf_pool *pool,
                                                  k_timeout_t timeout);
#endif

static inline struct net_buf * __must_check 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 * __must_check 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 * __must_check 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 * __must_check 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 * __must_check net_buf_alloc_with_data(struct net_buf_pool *pool,
                                                      void *data, size_t size,
                                                      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);
 
        if (buf->__buf) {
                if (!(buf->flags & NET_BUF_EXTERNAL_DATA)) {
                        pool->alloc->cb->unref(buf, buf->__buf);
                }
                buf->__buf = NULL;
        }
 
        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 * __must_check net_buf_slist_get(sys_slist_t *list);

#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 * __must_check net_buf_ref(struct net_buf *buf);

static inline struct net_buf *__must_check net_buf_take(struct net_buf **orig)
{
        return (struct net_buf *)atomic_ptr_clear((atomic_ptr_t *)orig);
}

static inline void net_buf_drop(struct net_buf **orig)
{
        struct net_buf *buf = net_buf_take(orig);
 
        if (buf != NULL) {
                net_buf_unref(buf);
        }
}

struct net_buf * __must_check net_buf_clone(struct net_buf *buf,
                                            k_timeout_t timeout);

static inline void * __must_check net_buf_user_data(const struct net_buf *buf)
{
        return (void *)buf->user_data;
}

int net_buf_user_data_copy(struct net_buf *dst, const struct net_buf *src);

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_le40(struct net_buf *buf, uint64_t val)
{
        net_buf_simple_add_le40(&buf->b, val);
}

static inline void net_buf_add_be40(struct net_buf *buf, uint64_t val)
{
        net_buf_simple_add_be40(&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_le40(struct net_buf *buf)
{
        return net_buf_simple_remove_le40(&buf->b);
}

static inline uint64_t net_buf_remove_be40(struct net_buf *buf)
{
        return net_buf_simple_remove_be40(&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_le40(struct net_buf *buf, uint64_t val)
{
        net_buf_simple_push_le40(&buf->b, val);
}

static inline void net_buf_push_be40(struct net_buf *buf, uint64_t val)
{
        net_buf_simple_push_be40(&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_le40(struct net_buf *buf)
{
        return net_buf_simple_pull_le40(&buf->b);
}

static inline uint64_t net_buf_pull_be40(struct net_buf *buf)
{
        return net_buf_simple_pull_be40(&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(const struct net_buf *buf)
{
        return net_buf_simple_tailroom(&buf->b);
}

static inline size_t net_buf_headroom(const struct net_buf *buf)
{
        return net_buf_simple_headroom(&buf->b);
}

__deprecated static inline uint16_t net_buf_max_len(const struct net_buf *buf)
{
        return buf->size - net_buf_headroom(buf);
}

static inline bool net_buf_is_valid(const struct net_buf *buf)
{
        return buf != NULL && buf->ref > 0 && net_buf_simple_is_valid(&buf->b);
}

static inline uint8_t *net_buf_tail(const 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,
                         const struct net_buf *src, size_t offset, size_t len);

typedef struct net_buf * __must_check (*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);

size_t net_buf_data_match(const struct net_buf *buf, size_t offset, const void *data, size_t len);

static inline struct net_buf *net_buf_skip(struct net_buf *buf, size_t len)
{
        while (buf != NULL && len > 0U) {
                size_t to_skip = MIN(len, buf->len);
 
                /* A zero-capacity fragment has no data buffer to pull from */
                if (to_skip > 0U) {
                        net_buf_pull(buf, to_skip);
                        len -= to_skip;
                }
 
                if (buf->len == 0U) {
                        buf = net_buf_frag_del(NULL, buf);
                }
        }
 
        return buf;
}

static inline size_t net_buf_frags_len(const 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_ */