path: root/src/io.c

#include <bh/internal/io.h>
#include <stdlib.h>
#include <string.h>

#define BH_IO_BUFFER_STEP 256

/**
 * \defgroup io Input/Output
 *
 * Input/output device abstraction layer.
 * \{
 */

/**
 * \internal
 * Returns pointer to the \a io peek buffer.
 *
 * \param io    Pointer to the io object
 *
 * \return Pointer to the peek buffer.
 *
 * \warning Always use this function to get data of the buffer!
 */
static char *bh_io_buffer_data(bh_io_t *io)
{
    if (io->buffer.capacity)
        return io->buffer.data;

    return (char *)&io->buffer.data;
}

/**
 * \internal
 * Returns peek buffer capacity of the /a io object.
 *
 * \param io    Pointer to the io object
 *
 * \return Peek buffer capacity.
 *
 * \warning Always use this function to get capacity of the buffer!
 */
static size_t bh_io_buffer_capacity(bh_io_t *io)
{
    if (io->buffer.capacity)
        return io->buffer.capacity;
    return sizeof(char *);
}

/**
 * \internal
 * Reduces the capacity of the \a io object peek buffer.
 *
 * \param io    Pointer to the io object.
 *
 * \note This function does not guarantee that the capacity of the buffer will
 *       actually be reduced.
 */
static void bh_io_buffer_shrink(bh_io_t *io)
{
    size_t capacity;
    char *data;

    /* Check if buffer is allocated */
    if (!io->buffer.capacity)
        return;

    /* Calculate new capacity and check against old capacity */
    capacity = (io->buffer.size + BH_IO_BUFFER_STEP - 1) / BH_IO_BUFFER_STEP;
    capacity *= BH_IO_BUFFER_STEP;
    if (io->buffer.capacity >= capacity)
        return;

    /* Allocate new buffer space */
    data = malloc(capacity);
    if (!data)
        return;

    /* Copy data */
    if (io->buffer.size)
    {
        size_t block;

        /* Depending on the tail-head positions copy data in two or one go */
        if (io->buffer.tail <= io->buffer.head)
        {
            block = io->buffer.capacity - io->buffer.head;
            memmove(data, io->buffer.data + io->buffer.head, block);
            memmove(data + block, io->buffer.data, io->buffer.size - block);
        }
        else
        {
            block = io->buffer.size;
            memmove(data, io->buffer.data + io->buffer.head, block);
        }
    }

    /* Update fields */
    free(io->buffer.data);
    io->buffer.data = data;
    io->buffer.head = 0;
    io->buffer.tail = io->buffer.size;
    io->buffer.capacity = capacity;
    if (io->buffer.tail >= capacity)
        io->buffer.tail = 0;
}

/**
 * \internal
 * Reserves the capacity of the \a io object peek buffer.
 *
 * \param io    Pointer to the io object
 * \param size  New peek buffer capacity
 *
 * \return On success, returns zero value.
 * \return On failure, returns error code.
 */
static int bh_io_buffer_reserve(bh_io_t *io,
                                size_t size)
{
    size_t capacity;
    char *data;

    /* Check if entire buffer can fit into a pointer */
    if (size <= sizeof(char *))
        return BH_OK;

    /* Check that size can fit into a buffer */
    if (io->buffer.capacity >= size)
        return BH_OK;

    /* Calculate new buffer capacity */
    capacity = (size + BH_IO_BUFFER_STEP - 1) / BH_IO_BUFFER_STEP;
    capacity *= BH_IO_BUFFER_STEP;

    /* Allocate new buffer space */
    data = malloc(capacity);
    if (!data)
        return BH_OOM;

    /* Copy data */
    if (io->buffer.size)
    {
        size_t block;

        /* Depending on the tail-head positions copy data in two or one go */
        if (io->buffer.tail <= io->buffer.head)
        {
            block = io->buffer.capacity - io->buffer.head;
            memmove(data, bh_io_buffer_data(io) + io->buffer.head, block);
            memmove(data + block, bh_io_buffer_data(io), io->buffer.size - block);
        }
        else
        {
            block = io->buffer.size;
            memmove(data, bh_io_buffer_data(io) + io->buffer.head, block);
        }
    }

    /* Update fields */
    if (io->buffer.capacity)
        free(io->buffer.data);
    io->buffer.data = data;
    io->buffer.head = 0;
    io->buffer.tail = io->buffer.size;
    io->buffer.capacity = capacity;
    if (io->buffer.tail >= capacity)
        io->buffer.tail = 0;

    return BH_OK;
}

