/*

 * Copyright (C) 2002 Cisco Systems, Inc.

 * maintained by linux-iscsi-devel@lists.sourceforge.net

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License as published

 * by the Free Software Foundation; either version 2 of the License, or

 * (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful, but

 * WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

 * General Public License for more details.

 *

 * See the file COPYING included with this distribution for more details.

 */

#include <stdio.h>

#include <stdlib.h>

#include <stdarg.h>

#include <string.h>

#include <unistd.h>

#include <errno.h>

#include <sys/param.h>

#include "local_strings.h"

#include "log.h"

int str_init_buffer(struct str_buffer *s, size_t initial_allocation)

{

	if (s) {

		memset(s, 0, sizeof (*s));

		s->buffer = NULL;

		if (initial_allocation) {

			s->buffer = malloc(initial_allocation);

			if (s->buffer) {

				s->allocated_length = initial_allocation;

				memset(s->buffer, 0, initial_allocation);

			}

		}

		s->data_length = 0;

		return 1;

	}

	return 0;

}

struct str_buffer *str_alloc_buffer(size_t initial_allocation)

{

	struct str_buffer *s = calloc(1, sizeof (*s));

	if (s)

		str_init_buffer(s, initial_allocation);

	return s;

}

void str_free_buffer(struct str_buffer *s)

{

	if (s) {

		if (s->buffer) {

			free(s->buffer);

			s->buffer = NULL;

		}

		s->allocated_length = 0;

		s->data_length = 0;

	}

}

int str_enlarge_data(struct str_buffer *s, int length)

{

	void *new_buf;

	if (s) {

		s->data_length += length;

		if (s->data_length > s->allocated_length) {

			log_debug(7, "enlarge buffer from %zu to %zu",

				  s->allocated_length, s->data_length);

			new_buf = realloc(s->buffer, s->data_length);

			if (!new_buf) {

				/* too big */

				log_error("enlarged buffer %p to %d data "

					  "bytes, with only %d bytes of buffer "

					  "space", s, (int)s->data_length,

					   (int)s->allocated_length);

				return ENOMEM;

			}

			s->buffer = new_buf;

			memset(s->buffer + s->allocated_length, 0,

			       s->data_length - s->allocated_length);

			s->allocated_length = s->data_length;

		}

	}

	return 0;

}

void str_remove_initial(struct str_buffer *s, int length)

{

	char *remaining;

	int amount;

	if (s && length) {

		remaining = s->buffer + length;

		amount = s->data_length - length;

		if (amount < 0)

			amount = 0;

		if (amount)

			memmove(s->buffer, remaining, amount);

		s->data_length = amount;

		s->buffer[amount] = '\0';

	}

}

/* truncate the data length down */

void str_truncate_buffer(struct str_buffer *s, size_t length)

{

	if (s) {

		if (!s->data_length)

			return;

		if (length <= s->data_length) {

			s->data_length = length;

			s->buffer[s->data_length] = '\0';

		} else if (length <= s->allocated_length) {

			/* clear the data, and declare the

			 * data length to be larger

			 */

			memset(s->buffer + s->data_length, 0,

			       length - s->data_length);

			s->data_length = length;

		} else {

			log_error(

			       "couldn't truncate data buffer to length %d, "

			       "only allocated %d",

			       (int)length, (int)s->allocated_length);

		}

	}

}

char *str_buffer_data(struct str_buffer *s)

{

	if (s)

		return s->buffer;

	else

		return NULL;

}

size_t str_data_length(struct str_buffer * s)

{

	if (s)

		return s->data_length;

	else

		return 0;

}

size_t str_unused_length(struct str_buffer * s)

{

	if (s)

		return s->allocated_length - s->data_length;

	else

		return 0;

}