common_allocation.c File Reference

wrapper around malloc/free More...

#include "platform.h"
#include "gnunet_crypto_lib.h"

Include dependency graph for common_allocation.c:

Go to the source code of this file.

Macros
#define	LOG(kind, ...)    GNUNET_log_from (kind, "util-common-allocation", __VA_ARGS__)
#define	LOG_STRERROR(kind, syscall)    GNUNET_log_from_strerror (kind, "util-common-allocation", syscall)
#define	INT_MAX   0x7FFFFFFF
#define	BAADFOOD_STR   "\x0D\xF0\xAD\xBA"
#define	BAADFOOD_STR   "\xBA\xAD\xF0\x0D"

Functions
void *	GNUNET_xmalloc_ (size_t size, const char *filename, int linenumber)
	Allocate memory. More...
void **	GNUNET_xnew_array_2d_ (size_t n, size_t m, size_t elementSize, const char *filename, int linenumber)
	Allocate memory for a two dimensional array in one block and set up pointers. More...
void ***	GNUNET_xnew_array_3d_ (size_t n, size_t m, size_t o, size_t elementSize, const char *filename, int linenumber)
	Allocate memory for a three dimensional array in one block and set up pointers. More...
void *	GNUNET_xmemdup_ (const void *buf, size_t size, const char *filename, int linenumber)
	Allocate and initialize memory. More...
void *	GNUNET_xmalloc_unchecked_ (size_t size, const char *filename, int linenumber)
	Wrapper around malloc(). More...
void *	GNUNET_xrealloc_ (void *ptr, size_t n, const char *filename, int linenumber)
	Reallocate memory. More...
void	GNUNET_xfree_ (void *ptr, const char *filename, int linenumber)
	Free memory. More...
char *	GNUNET_xstrdup_ (const char *str, const char *filename, int linenumber)
	Dup a string (same semantics as strdup). More...
static size_t	strnlen (const char *s, size_t n)
char *	GNUNET_xstrndup_ (const char *str, size_t len, const char *filename, int linenumber)
	Dup partially a string (same semantics as strndup). More...
void	GNUNET_xgrow_ (void **old, size_t elementSize, unsigned int *oldCount, unsigned int newCount, const char *filename, int linenumber)
	Grow an array. More...
int	GNUNET_asprintf (char **buf, const char *format,...)
	Like asprintf(), just portable. More...
int	GNUNET_snprintf (char *buf, size_t size, const char *format,...)
	Like snprintf(), just aborts if the buffer is of insufficient size. More...
struct GNUNET_MessageHeader *	GNUNET_copy_message (const struct GNUNET_MessageHeader *msg)
	Create a copy of the given message. More...
enum GNUNET_GenericReturnValue	GNUNET_is_zero_ (const void *a, size_t n)
	Check that memory in a is all zeros. More...

Detailed Description

wrapper around malloc/free

Author

Christian Grothoff

Definition in file common_allocation.c.

Macro Definition Documentation

LOG

#define LOG	(		kind,
			...
	)		GNUNET_log_from (kind, "util-common-allocation", __VA_ARGS__)

Definition at line 35 of file common_allocation.c.

LOG_STRERROR

#define LOG_STRERROR	(		kind,
			syscall
	)		GNUNET_log_from_strerror (kind, "util-common-allocation", syscall)

Definition at line 38 of file common_allocation.c.

INT_MAX

#define INT_MAX   0x7FFFFFFF

Definition at line 42 of file common_allocation.c.

BAADFOOD_STR [1/2]

#define BAADFOOD_STR   "\x0D\xF0\xAD\xBA"

Definition at line 273 of file common_allocation.c.

BAADFOOD_STR [2/2]

#define BAADFOOD_STR   "\xBA\xAD\xF0\x0D"

Definition at line 273 of file common_allocation.c.

Function Documentation

GNUNET_xmalloc_()

void* GNUNET_xmalloc_	(	size_t	size,
		const char *	filename,
		int	linenumber
	)

Allocate memory.

Checks the return value, aborts if no more memory is available.