/**
 * \internal
 * Reads data from the \a io peek buffer.
 *
 * \param io    Pointer to the io object
 * \param data  Pointer to the memory buffer
 * \param size  Maximum number of bytes to be read
 * \param peek  Reading or peeking flag
 *
 * \return On success, returns number of bytes successfuly read.
 * \return On failure, returns zero.
 */
static size_t bh_io_buffer_read(bh_io_t *io,
                                char *data,
                                size_t size,
                                int peek)
{
    size_t block;

    /* Check if buffer is empty */
    if (!io->buffer.size)
        return 0;

    /* Reading size can't be bigger then buffer size */
    if (size > io->buffer.size)
        size = io->buffer.size;

    /* Copy data */
    if (data)
    {
        /* Depending on the tail-head positions copy data in two or one go */
        if (io->buffer.tail <= io->buffer.head)
        {
            block = bh_io_buffer_capacity(io) - io->buffer.head;
            if (block > size)
                block = size;
            memmove(data, bh_io_buffer_data(io) + io->buffer.head, block);
            memmove(data + block, bh_io_buffer_data(io), size - block);
        }
        else
        {
            block = size;
            memmove(data, bh_io_buffer_data(io) + io->buffer.head, block);
        }
    }

    /* Adjust head position and size if we are not peeking */
    if (!peek)
    {
        io->buffer.head += size;
        io->buffer.size -= size;

        if (io->buffer.head >= bh_io_buffer_capacity(io))
            io->buffer.head -= bh_io_buffer_capacity(io);

        /* Shrink buffer if neccesary*/
        bh_io_buffer_shrink(io);
    }

    /* Return readed size */
    return size;
}

/**
 * \internal
 * Writes data to the \a io peek buffer.
 *
 * \param io    Pointer to the io object
 * \param data  Pointer to the memory buffer
 * \param size  Maximum number of bytes to be read
 *
 * \return On success, returns number of bytes successfuly written.
 * \return On failure, returns zero.
 */
static size_t bh_io_buffer_write(bh_io_t *io,
                                 const char *data,
                                 size_t size)
{
    size_t block;

    /* Reserve capacity in the buffer */
    if (bh_io_buffer_reserve(io, io->buffer.size + size))
        return 0;

    /* Depending on the tail-head positions copy data in two or one go */
    if (io->buffer.tail + size > bh_io_buffer_capacity(io))
    {
        block = io->buffer.capacity - io->buffer.tail;
        memmove(bh_io_buffer_data(io) + io->buffer.tail, data, block);
        memmove(bh_io_buffer_data(io), data + block, size - block);
    }
    else
    {
        block = size;
        memmove(bh_io_buffer_data(io) + io->buffer.tail, data, block);
    }

    /* Adjust tail and size */
    io->buffer.tail += size;
    io->buffer.size += size;

    if (io->buffer.tail >= bh_io_buffer_capacity(io))
        io->buffer.tail -= bh_io_buffer_capacity(io);

    return size;
}

/**
 * \internal
 * Adjusts \a io object peek buffer according to the specified seek direction
 * \a dir and \a offset.
 *
 * \param io        Pointer to the io object
 * \param offset    Number of bytes to seek in specified direciton
 * \param dir       Seeking direction
 *
 * \return Returns new offset for the io seek function.
 */
static bh_off_t bh_io_buffer_seek(bh_io_t *io,
                                  bh_off_t offset,
                                  int dir)
{
    /* Check if seek is relative to current position */
    if (dir != BH_IO_CURRENT)
    {
        /* It's not - reset peek buffer and return offset as is */
        io->buffer.size = 0;
        io->buffer.head = 0;
        io->buffer.tail = 0;
        return offset;
    }

    /* If offset is negative or past peek buffer size */
    if (offset < 0 || offset >= (bh_off_t)io->buffer.size)
    {
        /* It's not - reset peek buffer and adjust offset position */
        offset -= io->buffer.size;
        io->buffer.size = 0;
        io->buffer.head = 0;
        io->buffer.tail = 0;
        return offset;
    }

    /* Skip offset amount of bytes */
    bh_io_buffer_read(io, NULL, offset, 0);
    return 0;
}

