tlv.h

Go to the documentation of this file.

 
#pragma once
 
#include <stdbool.h>
#include <stdint.h>
#include <string.h>
#include <assert.h>
 
typedef uint8_t tlv_tag_t; 
typedef uint8_t tlv_len_t; 

#define TLV_TAGLEN_SIZE (sizeof(tlv_tag_t) + sizeof(tlv_len_t))
 
struct tlv_entry {
        tlv_tag_t tag; 
        tlv_len_t len; 
        void     *val; 
};
 
struct tlv_buf {
        uint8_t *_mem;  
        size_t   _cap; 
 
        size_t _head_idx; 
        size_t _tail_idx; 
};

static void tlv_buf_init(struct tlv_buf *self, uint8_t *mem, const size_t cap)
{
        assert(self && mem && (cap > 0u));
 
        self->_mem = mem;
        self->_cap = cap;
 
        self->_head_idx = 0u;
        self->_tail_idx = 0u;
}

static void tlv_entry_init(struct tlv_entry *self, const uint8_t tag,
                           const uint8_t len, void *val)
{
        assert(self && val);
 
        self->tag = tag;
        self->len = len;
        self->val = val;
}

static bool tlv_buf_push(struct tlv_buf *self, struct tlv_entry *entry)
{
        bool   result;
        size_t header_size;
        size_t entry_size;
        size_t new_tail_idx;
 
        assert(self && entry);
        result       = false;
        header_size  = sizeof(entry->tag) + sizeof(entry->len);
        entry_size   = header_size + entry->len;
        new_tail_idx = self->_tail_idx + entry_size;
 
        if (new_tail_idx < self->_cap) {
                self->_mem[self->_tail_idx] = entry->tag;
                self->_tail_idx += sizeof(entry->tag);
 
                self->_mem[self->_tail_idx] = entry->len;
                self->_tail_idx += sizeof(entry->len);
 
                (void)memcpy(&self->_mem[self->_tail_idx], entry->val,
                             entry->len);
                self->_tail_idx = new_tail_idx;
 
                result = true;
        }
 
        return result;
}

static bool tlv_buf_pop(struct tlv_buf *self, struct tlv_entry *entry)
{
        bool   result;
        size_t header_size;
 
        assert(self && entry);
        result      = false;
        header_size = sizeof(entry->tag) + sizeof(entry->len);
 
        /* There's no extra check for full length, which might be dangerous */
        if ((self->_head_idx + header_size) <= self->_tail_idx) {
                entry->tag = self->_mem[self->_head_idx];
                self->_head_idx += sizeof(entry->tag);
 
                entry->len = self->_mem[self->_head_idx];
                self->_head_idx += sizeof(entry->len);
 
                entry->val = &self->_mem[self->_head_idx];
                self->_head_idx += entry->len;
 
                result = true;
        }
 
        return result;
}

static void tlv_buf_reset_head(struct tlv_buf *self)
{
        assert(self);
        self->_head_idx = 0u;
}

static void tlv_buf_reset(struct tlv_buf *self)
{
        assert(self);
        self->_head_idx = 0u;
        self->_tail_idx = 0u;
}

static size_t tlv_buf_get_occupied_mem_size(struct tlv_buf *self)
{
        assert(self);
 
        return self->_tail_idx;
}

static size_t tlv_buf_get_free_mem_size(struct tlv_buf *self)
{
        assert(self);
 
        return self->_cap - self->_tail_idx;
}