Parameters

size	how many bytes of memory to allocate, do NOT use this function (or GNUNET_malloc()) to allocate more than several MB of memory, if you are possibly needing a very large chunk use GNUNET_xmalloc_unchecked_() instead.
filename	where in the code was the call to GNUNET_malloc()
linenumber	where in the code was the call to GNUNET_malloc()

Returns

pointer to size bytes of memory

Definition at line 59 of file common_allocation.c.

{
  void *ret;
 
  /* As a security precaution, we generally do not allow very large
   * allocations using the default 'GNUNET_malloc()' macro */
  GNUNET_assert_at (size <= GNUNET_MAX_MALLOC_CHECKED, filename, linenumber);
  ret = GNUNET_xmalloc_unchecked_ (size, filename, linenumber);
  if (NULL == ret)
  {
    LOG_STRERROR (GNUNET_ERROR_TYPE_ERROR, "malloc");
    GNUNET_assert (0);
  }
  return ret;
}

References filename, GNUNET_assert, GNUNET_assert_at, GNUNET_ERROR_TYPE_ERROR, GNUNET_MAX_MALLOC_CHECKED, GNUNET_xmalloc_unchecked_(), LOG_STRERROR, ret, and size.

Referenced by GNUNET_xgrow_(), GNUNET_xnew_array_2d_(), GNUNET_xnew_array_3d_(), GNUNET_xstrdup_(), and GNUNET_xstrndup_().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_xnew_array_2d_()

void** GNUNET_xnew_array_2d_	(	size_t	n,
		size_t	m,
		size_t	elementSize,
		const char *	filename,
		int	linenumber
	)

Allocate memory for a two dimensional array in one block and set up pointers.

Aborts if no more memory is available. Don't use GNUNET_xnew_array_2d_ directly. Use the GNUNET_new_array_2d macro. The memory of the elements will be zero'ed out.

Parameters

n	size of the first dimension
m	size of the second dimension
elementSize	size of a single element in bytes
filename	where is this call being made (for debugging)
linenumber	line where this call is being made (for debugging)

Returns

allocated memory, never NULL

Definition at line 91 of file common_allocation.c.

{
  /* use char pointer internally to avoid void pointer arithmetic warnings */
  char **ret = GNUNET_xmalloc_ (n * sizeof(void *)     /* 1. dim header */
                                + n * m * elementSize, /* element data */
                                filename,
                                linenumber);
 
  for (size_t i = 0; i < n; i++)
    ret[i] = (char *) ret    /* base address */
             + n * sizeof(void *)  /* skip 1. dim header */
             + i * m * elementSize; /* skip to 2. dim row header */
  return (void **) ret;
}

References filename, GNUNET_xmalloc_(), m, and ret.

Here is the call graph for this function:

GNUNET_xnew_array_3d_()

void*** GNUNET_xnew_array_3d_	(	size_t	n,
		size_t	m,
		size_t	o,
		size_t	elementSize,
		const char *	filename,
		int	linenumber
	)

Allocate memory for a three dimensional array in one block and set up pointers.

Aborts if no more memory is available. Don't use GNUNET_xnew_array_3d_ directly. Use the GNUNET_new_array_3d macro. The memory of the elements will be zero'ed out.

Parameters

n	size of the first dimension
m	size of the second dimension
o	size of the third dimension
elementSize	size of a single element in bytes
filename	where is this call being made (for debugging)
linenumber	line where this call is being made (for debugging)

Returns

allocated memory, never NULL

Definition at line 127 of file common_allocation.c.

