/*
 * buffer.c -- generic memory buffer .
 *
 * Copyright (c) 2001-2008, NLnet Labs. All rights reserved.
 *
 * See LICENSE for the license.
 *
 */
/**
 * \file
 *
 * This file contains the definition of sldns_buffer, and functions to manipulate those.
 */
#include "config.h"
#include "sldns/sbuffer.h"
#include <stdarg.h>

sldns_buffer *
sldns_buffer_new(size_t capacity)
{
        sldns_buffer *buffer = (sldns_buffer*)malloc(sizeof(sldns_buffer));

        if (!buffer) {
                return NULL;
        }
        
        buffer->_data = (uint8_t *) malloc(capacity);
        if (!buffer->_data) {
                free(buffer);
                return NULL;
        }
        
        buffer->_position = 0;
        buffer->_limit = buffer->_capacity = capacity;
        buffer->_fixed = 0;
        buffer->_status_err = 0;
        
        sldns_buffer_invariant(buffer);
        
        return buffer;
}

void
sldns_buffer_new_frm_data(sldns_buffer *buffer, void *data, size_t size)
{
        assert(data != NULL);

        buffer->_position = 0; 
        buffer->_limit = buffer->_capacity = size;
        buffer->_fixed = 0;
        if (!buffer->_fixed && buffer->_data)
                free(buffer->_data);
        buffer->_data = malloc(size);
        if(!buffer->_data) {
                buffer->_status_err = 1;
                return;
        }
        memcpy(buffer->_data, data, size);
        buffer->_status_err = 0;
        
        sldns_buffer_invariant(buffer);
}

void
sldns_buffer_init_frm_data(sldns_buffer *buffer, void *data, size_t size)
{
        memset(buffer, 0, sizeof(*buffer));
        buffer->_data = data;
        buffer->_capacity = buffer->_limit = size;
        buffer->_fixed = 1;
}

int
sldns_buffer_set_capacity(sldns_buffer *buffer, size_t capacity)
{
        void *data;
        
        sldns_buffer_invariant(buffer);
        assert(buffer->_position <= capacity && !buffer->_fixed);

        data = (uint8_t *) realloc(buffer->_data, capacity);
        if (!data) {
                buffer->_status_err = 1;
                return 0;
        } else {
                buffer->_data = data;
                buffer->_limit = buffer->_capacity = capacity;
                return 1;
        }
}

int
sldns_buffer_reserve(sldns_buffer *buffer, size_t amount)
{
        sldns_buffer_invariant(buffer);
        assert(!buffer->_fixed);
        if (buffer->_capacity < buffer->_position + amount) {
                size_t new_capacity = buffer->_capacity * 3 / 2;

                if (new_capacity < buffer->_position + amount) {
                        new_capacity = buffer->_position + amount;
                }
                if (!sldns_buffer_set_capacity(buffer, new_capacity)) {
                        buffer->_status_err = 1;
                        return 0;
                }
        }
        buffer->_limit = buffer->_capacity;
        return 1;
}

int
sldns_buffer_printf(sldns_buffer *buffer, const char *format, ...)
{
        va_list args;
        int written = 0;
        size_t remaining;
        
        if (sldns_buffer_status_ok(buffer)) {
                sldns_buffer_invariant(buffer);
                assert(buffer->_limit == buffer->_capacity);

                remaining = sldns_buffer_remaining(buffer);
                va_start(args, format);
                written = vsnprintf((char *) sldns_buffer_current(buffer), remaining,
                                    format, args);
                va_end(args);
                if (written == -1) {
                        buffer->_status_err = 1;
                        return -1;
                }
                buffer->_position += written;
        }
        return written;
}

void
sldns_buffer_free(sldns_buffer *buffer)
{
        if (!buffer) {
                return;
        }

        if (!buffer->_fixed)
                free(buffer->_data);

        free(buffer);
}

void 
sldns_buffer_copy(sldns_buffer* result, sldns_buffer* from)
{
        size_t tocopy = sldns_buffer_limit(from);

        if(tocopy > sldns_buffer_capacity(result))
                tocopy = sldns_buffer_capacity(result);
        sldns_buffer_clear(result);
        sldns_buffer_write(result, sldns_buffer_begin(from), tocopy);
        sldns_buffer_flip(result);
}