/**
 * Destroys base io object.
 *
 * \param io    Pointer to the base io object
 *
 * \warning This function should be used in context of implementing child
 *          io objects (files, sockets, streaming compression, etc).
 */
void bh_io_destroy_base(bh_io_t *io)
{
    if (io->buffer.capacity)
        free(io->buffer.data);
}

/**
 * Creates the new io object with specified \a table and \a size.
 *
 * The \a unified flag specifies the behaivor of the internal peek buffer.
 * If the \a unified flag is set - the io object will assume that read and
 * write operations are dependant on each other (ex. writing to the file
 * affects next read operation).
 * If the \a unified flag is not set - the io object will asusme that read and
 * write operations are independant.
 *
 * \param table     Pointer to the io table
 * \param size      Size of the io object
 * \param unified   Unified read/write stream flag
 *
 * \return On success, returns new semi-initialized io object.
 * \return On failure, returns null pointer.
 *
 * \warning This function should be used in context of implementing child
 *          io objects (files, sockets, streaming compression, etc).
 */
bh_io_t *bh_io_new(const bh_io_table_t *table,
                   size_t size,
                   int unified)
{
    bh_io_t *result;

    result = malloc(size);
    if (result)
        bh_io_init(result, table, unified);

    return result;
}

/**
 * Frees the \a io object.
 *
 * \param io    Pointer to the io object to be freed
 */
void bh_io_free(bh_io_t *io)
{
    bh_io_destroy(io);
    free(io);
}

/**
 * Initializes the \a io object with specified \a table.
 *
 * The \a unified flag specifies the behaivor of the internal peek buffer.
 * If the \a unified flag is set - the io object will assume that read and
 * write operations are dependant on each other (ex. writing to the file
 * affects next read operation).
 * If the \a unified flag is not set - the io object will asusme that read and
 * write operations are independant.
 *
 * \param io        Pointer to the io object to be initialized
 * \param table     Pointer to the io table
 * \param unified   Unified read/write stream flag
 */
void bh_io_init(bh_io_t *io,
                const bh_io_table_t *table,
                int unified)
{
    io->table = table;
    io->flags = (unified) ? (BH_IO_UNIFIED) : (0);
    io->buffer.capacity = 0;
    io->buffer.head = 0;
    io->buffer.tail = 0;
    io->buffer.size = 0;
}

/**
 * Destroys the \a io object.
 *
 * \param io    Pointer to the io object to be destroyed
 */
void bh_io_destroy(bh_io_t *io)
{
    io->table->destroy(io);
}

/**
 * Opens the \a io object for specified \a mode of operation.
 *
 * \param io    Pointer to the io object
 * \param mode  Bitmask determining access mode
 *
 * \return On success, returns zero.
 * \return On failure, returns error code.
 */
int bh_io_open(bh_io_t *io,
               int mode)
{
    return io->table->open(io, mode);
}

/**
 * Closes the \a io object.
 *
 * \param io    Pointer to the io object
 */
void bh_io_close(bh_io_t *io)
{
    io->table->close(io);
}

/**
 * Checks if the \a io is open.
 *
 * \param io    Pointer to the io object
 *
 * \return If io object is open - returns non-zero.
 * \return If io object is closed - returns zero.
 */
int bh_io_is_open(bh_io_t *io)
{
    return io->table->is_open(io);
}

/**
 * Reads up to \a size amount of bytes from the \a io object into memory buffer
 * pointed by \a data pointer.
 *
 * \param io    Pointer to the io object
 * \param data  Pointer to the memory buffer
 * \param size  Maximum number of bytes to be read
 *
 * \return On success, returns number of bytes successfuly read.
 * \return On failure, returns zero.
 *
 * \note To check for end-of-file or error see bh_io_eof and bh_io_error.
 */
size_t bh_io_read(bh_io_t *io,
                  char *data,
                  size_t size)
{

    size_t result;

    /* Read as much data from peek buffer as possible */
    result = bh_io_buffer_read(io, data, size, 0);

    /* If that wasn't enough read from the device */
    if (result != size)
        result += io->table->read(io, data + result, size - result);

    /* Return amount of bytes read */
    return result;
}

