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.

Referenced by GNUNET_xmalloc_(), GNUNET_xmemdup_(), and GNUNET_xrealloc_().

INT_MAX

#define INT_MAX   0x7FFFFFFF

Definition at line 42 of file common_allocation.c.

Referenced by GCPP_update_score(), GNUNET_CRYPTO_ecc_dlog(), GNUNET_xgrow_(), GNUNET_xmemdup_(), handle_bobs_cryptodata_message(), is_before(), parse_definitions(), and transmit_client_response().

BAADFOOD_STR [1/2]

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

Definition at line 309 of file common_allocation.c.

BAADFOOD_STR [2/2]

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

Definition at line 309 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 66 of file common_allocation.c.

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

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

{
  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;
}

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 98 of file common_allocation.c.

References GNUNET_xmalloc_(), and ret.

{
  /* 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;
}

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 134 of file common_allocation.c.

References GNUNET_xmalloc_(), m, and ret.

{
  /* 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;
}

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 177 of file common_allocation.c.

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

{
  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);
#ifdef W32_MEM_LIMIT
  size += sizeof(size_t);
  if (mem_used + size > W32_MEM_LIMIT)
    return NULL;
#endif
  GNUNET_assert_at (size < INT_MAX, filename, linenumber);
  ret = malloc (size);
  if (ret == NULL)
  {
    LOG_STRERROR (GNUNET_ERROR_TYPE_ERROR, "malloc");
    GNUNET_assert (0);
  }
#ifdef W32_MEM_LIMIT
  *((size_t *) ret) = size;
  ret = &((size_t *) ret)[1];
  mem_used += size;
#endif
  GNUNET_memcpy (ret, buf, size);
  return ret;
}

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 219 of file common_allocation.c.

References result, and size.

Referenced by GNUNET_xmalloc_().

{
  void *result;

  (void) filename;
  (void) linenumber;
#ifdef W32_MEM_LIMIT
  size += sizeof(size_t);
  if (mem_used + size > W32_MEM_LIMIT)
    return NULL;
#endif

  result = malloc (size);
  if (NULL == result)
    return NULL;
  memset (result, 0, size);

#ifdef W32_MEM_LIMIT
  *((size_t *) result) = size;
  result = &((size_t *) result)[1];
  mem_used += size;
#endif

  return result;
}

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 258 of file common_allocation.c.

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

{
  (void) filename;
  (void) linenumber;

#ifdef W32_MEM_LIMIT
  n += sizeof(size_t);
  ptr = &((size_t *) ptr)[-1];
  mem_used = mem_used - *((size_t *) ptr) + n;
#endif
#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);
  }
#ifdef W32_MEM_LIMIT
  ptr = &((size_t *) ptr)[1];
#endif
  return ptr;
}

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 330 of file common_allocation.c.

References GNUNET_memcpy, and GNUNET_ntohll().

Referenced by GNUNET_xgrow_().

{
  if (NULL == ptr)
    return;
#ifdef W32_MEM_LIMIT
  ptr = &((size_t *) ptr)[-1];
  mem_used -= *((size_t *) ptr);
#endif
#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);
}

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 366 of file common_allocation.c.

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

{
  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;
}

Here is the call graph for this function:

strnlen()

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

static

Definition at line 381 of file common_allocation.c.

References e.

Referenced by GNUNET_strlcpy(), and GNUNET_xstrndup_().

{
  const char *e;

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

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 405 of file common_allocation.c.

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

{
  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;
}

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 436 of file common_allocation.c.

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

{
  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;
}

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 479 of file common_allocation.c.

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

{
  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;
}

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 506 of file common_allocation.c.

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

{
  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;
}

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 548 of file common_allocation.c.

References testconfigure::b, GNUNET_NO, and GNUNET_YES.

{
  const char *b = a;

  for (size_t i = 0; i < n; i++)
    if (b[i])
      return GNUNET_NO;
  return GNUNET_YES;
}