{
  /* use char pointer internally to avoid void pointer arithmetic warnings */
  char ***ret = GNUNET_xmalloc_ (n * sizeof(void **)     /* 1. dim header */
                                 + n * m * sizeof(void *)    /* 2. dim header */
                                 + n * m * o * elementSize, /* element data */
                                 filename,
                                 linenumber);
 
  for (size_t i = 0; i < n; i++)
  {
    /* need to cast to (char *) temporarily for byte level accuracy */
    ret[i] = (char **) ((char *) ret   /* base address */
                        + n * sizeof(void **)  /* skip 1. dim header */
                        + i * m * sizeof(void *)); /* skip to 2. dim header */
    for (size_t j = 0; j < m; j++)
      ret[i][j] = (char *) ret    /* base address */
                  + n * sizeof(void **)   /* skip 1. dim header */
                  + n * m * sizeof(void *)   /* skip 2. dim header */
                  + i * m * o * elementSize   /* skip to 2. dim part */
                  + j * o * elementSize; /* skip to 3. dim row data */
  }
  return (void ***) ret;
}

References filename, GNUNET_xmalloc_(), m, and ret.

Here is the call graph for this function:

GNUNET_xmemdup_()

void* GNUNET_xmemdup_	(	const void *	buf,
		size_t	size,
		const char *	filename,
		int	linenumber
	)

Allocate and initialize memory.

Checks the return value, aborts if no more memory is available. Don't use GNUNET_xmemdup_() directly. Use the GNUNET_memdup() macro.

Parameters

buf	buffer to initialize from (must contain size bytes)
size	number of bytes to allocate
filename	where is this call being made (for debugging)
linenumber	line where this call is being made (for debugging)

Returns

allocated memory, never NULL

Definition at line 170 of file common_allocation.c.

{
  void *ret;
 
  /* As a security precaution, we generally do not allow very large
   * allocations here */
  GNUNET_assert_at (size <= GNUNET_MAX_MALLOC_CHECKED, filename, linenumber);
  GNUNET_assert_at (size < INT_MAX, filename, linenumber);
  ret = malloc (size);
  if (ret == NULL)
  {
    LOG_STRERROR (GNUNET_ERROR_TYPE_ERROR, "malloc");
    GNUNET_assert (0);
  }
  GNUNET_memcpy (ret, buf, size);
  return ret;
}

References buf, filename, GNUNET_assert, GNUNET_assert_at, GNUNET_ERROR_TYPE_ERROR, GNUNET_MAX_MALLOC_CHECKED, GNUNET_memcpy, INT_MAX, LOG_STRERROR, ret, and size.

GNUNET_xmalloc_unchecked_()

void* GNUNET_xmalloc_unchecked_	(	size_t	size,
		const char *	filename,
		int	linenumber
	)

Wrapper around malloc().

Allocate memory.

Allocates size bytes of memory. The memory will be zero'ed out.

Parameters

size	the number of bytes to allocate
filename	where in the code was the call to GNUNET_malloc_unchecked()
linenumber	where in the code was the call to GNUNET_malloc_unchecked()

Returns

pointer to size bytes of memory, NULL if we do not have enough memory

Definition at line 202 of file common_allocation.c.

{
  void *result;
 
  (void) filename;
  (void) linenumber;
 
  result = malloc (size);
  if (NULL == result)
    return NULL;
  memset (result, 0, size);
 
  return result;
}

References filename, result, and size.

Referenced by GNUNET_xmalloc_().

Here is the caller graph for this function:

GNUNET_xrealloc_()

void* GNUNET_xrealloc_	(	void *	ptr,
		size_t	n,
		const char *	filename,
		int	linenumber
	)

Reallocate memory.

Checks the return value, aborts if no more memory is available. The content of the intersection of the new and old size will be unchanged.

Parameters

ptr	the pointer to reallocate
n	how many bytes of memory to allocate
filename	where in the code was the call to GNUNET_realloc()
linenumber	where in the code was the call to GNUNET_realloc()

Returns

pointer to size bytes of memory

Definition at line 230 of file common_allocation.c.

