#endif
#define LOG(kind, ...) \
- GNUNET_log_from(kind, "util-common-allocation", __VA_ARGS__)
+ GNUNET_log_from (kind, "util-common-allocation", __VA_ARGS__)
#define LOG_STRERROR(kind, syscall) \
- GNUNET_log_from_strerror(kind, "util-common-allocation", syscall)
+ GNUNET_log_from_strerror (kind, "util-common-allocation", syscall)
#ifndef INT_MAX
#define INT_MAX 0x7FFFFFFF
* @return pointer to size bytes of memory
*/
void *
-GNUNET_xmalloc_(size_t size, const char *filename, int linenumber)
+GNUNET_xmalloc_ (size_t size, const char *filename, int linenumber)
{
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);
+ 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);
- }
+ {
+ LOG_STRERROR (GNUNET_ERROR_TYPE_ERROR, "malloc");
+ GNUNET_assert (0);
+ }
return ret;
}
* @return allocated memory, never NULL
*/
void **
-GNUNET_xnew_array_2d_(size_t n,
- size_t m,
- size_t elementSize,
- const char *filename,
- int linenumber)
+GNUNET_xnew_array_2d_ (size_t n,
+ size_t m,
+ size_t elementSize,
+ const char *filename,
+ int linenumber)
{
/* 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);
+ 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;
+ 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;
}
* @return allocated memory, never NULL
*/
void ***
-GNUNET_xnew_array_3d_(size_t n,
- size_t m,
- size_t o,
- size_t elementSize,
- const char *filename,
- int linenumber)
+GNUNET_xnew_array_3d_ (size_t n,
+ size_t m,
+ size_t o,
+ size_t elementSize,
+ const char *filename,
+ int linenumber)
{
/* 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);
+ 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 acuracy */
- 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;
+ {
+ /* need to cast to (char *) temporarily for byte level acuracy */
+ 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;
}
* @return allocated memory, never NULL
*/
void *
-GNUNET_xmemdup_(const void *buf,
- size_t size,
- const char *filename,
- int linenumber)
+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 <= 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);
+ GNUNET_assert_at (size < INT_MAX, filename, linenumber);
+ ret = malloc (size);
if (ret == NULL)
- {
- LOG_STRERROR(GNUNET_ERROR_TYPE_ERROR, "malloc");
- GNUNET_assert(0);
- }
+ {
+ LOG_STRERROR (GNUNET_ERROR_TYPE_ERROR, "malloc");
+ GNUNET_assert (0);
+ }
#ifdef W32_MEM_LIMIT
- *((size_t *)ret) = size;
- ret = &((size_t *)ret)[1];
+ *((size_t *) ret) = size;
+ ret = &((size_t *) ret)[1];
mem_used += size;
#endif
- GNUNET_memcpy(ret, buf, size);
+ GNUNET_memcpy (ret, buf, size);
return ret;
}
* @return pointer to size bytes of memory, NULL if we do not have enough memory
*/
void *
-GNUNET_xmalloc_unchecked_(size_t size, const char *filename, int linenumber)
+GNUNET_xmalloc_unchecked_ (size_t size, const char *filename, int linenumber)
{
void *result;
- (void)filename;
- (void)linenumber;
+ (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);
+ result = malloc (size);
if (NULL == result)
return NULL;
- memset(result, 0, size);
+ memset (result, 0, size);
#ifdef W32_MEM_LIMIT
- *((size_t *)result) = size;
- result = &((size_t *)result)[1];
+ *((size_t *) result) = size;
+ result = &((size_t *) result)[1];
mem_used += size;
#endif
* @return pointer to size bytes of memory
*/
void *
-GNUNET_xrealloc_(void *ptr, size_t n, const char *filename, int linenumber)
+GNUNET_xrealloc_ (void *ptr, size_t n, const char *filename, int linenumber)
{
- (void)filename;
- (void)linenumber;
+ (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;
+ ptr = &((size_t *) ptr)[-1];
+ mem_used = mem_used - *((size_t *) ptr) + n;
#endif
- ptr = realloc(ptr, n);
- if ((NULL == ptr) && (n > 0))
+#if defined(M_SIZE)
+#if ENABLE_POISONING
+ {
+ uint64_t *base = ptr;
+ size_t s = M_SIZE (ptr);
+
+ if (s > n)
{
- LOG_STRERROR(GNUNET_ERROR_TYPE_ERROR, "realloc");
- GNUNET_assert(0);
+ 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];
+ ptr = &((size_t *) ptr)[1];
#endif
return ptr;
}
#include <malloc_np.h>
#endif
#if HAVE_MALLOC_USABLE_SIZE
-#define M_SIZE(p) malloc_usable_size(p)
+#define M_SIZE(p) malloc_usable_size (p)
#elif HAVE_MALLOC_SIZE
-#define M_SIZE(p) malloc_size(p)
+#define M_SIZE(p) malloc_size (p)
#endif
/**
* @param linenumber where in the code was the call to GNUNET_free
*/
void
-GNUNET_xfree_(void *ptr, const char *filename, int linenumber)
+GNUNET_xfree_ (void *ptr, const char *filename, int linenumber)
{
- GNUNET_assert_at(NULL != ptr, filename, linenumber);
+ GNUNET_assert_at (NULL != ptr, filename, linenumber);
#ifdef W32_MEM_LIMIT
- ptr = &((size_t *)ptr)[-1];
- mem_used -= *((size_t *)ptr);
+ 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);
+ const uint64_t baadfood = GNUNET_ntohll (0xBAADF00DBAADF00DLL);
uint64_t *base = ptr;
- size_t s = M_SIZE(ptr);
- size_t i;
+ size_t s = M_SIZE (ptr);
- for (i = 0; i < s / 8; i++)
+ for (size_t i = 0; i < s / 8; i++)
base[i] = baadfood;
- GNUNET_memcpy(&base[s / 8], &baadfood, s % 8);
+ GNUNET_memcpy (&base[s / 8], &baadfood, s % 8);
}
#endif
#endif
- free(ptr);
+ free (ptr);
}
* @return `strdup(@a str)`
*/
char *
-GNUNET_xstrdup_(const char *str, const char *filename, int linenumber)
+GNUNET_xstrdup_ (const char *str, const char *filename, int linenumber)
{
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);
+ GNUNET_assert_at (str != NULL, filename, linenumber);
+ slen = strlen (str) + 1;
+ res = GNUNET_xmalloc_ (slen, filename, linenumber);
+ GNUNET_memcpy (res, str, slen);
return res;
}
-#if !HAVE_STRNLEN
+#if ! HAVE_STRNLEN
static size_t
-strnlen(const char *s, size_t n)
+strnlen (const char *s, size_t n)
{
const char *e;
- e = memchr(s, '\0', n);
+ e = memchr (s, '\0', n);
if (NULL == e)
return n;
return e - s;
}
+
+
#endif
* @return `strndup(@a str,@a len)`
*/
char *
-GNUNET_xstrndup_(const char *str,
- size_t len,
- const char *filename,
- int linenumber)
+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);
+ 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;
}
* @param linenumber where in the code was the call to GNUNET_array_grow()
*/
void
-GNUNET_xgrow_(void **old,
- size_t elementSize,
- unsigned int *oldCount,
- unsigned int newCount,
- const char *filename,
- int linenumber)
+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(INT_MAX / elementSize > newCount, filename, linenumber);
+ GNUNET_assert_at (INT_MAX / elementSize > newCount, filename, linenumber);
size = newCount * elementSize;
if (0 == size)
- {
- tmp = NULL;
- }
+ {
+ tmp = NULL;
+ }
else
+ {
+ tmp = GNUNET_xmalloc_ (size, filename, linenumber);
+ if (NULL != *old)
{
- tmp = GNUNET_xmalloc_(size, filename, linenumber);
- if (NULL != *old)
- {
- GNUNET_memcpy(tmp, *old, elementSize * GNUNET_MIN(*oldCount, newCount));
- }
+ GNUNET_memcpy (tmp, *old, elementSize * GNUNET_MIN (*oldCount, newCount));
}
+ }
if (NULL != *old)
- {
- GNUNET_xfree_(*old, filename, linenumber);
- }
+ {
+ GNUNET_xfree_ (*old, filename, linenumber);
+ }
*old = tmp;
*oldCount = newCount;
}
* @return number of bytes in `*@a buf`, excluding 0-termination
*/
int
-GNUNET_asprintf(char **buf, const char *format, ...)
+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 = vsprintf(*buf, format, args);
- va_end(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;
}
* @return number of bytes written to buf or negative value on error
*/
int
-GNUNET_snprintf(char *buf, size_t size, const char *format, ...)
+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));
+ va_start (args, format);
+ ret = vsnprintf (buf, size, format, args);
+ va_end (args);
+ GNUNET_assert ((ret >= 0) && (((size_t) ret) < size));
return ret;
}
* @return duplicate of the message
*/
struct GNUNET_MessageHeader *
-GNUNET_copy_message(const struct GNUNET_MessageHeader *msg)
+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);
+ msize = ntohs (msg->size);
+ GNUNET_assert (msize >= sizeof(struct GNUNET_MessageHeader));
+ ret = GNUNET_malloc (msize);
+ GNUNET_memcpy (ret, msg, msize);
return ret;
}
projects / oweals / gnunet.git / blobdiff