buf.c

/* 
 * Copyright (c) 2005-2012 by KoanLogic s.r.l. - All rights reserved.  
 */

#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <stdio.h>
#include <stdarg.h>
#include <u/libu.h>
#include <toolbox/buf.h>

struct u_buf_s
{
    char *data;     /* the memory buffer */
    size_t size;    /* bytes malloc'd for .data */
    size_t len;     /* bytes actually in use (always <= .size) */
};

int u_buf_reserve (u_buf_t *ubuf, size_t size)
{
    char *nbuf;

    dbg_err_if (ubuf == NULL);

    nop_return_if (size <= ubuf->size, 0);  /* nothing to do */
   
    /* size plus 1 char to store a '\0' */
    dbg_err_sif ((nbuf = u_realloc(ubuf->data, size + 1)) == NULL);

    /* buffer data will always be zero-terminated (but the len field will not
     * count the last '\0') */
    nbuf[size] = '\0';

    ubuf->data = nbuf;
    ubuf->size = size;

    return 0;
err:
    return ~0;
}

int u_buf_append (u_buf_t *ubuf, const void *data, size_t size)
{
    dbg_return_if (ubuf == NULL, ~0);
    dbg_return_if (data == NULL, ~0);
    dbg_return_if (size == 0, ~0);

    if (ubuf->size - ubuf->len < size)
    {
        /* buffer too small, resize generously */
        dbg_err_if (u_buf_reserve(ubuf, ubuf->size + ubuf->len + 2 * size));
    }
 
    memcpy(ubuf->data + ubuf->len, data, size);
    ubuf->len += size;

    /* zero term the buffer so it can be used (when applicable) as a string */
    ubuf->data[ubuf->len] = '\0';

    return 0;
err:
    return ~0;
}

int u_buf_load (u_buf_t *ubuf, const char *filename)
{
    struct stat st;
    FILE *fp = NULL;

    dbg_return_if (ubuf == NULL, ~0);
    dbg_return_if (filename == NULL, ~0);

    dbg_err_sif (stat(filename, &st) == -1);

    /* clear the current data */
    dbg_err_if (u_buf_clear(ubuf));

    /* be sure to have a big enough buffer */
    dbg_err_if (u_buf_reserve(ubuf, st.st_size));

    dbg_err_sifm ((fp = fopen(filename, "r")) == NULL, "%s", filename);

    /* fill the buffer with the whole file content */
    dbg_err_if (fread(ubuf->data, st.st_size, 1, fp) != 1);
    ubuf->len = st.st_size;

    (void) fclose(fp);

    return 0;
err:
    U_FCLOSE(fp);
    return ~0;
}

int u_buf_save (u_buf_t *ubuf, const char *filename)
{
    dbg_return_if (ubuf == NULL, ~0);
    dbg_return_if (filename == NULL, ~0);

    return u_data_dump(u_buf_ptr(ubuf), u_buf_len(ubuf), filename);
}

int u_buf_detach (u_buf_t *ubuf)
{
    dbg_return_if (ubuf == NULL, ~0);

    ubuf->data = NULL;
    ubuf->size = 0;
    ubuf->len = 0;

    return 0;
}

ssize_t u_buf_size (u_buf_t *ubuf)
{
    dbg_return_if (ubuf == NULL, -1);

    return ubuf->size;
}

ssize_t u_buf_len (u_buf_t *ubuf)
{
    dbg_return_if (ubuf == NULL, -1);

    return ubuf->len;
}

int u_buf_clear (u_buf_t *ubuf)
{
    dbg_return_if (ubuf == NULL, ~0);
    
    ubuf->len = 0;

    return 0;
}

int u_buf_set (u_buf_t *ubuf, const void *data, size_t size)
{
    dbg_return_if (ubuf == NULL, ~0);
    dbg_return_if (data == NULL, ~0);
    dbg_return_if (size == 0, ~0);

    dbg_err_if (u_buf_clear(ubuf));
    dbg_err_if (u_buf_append(ubuf, data, size));

    return 0;
err:
    return ~0;
}

void *u_buf_ptr (u_buf_t *ubuf)
{
    dbg_return_if (ubuf == NULL, NULL);
    
    return ubuf->data;
}

int u_buf_shrink(u_buf_t *ubuf, size_t newlen)
{
    dbg_err_if (ubuf == NULL);
    dbg_err_if (newlen > ubuf->len);

    ubuf->len = newlen;

    return 0;
err:
    return ~0;
}

int u_buf_free (u_buf_t *ubuf)
{
    dbg_return_if (ubuf == NULL, ~0);

    U_FREE(ubuf->data);
    u_free(ubuf);

    return 0;
}

int u_buf_printf (u_buf_t *ubuf, const char *fmt, ...)
{
    va_list ap;
    size_t sz, avail;

    dbg_return_if (ubuf == NULL, ~0);
    dbg_return_if (fmt == NULL, ~0);

again:
    va_start(ap, fmt); 

    avail = ubuf->size - ubuf->len; /* avail may be zero */

    /* write to the internal buffer of ubuf */
    dbg_err_if ((sz = vsnprintf(ubuf->data + ubuf->len, avail, fmt, ap)) <= 0);

    if (sz >= avail)
    {
        /* enlarge the buffer (make it at least 128 bytes bigger) */
        dbg_err_if (u_buf_reserve(ubuf, ubuf->len + U_MIN(128, sz + 1)));

        /* zero-term the buffer (vsnprintf has removed the last \0!) */
        ubuf->data[ubuf->len] = '\0';

        va_end(ap);

        /* try again with a bigger buffer */
        goto again;
    }

    /* update data length (don't include the '\0' in the size count) */
    ubuf->len += sz; 

    va_end(ap);

    return 0;
err:
    va_end(ap);
    return ~0;
}


int u_buf_create (u_buf_t **pubuf)
{
    u_buf_t *ubuf = NULL;

    dbg_return_if (pubuf == NULL, ~0);

    dbg_err_sif ((ubuf = u_zalloc(sizeof(u_buf_t))) == NULL);

    ubuf->len = 0;
    ubuf->size = 0;
    ubuf->data = NULL;

    *pubuf = ubuf;

    return 0;
err:
    return ~0;
}