mmbuf.h

/*
 * Copyright 2024 Morse Micro
 *
 * SPDX-License-Identifier: Apache-2.0
 */
 
#pragma once
 
#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
 
#include "mmosal.h"
 
#ifdef __cplusplus
extern "C"
{
#endif
 
struct mmbuf_ops;
 
struct mmbuf
{
    uint8_t *buf;
    uint32_t buf_len;
    uint32_t start_offset;
    uint32_t data_len;
    const struct mmbuf_ops *ops;
    struct mmbuf *volatile next;
};
 
struct mmbuf_ops
{
    void (*free_mmbuf)(void *mmbuf);
};
 
static inline void mmbuf_init(struct mmbuf *mmbuf,
                              uint8_t *buf,
                              uint32_t buf_len,
                              uint32_t data_start_offset,
                              const struct mmbuf_ops *ops)
{
    memset(mmbuf, 0, sizeof(*mmbuf));
    mmbuf->buf = buf;
    mmbuf->buf_len = buf_len;
    mmbuf->start_offset = data_start_offset;
    mmbuf->ops = ops;
}
 
struct mmbuf *mmbuf_alloc_on_heap(uint32_t space_at_start, uint32_t space_at_end);
 
struct mmbuf *mmbuf_make_copy_on_heap(struct mmbuf *original);
 
void mmbuf_release(struct mmbuf *mmbuf);
 
static inline uint8_t *mmbuf_get_data_start(struct mmbuf *mmbuf)
{
    return mmbuf->buf + mmbuf->start_offset;
}
 
static inline uint8_t *mmbuf_get_data_end(struct mmbuf *mmbuf)
{
    return mmbuf->buf + mmbuf->start_offset + mmbuf->data_len;
}
 
static inline uint32_t mmbuf_get_data_length(struct mmbuf *mmbuf)
{
    return mmbuf->data_len;
}
 
static inline uint32_t mmbuf_available_space_at_start(struct mmbuf *mmbuf)
{
    return mmbuf->start_offset;
}
 
static inline uint32_t mmbuf_available_space_at_end(struct mmbuf *mmbuf)
{
    return mmbuf->buf_len - (mmbuf->start_offset + mmbuf->data_len);
}
 
static inline uint8_t *mmbuf_prepend(struct mmbuf *mmbuf, uint32_t len)
{
    MMOSAL_ASSERT(len <= mmbuf_available_space_at_start(mmbuf));
    mmbuf->start_offset -= len;
    mmbuf->data_len += len;
    return mmbuf->buf + mmbuf->start_offset;
}
 
static inline void mmbuf_prepend_data(struct mmbuf *mmbuf, const uint8_t *data, uint32_t len)
{
    uint8_t *dest = mmbuf_prepend(mmbuf, len);
    memcpy(dest, data, len);
}
 
static inline uint8_t *mmbuf_append(struct mmbuf *mmbuf, uint32_t len)
{
    uint8_t *ret = mmbuf_get_data_end(mmbuf);
    MMOSAL_ASSERT(len <= mmbuf_available_space_at_end(mmbuf));
    mmbuf->data_len += len;
    return ret;
}
 
static inline void mmbuf_append_data(struct mmbuf *mmbuf, const uint8_t *data, uint32_t len)
{
    uint8_t *dest = mmbuf_append(mmbuf, len);
    memcpy(dest, data, len);
}
 
static inline uint8_t *mmbuf_remove_from_start(struct mmbuf *mmbuf, uint32_t len)
{
    uint8_t *ret;
 
    if (mmbuf_get_data_length(mmbuf) < len)
    {
        return NULL;
    }
 
    ret = mmbuf_get_data_start(mmbuf);
 
    mmbuf->start_offset += len;
    mmbuf->data_len -= len;
 
    return ret;
}
 
static inline uint8_t *mmbuf_remove_from_end(struct mmbuf *mmbuf, uint32_t len)
{
    uint8_t *ret;
 
    if (mmbuf_get_data_length(mmbuf) < len)
    {
        return NULL;
    }
 
    ret = mmbuf_get_data_end(mmbuf) - len;
 
    mmbuf->data_len -= len;
 
    return ret;
}
 
static inline void mmbuf_truncate(struct mmbuf *mmbuf, uint32_t len)
{
    MMOSAL_ASSERT(len <= mmbuf->data_len);
    mmbuf->data_len = len;
}
 
/* --------------------------------------------------------------------------------------------- */
 
struct mmbuf_list
{
    struct mmbuf *volatile head;
    struct mmbuf *volatile tail;
    volatile uint32_t len;
};
 
#define MMBUF_LIST_INIT { NULL, NULL, 0 }
 
static inline void mmbuf_list_init(struct mmbuf_list *list)
{
    list->head = NULL;
    list->tail = NULL;
    list->len = 0;
}
 
void mmbuf_list_prepend(struct mmbuf_list *list, struct mmbuf *mmbuf);
 
void mmbuf_list_append(struct mmbuf_list *list, struct mmbuf *mmbuf);
 
bool mmbuf_list_remove(struct mmbuf_list *list, struct mmbuf *mmbuf);
 
struct mmbuf *mmbuf_list_dequeue(struct mmbuf_list *list);
 
struct mmbuf *mmbuf_list_dequeue_tail(struct mmbuf_list *list);
 
static inline struct mmbuf *mmbuf_list_dequeue_all(struct mmbuf_list *list)
{
    struct mmbuf *head = list->head;
    list->head = NULL;
    list->tail = NULL;
    list->len = 0;
    return head;
}
 
static inline bool mmbuf_list_is_empty(struct mmbuf_list *list)
{
    return (list->head == NULL);
}
 
static inline struct mmbuf *mmbuf_list_peek(struct mmbuf_list *list)
{
    return list->head;
}
 
static inline struct mmbuf *mmbuf_list_peek_tail(struct mmbuf_list *list)
{
    return list->tail;
}
 
void mmbuf_list_clear(struct mmbuf_list *list);
 
#ifdef __cplusplus
}
#endif