ngircd-tor/src/ngircd/array.c

332 lines
5.8 KiB
C
Raw Normal View History

2005-07-07 20:38:14 +02:00
/*
* 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.
* Please read the file COPYING, README and AUTHORS for more information.
*
* libarray - dynamically allocate arrays.
2005-07-07 20:38:14 +02:00
* Copyright (c) 2005 Florian Westphal (westphal@foo.fh-furtwangen.de)
*/
/**
* @file
* Functions to dynamically allocate arrays.
2005-07-07 20:38:14 +02:00
*/
/* Additionan debug messages related to array handling: 0=off / 1=on */
#define DEBUG_ARRAY 0
2005-07-07 20:38:14 +02:00
#include "array.h"
#include <assert.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
2005-07-07 20:38:14 +02:00
#if DEBUG_ARRAY
# include "log.h"
#endif
2005-07-07 20:38:14 +02:00
#define array_UNUSABLE(x) ( !(x)->mem )
2005-07-07 23:26:31 +02:00
static bool
2005-08-30 15:36:32 +02:00
safemult_sizet(size_t a, size_t b, size_t *res)
2005-07-07 20:38:14 +02:00
{
size_t tmp = a * b;
2005-07-07 20:38:14 +02:00
if (b && (tmp / b != a))
2005-07-07 23:26:31 +02:00
return false;
2005-07-07 20:38:14 +02:00
*res = tmp;
2005-07-07 23:26:31 +02:00
return true;
2005-07-07 20:38:14 +02:00
}
void
array_init(array *a)
{
assert(a != NULL);
a->mem = NULL;
a->allocated = 0;
a->used = 0;
}
2005-07-07 20:38:14 +02:00
/* if realloc() fails, array_alloc return NULL. otherwise return pointer to elem pos in array */
void *
2005-08-30 15:36:32 +02:00
array_alloc(array * a, size_t size, size_t pos)
2005-07-07 20:38:14 +02:00
{
2005-08-30 15:36:32 +02:00
size_t alloc, pos_plus1 = pos + 1;
2005-07-07 20:38:14 +02:00
char *tmp;
assert(size > 0);
2005-07-07 20:38:14 +02:00
if (pos_plus1 == 0 || !safemult_sizet(size, pos_plus1, &alloc))
2005-07-07 20:38:14 +02:00
return NULL;
if (a->allocated < alloc) {
#if DEBUG_ARRAY
Log(LOG_DEBUG, "array_alloc(): changing size from %u to %u bytes.",
a->allocated, alloc);
2005-07-07 20:38:14 +02:00
#endif
tmp = realloc(a->mem, alloc);
if (!tmp)
return NULL;
a->mem = tmp;
a->allocated = alloc;
memset(a->mem + a->used, 0, a->allocated - a->used);
a->used = alloc;
}
assert(a->allocated >= a->used);
2005-07-07 20:38:14 +02:00
return a->mem + (pos * size);
}
/*return number of initialized ELEMS in a. */
2005-08-30 15:36:32 +02:00
size_t
array_length(const array * const a, size_t membersize)
2005-07-07 20:38:14 +02:00
{
assert(a != NULL);
assert(membersize > 0);
2005-07-07 20:38:14 +02:00
if (array_UNUSABLE(a))
return 0;
assert(a->allocated);
2005-07-07 20:38:14 +02:00
return membersize ? a->used / membersize : 0;
}
/* copy array src to array dest */
bool
array_copy(array * dest, const array * const src)
{
if (array_UNUSABLE(src))
return false;
assert(src->allocated);
2005-07-07 20:38:14 +02:00
return array_copyb(dest, src->mem, src->used);
}
2005-08-30 15:36:32 +02:00
/* return false on failure (realloc failure, invalid src/dest array) */
2005-07-07 20:38:14 +02:00
bool
2005-08-30 15:36:32 +02:00
array_copyb(array * dest, const char *src, size_t len)
2005-07-07 20:38:14 +02:00
{
assert(dest != NULL);
assert(src != NULL );
2005-07-07 20:38:14 +02:00
2005-08-30 15:36:32 +02:00
if (!src || !dest)
2005-07-07 20:38:14 +02:00
return false;
2005-08-30 15:36:32 +02:00
array_trunc(dest);
return array_catb(dest, src, len);
2005-07-07 20:38:14 +02:00
}
/* copy string to dest */
bool
array_copys(array * dest, const char *src)
{
return array_copyb(dest, src, strlen(src));
}
/* append len bytes from src to the array dest.
return false if we could not append all bytes (realloc failure, invalid src/dest array) */
bool
2005-08-30 15:36:32 +02:00
array_catb(array * dest, const char *src, size_t len)
2005-07-07 20:38:14 +02:00
{
2005-08-30 15:36:32 +02:00
size_t tmp;
size_t used;
2005-07-07 20:38:14 +02:00
char *ptr;
assert(dest != NULL);
assert(src != NULL);
2005-07-07 20:38:14 +02:00
if (!len)
return true;
if (!src || !dest)
return false;
used = dest->used;
tmp = used + len;
if (tmp < used || tmp < len) /* integer overflow */
return false;
if (!array_alloc(dest, 1, tmp))
return false;
ptr = dest->mem;
assert(ptr != NULL);
2005-07-07 20:38:14 +02:00
#if DEBUG_ARRAY
2005-07-07 20:38:14 +02:00
Log(LOG_DEBUG,
"array_catb(): appending %u bytes to array (now %u bytes in array).",
2005-07-07 20:38:14 +02:00
len, tmp);
#endif
memcpy(ptr + used, src, len);
dest->used = tmp;
return true;
}
/* append string to dest */
bool
array_cats(array * dest, const char *src)
{
return array_catb(dest, src, strlen(src));
}
/* append trailing NUL byte to array */
bool
array_cat0(array * a)
{
return array_catb(a, "", 1);
}
/* append trailing NUL byte to array, but do not count it. */
bool
array_cat0_temporary(array * a)
{
2005-08-28 14:18:50 +02:00
char *endpos = array_alloc(a, 1, array_bytes(a));
if (!endpos)
return false;
*endpos = '\0';
return true;
}
2005-07-07 20:38:14 +02:00
/* add contents of array src to array dest. */
bool
array_cat(array * dest, const array * const src)
{
if (array_UNUSABLE(src))
return false;
return array_catb(dest, src->mem, src->used);
}
/* return pointer to the element at pos.
return NULL if the array is unallocated, or if pos is larger than
the number of elements stored int the array. */
void *
2005-08-30 15:36:32 +02:00
array_get(array * a, size_t membersize, size_t pos)
2005-07-07 20:38:14 +02:00
{
2005-08-30 15:36:32 +02:00
size_t totalsize;
2006-12-17 23:52:43 +01:00
size_t posplus1 = pos + 1;
2005-07-07 20:38:14 +02:00
assert(membersize > 0);
assert(a != NULL);
2005-07-07 20:38:14 +02:00
2006-12-17 23:52:43 +01:00
if (!posplus1 || array_UNUSABLE(a))
2005-07-07 20:38:14 +02:00
return NULL;
2006-12-17 23:52:43 +01:00
if (!safemult_sizet(posplus1, membersize, &totalsize))
2005-07-07 20:38:14 +02:00
return NULL;
if (a->allocated < totalsize)
return NULL;
2006-12-17 23:52:43 +01:00
totalsize = pos * membersize;
return a->mem + totalsize;
2005-07-07 20:38:14 +02:00
}
void
array_free(array * a)
{
assert(a != NULL);
#if DEBUG_ARRAY
2005-07-07 20:38:14 +02:00
Log(LOG_DEBUG,
"array_free(): %u bytes free'd (%u bytes still used at time of free()).",
2005-07-07 20:38:14 +02:00
a->allocated, a->used);
#endif
free(a->mem);
a->mem = NULL;
a->allocated = 0;
a->used = 0;
}
void
array_free_wipe(array *a)
{
size_t bytes = a->allocated;
if (bytes)
memset(a->mem, 0, bytes);
array_free(a);
}
2005-07-07 20:38:14 +02:00
void *
array_start(const array * const a)
{
assert(a != NULL);
2005-07-07 20:38:14 +02:00
return a->mem;
}
void
array_trunc(array * a)
{
assert(a != NULL);
2005-07-07 20:38:14 +02:00
a->used = 0;
}
void
2005-08-30 15:36:32 +02:00
array_truncate(array * a, size_t membersize, size_t len)
2005-07-07 20:38:14 +02:00
{
2005-08-30 15:36:32 +02:00
size_t newlen;
assert(a != NULL);
2005-08-30 15:36:32 +02:00
if (!safemult_sizet(membersize, len, &newlen))
2005-07-07 20:38:14 +02:00
return;
if (newlen <= a->allocated)
a->used = newlen;
}
/* move elements starting at pos to beginning of array */
void
2005-08-30 15:36:32 +02:00
array_moveleft(array * a, size_t membersize, size_t pos)
2005-07-07 20:38:14 +02:00
{
2005-08-30 15:36:32 +02:00
size_t bytepos;
2005-07-07 20:38:14 +02:00
assert(a != NULL);
assert(membersize > 0);
2005-07-07 20:38:14 +02:00
2005-08-30 15:36:32 +02:00
if (!safemult_sizet(membersize, pos, &bytepos)) {
2005-07-07 20:38:14 +02:00
a->used = 0;
return;
}
if (!bytepos)
return; /* nothing to do */
#if DEBUG_ARRAY
2005-07-07 20:38:14 +02:00
Log(LOG_DEBUG,
"array_moveleft(): %u bytes used in array, starting at position %u.",
2005-07-07 20:38:14 +02:00
a->used, bytepos);
#endif
if (a->used <= bytepos) {
a->used = 0;
return;
}
a->used -= bytepos;
memmove(a->mem, a->mem + bytepos, a->used);
}
/* -eof- */