/**
 * Peeks up to \a size amount of bytes from the \a io object into memory buffer
 * pointed by \a data pointer.
 *
 * \param io    Pointer to the io object
 * \param data  Pointer to the memory buffer
 * \param size  Maximum number of bytes to be read
 *
 * \return On success, returns number of bytes successfuly read.
 * \return On failure, returns zero.
 */
size_t bh_io_peek(bh_io_t *io,
                  char *data,
                  size_t size)
{
    /* Fill peek buffer if it's size is less then requested */
    if (io->buffer.size < size)
    {
        size_t read;

        read = io->table->read(io, data, size - io->buffer.size);
        bh_io_buffer_write(io, data, read);
    }

    /* Clear EOF flag if peek buffer is not empty */
    if (io->buffer.size > 0)
        io->flags &= ~BH_IO_EOF;

    /* Read data from the peek buffer */
    return bh_io_buffer_read(io, data, size, 1);
}

/**
 * Writes up to \a size amount of bytes to the \a io object from memory buffer
 * pointed by \a data pointer.
 *
 * \param io    Pointer to the io object
 * \param data  Pointer to the memory buffer
 * \param size  Maximum number of bytes to be read
 *
 * \return On success, returns number of bytes successfuly written.
 * \return On failure, returns zero.
 *
 * \note To check for error see bh_io_error.
 */
size_t bh_io_write(bh_io_t *io,
                   const char *data,
                   size_t size)
{
    /* Clear peek buffer and adjust the position if IO is unified */
    if (io->buffer.size && (io->flags & BH_IO_UNIFIED))
    {
        io->table->seek(io, -(bh_off_t)io->buffer.size, BH_IO_CURRENT);
        io->buffer.head = 0;
        io->buffer.tail = 0;
        io->buffer.size = 0;
    }

    /* Write data */
    return io->table->write(io, data, size);
}

/**
 * Synchronizes the \a io object (if possible).
 *
 * In most cases, this function causes any unwritten/buffered data to be
 * written.
 *
 * \param io    Pointer to the io object
 */
void bh_io_flush(bh_io_t *io)
{
    io->table->flush(io);
}

/**
 * Seeks the \a io object in the specified direction \a dir and \a offset (if
 * possible).
 *
 * \param io        Pointer to the io object
 * \param offset    Number of bytes to seek in specified direciton
 * \param dir       Seeking direction
 *
 * \return On success, returns zero.
 * \return On failure, returns error code.
 */
int bh_io_seek(bh_io_t *io,
               bh_off_t offset,
               int dir)
{
    offset = bh_io_buffer_seek(io, offset, dir);
    return io->table->seek(io, offset, dir);
}

/**
 * Returns total size of the \a io object (if possible)
 *
 * \param io    Pointer to the io object
 *
 * \return On success, returns total size of the io object.
 * \return On failure, returns -1.
 */
bh_off_t bh_io_size(bh_io_t *io)
{
    return io->table->size(io);
}

/**
 * Returns current position in the \a io object (if possible).
 *
 * \param io    Pointer to the io object
 *
 * \return On success, returns current position in the io object.
 * \return On failure, returns -1.
 */
bh_off_t bh_io_tell(bh_io_t *io)
{
    return io->table->tell(io) - io->buffer.size;
}

/**
 * Returns available number of bytes to be read from the \a io object.
 *
 * \param io    Pointer to the io object
 *
 * \return On success, returns number of available bytes to be read.
 * \return On failure, returns zero.
 */
bh_off_t bh_io_available(bh_io_t *io)
{
    return io->table->available(io) + io->buffer.size;
}

/**
 * Checks error flag of the \a io object.
 *
 * \param io    Pointer to the io object
 *
 * \return If error flag is set, returns non-zero.
 * \return If error flag is not set, returns zero.
 */
int bh_io_error(bh_io_t *io)
{
    return (io->flags & BH_IO_ERROR) != 0;
}

/**
 * Checks end-of-file flag of the \a io object.
 *
 * \param io    Pointer to the io object
 *
 * \return If end-of-file flag is set, returns non-zero.
 * \return If end-of-file flag is not set, returns zero.
 */
int bh_io_eof(bh_io_t *io)
{
    return (io->flags & BH_IO_EOF) != 0;
}

/**
 * Clears error of the \a io object.
 *
 * \param io    Pointer to the io object
 */
void bh_io_clear(bh_io_t *io)
{
    io->table->clear(io);
}

/**
 * \}
 */