Admin Control Panel v2.0

✎ Editing: protocol_transport_impl.h ← Back

#ifndef KERNEL__OAS__SMALL__PROTOCOL_TRANSPORT_IMPL_H
#define KERNEL__OAS__SMALL__PROTOCOL_TRANSPORT_IMPL_H

#include "oas/small/protocol.h"

#if defined(__linux__) && defined(__KERNEL__)
#include <linux/byteorder/generic.h>
#endif

typedef struct
{
    char* data;
    u_int32_t capacity;
    u_int32_t length;
    char* start;
} TransportBuffer;

typedef struct
{
    char* begin;
    char* end;
} TransportBufferEntry;

// user should call only next functions:
// reser buffer before use
static inline int TransportBufferInit(TransportBuffer* buf);
static inline void TransportBufferFinit(TransportBuffer* buf);
// add transport packet to buffer
static inline int TransportBufferAddPacket(TransportBuffer* buf,
                                           const PackedBuffer* packet);
// check is packet ready in buffer
static inline u_int32_t TransportBufferIsReady(const TransportBuffer* buf);
// if packet ready - process it
static inline u_int32_t TransportBufferGetNextPacket(TransportBuffer* buf,
                                                     TransportBufferEntry* el);

static inline int fs_transport_buffer_check_size(TransportBuffer* buf,
                                                 u_int32_t need_bytes);
static inline void fs_transport_buffer_append_raw(TransportBuffer* buf,
                                                  const char* data, u_int32_t len);
static inline u_int32_t fs_transport_buffer_get_length(const TransportBuffer* buf);

static inline int TransportBufferInit(TransportBuffer* buf)
{
    buf->capacity = 1024;
    buf->data     = protocol_alloc.alloc(buf->capacity);
    buf->length   = 0;
    buf->start = buf->data;
    if (!buf->data)
    {
        buf->capacity = 0;
        return 0;
    }

return 1;
}

static inline void TransportBufferFinit(TransportBuffer* buf)
{
    if (buf->data)
    {
        protocol_alloc.free(buf->data);
        buf->data = NULL;
    }
}

static inline int TransportBufferAddPacket(TransportBuffer* buf,
                                           const PackedBuffer* packet)
{
    u_int32_t net_len = htonl(packet->length);

if (!fs_transport_buffer_check_size(buf, sizeof(u_int32_t) + packet->length))
    {
        return 0;
    }
    fs_transport_buffer_append_raw(buf, (char*)&net_len, sizeof(u_int32_t));
    fs_transport_buffer_append_raw(buf, (char*)packet->data, packet->length);

return 1;
}

static inline u_int32_t TransportBufferIsReady(const TransportBuffer* buf)
{
    u_int32_t len;

if (buf->length < sizeof(u_int32_t))
        return 0;

len = fs_transport_buffer_get_length(buf) + sizeof(u_int32_t);
    if (buf->length < len)
        return 0;
    return len;
}

static inline u_int32_t TransportBufferGetNextPacket(TransportBuffer* buf,
                                                     TransportBufferEntry* el)
{
    u_int32_t len = TransportBufferIsReady(buf);
    if (!len)
        return 0;
    el->begin = buf->start + sizeof(u_int32_t);
    el->end   = buf->start + len;
    buf->start += len;
    buf->length -= len;
    return len;
}

static inline int fs_transport_buffer_only_check_size(TransportBuffer* buf,
                                                      u_int32_t need_bytes)
{
    if (buf->start + buf->length + need_bytes <= buf->data + buf->capacity)
        return 1;

if (!buf->length && need_bytes <= buf->capacity)
    {
        buf->start = buf->data;
        return 1;
    }
    if (buf->length + need_bytes <= buf->capacity)
    {
        memmove(buf->data, buf->start, buf->length);
        buf->start = buf->data;
        return 1;
    }
    return 0;
}

static inline int fs_transport_buffer_check_size(TransportBuffer* buf,
                                                 u_int32_t need_bytes)
{
    size_t capacity;

if (fs_transport_buffer_only_check_size(buf, need_bytes))
    {
        return 1;
    }

capacity = buf->capacity;
    if (!capacity)
        capacity = 512;
    do
        capacity *= 2;
    while (need_bytes > (capacity - buf->length));

{
        char* tmp = protocol_alloc.alloc(capacity);
        if (!tmp)
            return 0;

if (buf->data)
        {
            memcpy(tmp, buf->start, buf->length);
            protocol_alloc.free(buf->data);
        }
        buf->data     = tmp;
        buf->start    = buf->data;
        buf->capacity = capacity;
    }

return 1;
}

static inline int fs_transport_buffer_get_free_size(TransportBuffer* buf)
{
    if (buf->length && buf->start != buf->data)
    {
        memmove(buf->data, buf->start, buf->length);
        buf->start = buf->data;
    }
    return buf->capacity - buf->length;
}

static inline void fs_transport_buffer_append_raw(TransportBuffer* buf,
                                                  const char* data, u_int32_t len)
{
    memcpy(buf->start + buf->length, data, len);
    buf->length += len;
}

static inline u_int32_t fs_transport_buffer_get_length(const TransportBuffer* buf)
{
    u_int32_t* ptr = (u_int32_t*)buf->start;
    return ntohl(*ptr);
}

#endif // KERNEL__OAS__SMALL__PROTOCOL_TRANSPORT_IMPL_H

Cancel