common_allocation.c File Reference

wrapper around malloc/free More...

#include "platform.h"
#include "gnunet_util_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.
void *	GNUNET_xmemdup_ (const void *buf, size_t size, const char *filename, int linenumber)
	Allocate and initialize memory.
void *	GNUNET_xmalloc_unchecked_ (size_t size, const char *filename, int linenumber)
	Allocate memory.
void *	GNUNET_xrealloc_ (void *ptr, size_t n, const char *filename, int linenumber)
	Reallocate memory.
void	GNUNET_xfree_ (void *ptr, const char *filename, int linenumber)
	Free memory.
char *	GNUNET_xstrdup_ (const char *str, const char *filename, int linenumber)
	Dup a string.
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.
void	GNUNET_xgrow_ (void **old, size_t elementSize, unsigned int *oldCount, unsigned int newCount, const char *filename, int linenumber)
	Grow an array, the new elements are zeroed out.
int	GNUNET_asprintf (char **buf, const char *format,...)
int	GNUNET_snprintf (char *buf, size_t size, const char *format,...)
struct GNUNET_MessageHeader *	GNUNET_copy_message (const struct GNUNET_MessageHeader *msg)
	Create a copy of the given message.
bool	GNUNET_is_zero_ (const void *a, size_t n)
	Check that memory in a is all zeros.

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 36 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;
}
 
 
void *
GNUNET_xmemdup_ (const void *buf,
                 size_t size,
                 const char *filename,
                 int linenumber)
{
  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 (NULL == ret)
  {
    LOG_STRERROR (GNUNET_ERROR_TYPE_ERROR,
                  "malloc");
    GNUNET_assert (0);
  }
  GNUNET_memcpy (ret,
                 buf,
                 size);
  return ret;
}
 
 
void *
GNUNET_xmalloc_unchecked_ (size_t size,
                           const char *filename,
                           int linenumber)
{
  void *result;
 
  (void) filename;
  (void) linenumber;
  result = malloc (size);
  if (NULL == result)
    return NULL;
  memset (result,
          0,
          size);
  return result;
}
 
 
void *
GNUNET_xrealloc_ (void *ptr,
                  size_t n,
                  const char *filename,
                  int linenumber)
{
  (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;
}
 
 
#if __BYTE_ORDER == __LITTLE_ENDIAN
#define BAADFOOD_STR "\x0D\xF0\xAD\xBA"
#endif
#if __BYTE_ORDER == __BIG_ENDIAN
#define BAADFOOD_STR "\xBA\xAD\xF0\x0D"
#endif
 
#if HAVE_MALLOC_NP_H
#include <malloc_np.h>
#endif
#if HAVE_MALLOC_USABLE_SIZE
#define M_SIZE(p) malloc_usable_size (p)
#elif HAVE_MALLOC_SIZE
#define M_SIZE(p) malloc_size (p)
#endif
 
void
GNUNET_xfree_ (void *ptr,
               const char *filename,
               int linenumber)
{
  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);
}
 
 
char *
GNUNET_xstrdup_ (const char *str,
                 const char *filename,
                 int linenumber)
{
  size_t slen = strlen (str) + 1;
  char *res;
 
  GNUNET_assert_at (str != NULL,
                    filename,
                    linenumber);
  res = GNUNET_xmalloc_ (slen,
                         filename,
                         linenumber);
  GNUNET_memcpy (res,
                 str,
                 slen);
  return res;
}
 
 
#if ! HAVE_STRNLEN
static size_t
strnlen (const char *s,
         size_t n)
{
  const char *e;
 
  e = memchr (s,
              '\0',
              n);
  if (NULL == e)
    return n;
  return e - s;
}
 
 
#endif
 
 
char *
GNUNET_xstrndup_ (const char *str,
                  size_t len,
                  const char *filename,
                  int linenumber)
{
  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;
}
 
 
void
GNUNET_xgrow_ (void **old,
               size_t elementSize,
               unsigned int *oldCount,
               unsigned int newCount,
               const char *filename,
               int linenumber)
{
  void *tmp;
  size_t size;
 
  GNUNET_assert_at (elementSize > 0,  filename, linenumber);
  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;
}
 
 
int
GNUNET_asprintf (char **buf,
                 const char *format,
                 ...)
{
  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 = vsnprintf (*buf,
                   ret + 1,
                   format,
                   args);
  va_end (args);
  return ret;
}
 
 
int
GNUNET_snprintf (char *buf,
                 size_t size,
                 const char *format,
                 ...)
{
  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;
}
 
 
struct GNUNET_MessageHeader *
GNUNET_copy_message (const struct GNUNET_MessageHeader *msg)
{
  struct GNUNET_MessageHeader *ret;
  uint16_t msize;
 
  msize = ntohs (msg->size);
  GNUNET_assert (msize >= sizeof(struct GNUNET_MessageHeader));
  ret = GNUNET_malloc (msize);
  GNUNET_memcpy (ret, msg, msize);
  return ret;
}
 
 
bool
GNUNET_is_zero_ (const void *a,
                 size_t n)
{
  const char *b = a;
 
  for (size_t i = 0; i < n; i++)
    if (b[i])
      return false;
  return true;
}
 
 
/* end of common_allocation.c */

LOG_STRERROR

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

Definition at line 39 of file common_allocation.c.

INT_MAX

#define INT_MAX   0x7FFFFFFF

Definition at line 43 of file common_allocation.c.

BAADFOOD_STR [1/2]

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

Definition at line 166 of file common_allocation.c.

BAADFOOD_STR [2/2]

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

Definition at line 166 of file common_allocation.c.

Function Documentation

strnlen()

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

static

Definition at line 228 of file common_allocation.c.

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

Referenced by GNUNET_strlcpy(), GNUNET_xstrndup_(), handle_gns_resolution_result(), and send_init().

Here is the caller graph for this function:

GNUNET_asprintf()

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

Definition at line 312 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 = vsnprintf (*buf,
                   ret + 1,
                   format,
                   args);
  va_end (args);
  return ret;
}

References GNUNET_assert, GNUNET_malloc, and ret.

GNUNET_snprintf()

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

Definition at line 339 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 GNUNET_assert, ret, and size.