{
  (void) filename;
  (void) linenumber;
 
#if defined(M_SIZE)
#if ENABLE_POISONING
  {
    uint64_t *base = ptr;
    size_t s = M_SIZE (ptr);
 
    if (s > n)
    {
      const uint64_t baadfood = GNUNET_ntohll (0xBAADF00DBAADF00DLL);
      char *cbase = ptr;
 
      GNUNET_memcpy (&cbase[n],
                     &baadfood,
                     GNUNET_MIN (8 - (n % 8),
                                 s - n));
      for (size_t i = 1 + (n + 7) / 8; i < s / 8; i++)
        base[i] = baadfood;
      GNUNET_memcpy (&base[s / 8],
                     &baadfood,
                     s % 8);
    }
  }
#endif
#endif
  ptr = realloc (ptr, n);
  if ((NULL == ptr) && (n > 0))
  {
    LOG_STRERROR (GNUNET_ERROR_TYPE_ERROR, "realloc");
    GNUNET_assert (0);
  }
  return ptr;
}

References filename, GNUNET_assert, GNUNET_ERROR_TYPE_ERROR, GNUNET_memcpy, GNUNET_MIN, GNUNET_ntohll(), and LOG_STRERROR.

Here is the call graph for this function:

GNUNET_xfree_()

void GNUNET_xfree_	(	void *	ptr,
		const char *	filename,
		int	linenumber
	)

Free memory.

Merely a wrapper for the case that we want to keep track of allocations.

Parameters

ptr	the pointer to free
filename	where in the code was the call to GNUNET_free()
linenumber	where in the code was the call to GNUNET_free()

Definition at line 294 of file common_allocation.c.

{
  if (NULL == ptr)
    return;
#if defined(M_SIZE)
#if ENABLE_POISONING
  {
    const uint64_t baadfood = GNUNET_ntohll (0xBAADF00DBAADF00DLL);
    uint64_t *base = ptr;
    size_t s = M_SIZE (ptr);
 
    for (size_t i = 0; i < s / 8; i++)
      base[i] = baadfood;
    GNUNET_memcpy (&base[s / 8], &baadfood, s % 8);
  }
#endif
#endif
  free (ptr);
}

References GNUNET_memcpy, and GNUNET_ntohll().

Referenced by GNUNET_xgrow_().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_xstrdup_()

char* GNUNET_xstrdup_	(	const char *	str,
		const char *	filename,
		int	linenumber
	)

Dup a string (same semantics as strdup).

Dup a string.

Parameters

str	the string to dup
filename	where in the code was the call to GNUNET_strdup()
linenumber	where in the code was the call to GNUNET_strdup()

Returns

strdup(@a str)

Definition at line 326 of file common_allocation.c.

{
  char *res;
  size_t slen;
 
  GNUNET_assert_at (str != NULL, filename, linenumber);
  slen = strlen (str) + 1;
  res = GNUNET_xmalloc_ (slen, filename, linenumber);
  GNUNET_memcpy (res, str, slen);
  return res;
}

References filename, GNUNET_assert_at, GNUNET_memcpy, GNUNET_xmalloc_(), and res.

Here is the call graph for this function:

strnlen()

static size_t strnlen ( const char *  s, size_t  n  )

static

Definition at line 341 of file common_allocation.c.

{
  const char *e;
 
  e = memchr (s, '\0', n);
  if (NULL == e)
    return n;
  return e - s;
}

References e.

Referenced by GNUNET_strlcpy(), and GNUNET_xstrndup_().

Here is the caller graph for this function:

GNUNET_xstrndup_()

char* GNUNET_xstrndup_	(	const char *	str,
		size_t	len,
		const char *	filename,
		int	linenumber
	)

Dup partially a string (same semantics as strndup).

Dup partially a string.

Parameters

str	the string to dup
len	the length of the string to dup
filename	where in the code was the call to GNUNET_strndup()
linenumber	where in the code was the call to GNUNET_strndup()

Returns

strndup(@a str,@a len)

Definition at line 365 of file common_allocation.c.

{
  char *res;
 
  if (0 == len)
    return GNUNET_strdup ("");
  GNUNET_assert_at (NULL != str, filename, linenumber);
  len = strnlen (str, len);
  res = GNUNET_xmalloc_ (len + 1, filename, linenumber);
  GNUNET_memcpy (res, str, len);
  /* res[len] = '\0'; 'malloc' zeros out anyway */
  return res;
}

References filename, GNUNET_assert_at, GNUNET_memcpy, GNUNET_strdup, GNUNET_xmalloc_(), len, res, and strnlen().

Here is the call graph for this function:

GNUNET_xgrow_()

void GNUNET_xgrow_	(	void **	old,
		size_t	elementSize,
		unsigned int *	oldCount,
		unsigned int	newCount,
		const char *	filename,
		int	linenumber
	)

Grow an array.

Grow an array, the new elements are zeroed out.

Grows old by (*oldCount-newCount)*elementSize bytes and sets *oldCount to newCount.

Parameters

old	address of the pointer to the array *old may be NULL
elementSize	the size of the elements of the array
oldCount	address of the number of elements in the *old array
newCount	number of elements in the new array, may be 0
filename	where in the code was the call to GNUNET_array_grow()
linenumber	where in the code was the call to GNUNET_array_grow()

Definition at line 396 of file common_allocation.c.

{
  void *tmp;
  size_t size;
 
  GNUNET_assert_at (INT_MAX / elementSize > newCount, filename, linenumber);
  size = newCount * elementSize;
  if (0 == size)
  {
    tmp = NULL;
  }
  else
  {
    tmp = GNUNET_xmalloc_ (size, filename, linenumber);
    if (NULL != *old)
    {
      GNUNET_memcpy (tmp, *old, elementSize * GNUNET_MIN (*oldCount, newCount));
    }
  }
 
  if (NULL != *old)
  {
    GNUNET_xfree_ (*old, filename, linenumber);
  }
  *old = tmp;
  *oldCount = newCount;
}

References filename, GNUNET_assert_at, GNUNET_memcpy, GNUNET_MIN, GNUNET_xfree_(), GNUNET_xmalloc_(), INT_MAX, and size.

Here is the call graph for this function:

GNUNET_asprintf()

int GNUNET_asprintf	(	char **	buf,
		const char *	format,
			...
	)

Like asprintf(), just portable.

Parameters

buf	set to a buffer of sufficient size (allocated, caller must free)
format	format string (see printf(), fprintf(), etc.)
...	data for format string

Returns

number of bytes in *@a buf, excluding 0-termination

Definition at line 439 of file common_allocation.c.

{
  int ret;
  va_list args;
 
  va_start (args, format);
  ret = vsnprintf (NULL, 0, format, args);
  va_end (args);
  GNUNET_assert (ret >= 0);
  *buf = GNUNET_malloc (ret + 1);
  va_start (args, format);
  ret = vsprintf (*buf, format, args);
  va_end (args);
  return ret;
}

References consensus-simulation::args, buf, GNUNET_assert, GNUNET_malloc, and ret.

GNUNET_snprintf()

int GNUNET_snprintf	(	char *	buf,
		size_t	size,
		const char *	format,
			...
	)

Like snprintf(), just aborts if the buffer is of insufficient size.

Parameters

buf	pointer to buffer that is written to
size	number of bytes in buf
format	format strings
...	data for format string

Returns

number of bytes written to buf or negative value on error

Definition at line 466 of file common_allocation.c.

{
  int ret;
  va_list args;
 
  va_start (args, format);
  ret = vsnprintf (buf, size, format, args);
  va_end (args);
  GNUNET_assert ((ret >= 0) && (((size_t) ret) < size));
  return ret;
}

References consensus-simulation::args, buf, GNUNET_assert, ret, and size.

GNUNET_is_zero_()

enum GNUNET_GenericReturnValue GNUNET_is_zero_	(	const void *	a,
		size_t	n
	)

Check that memory in a is all zeros.

a must be a pointer.

Parameters

a	pointer to n bytes which should be tested for the entire memory being zero'ed out.
n	number of bytes in to be tested

Returns

GNUNET_YES if a is zero, GNUNET_NO otherwise

Definition at line 486 of file common_allocation.c.

{
  const char *b = a;
 
  for (size_t i = 0; i < n; i++)
    if (b[i])
      return GNUNET_NO;
  return GNUNET_YES;
}