aboutsummaryrefslogtreecommitdiff
path: root/src/util/common_allocation.c
diff options
context:
space:
mode:
Diffstat (limited to 'src/util/common_allocation.c')
-rw-r--r--src/util/common_allocation.c284
1 files changed, 142 insertions, 142 deletions
diff --git a/src/util/common_allocation.c b/src/util/common_allocation.c
index d8d6d639f..358c09808 100644
--- a/src/util/common_allocation.c
+++ b/src/util/common_allocation.c
@@ -33,10 +33,10 @@
33#endif 33#endif
34 34
35#define LOG(kind, ...) \ 35#define LOG(kind, ...) \
36 GNUNET_log_from(kind, "util-common-allocation", __VA_ARGS__) 36 GNUNET_log_from (kind, "util-common-allocation", __VA_ARGS__)
37 37
38#define LOG_STRERROR(kind, syscall) \ 38#define LOG_STRERROR(kind, syscall) \
39 GNUNET_log_from_strerror(kind, "util-common-allocation", syscall) 39 GNUNET_log_from_strerror (kind, "util-common-allocation", syscall)
40 40
41#ifndef INT_MAX 41#ifndef INT_MAX
42#define INT_MAX 0x7FFFFFFF 42#define INT_MAX 0x7FFFFFFF
@@ -63,19 +63,19 @@ static LONG mem_used = 0;
63 * @return pointer to size bytes of memory 63 * @return pointer to size bytes of memory
64 */ 64 */
65void * 65void *
66GNUNET_xmalloc_(size_t size, const char *filename, int linenumber) 66GNUNET_xmalloc_ (size_t size, const char *filename, int linenumber)
67{ 67{
68 void *ret; 68 void *ret;
69 69
70 /* As a security precaution, we generally do not allow very large 70 /* As a security precaution, we generally do not allow very large
71 * allocations using the default 'GNUNET_malloc()' macro */ 71 * allocations using the default 'GNUNET_malloc()' macro */
72 GNUNET_assert_at(size <= GNUNET_MAX_MALLOC_CHECKED, filename, linenumber); 72 GNUNET_assert_at (size <= GNUNET_MAX_MALLOC_CHECKED, filename, linenumber);
73 ret = GNUNET_xmalloc_unchecked_(size, filename, linenumber); 73 ret = GNUNET_xmalloc_unchecked_ (size, filename, linenumber);
74 if (NULL == ret) 74 if (NULL == ret)
75 { 75 {
76 LOG_STRERROR(GNUNET_ERROR_TYPE_ERROR, "malloc"); 76 LOG_STRERROR (GNUNET_ERROR_TYPE_ERROR, "malloc");
77 GNUNET_assert(0); 77 GNUNET_assert (0);
78 } 78 }
79 return ret; 79 return ret;
80} 80}
81 81
@@ -95,23 +95,23 @@ GNUNET_xmalloc_(size_t size, const char *filename, int linenumber)
95 * @return allocated memory, never NULL 95 * @return allocated memory, never NULL
96 */ 96 */
97void ** 97void **
98GNUNET_xnew_array_2d_(size_t n, 98GNUNET_xnew_array_2d_ (size_t n,
99 size_t m, 99 size_t m,
100 size_t elementSize, 100 size_t elementSize,
101 const char *filename, 101 const char *filename,
102 int linenumber) 102 int linenumber)
103{ 103{
104 /* use char pointer internally to avoid void pointer arithmetic warnings */ 104 /* use char pointer internally to avoid void pointer arithmetic warnings */
105 char **ret = GNUNET_xmalloc_(n * sizeof(void *) + /* 1. dim header */ 105 char **ret = GNUNET_xmalloc_ (n * sizeof(void *) /* 1. dim header */
106 n * m * elementSize, /* element data */ 106 + n * m * elementSize, /* element data */
107 filename, 107 filename,
108 linenumber); 108 linenumber);
109 109
110 for (size_t i = 0; i < n; i++) 110 for (size_t i = 0; i < n; i++)
111 ret[i] = (char *)ret + /* base address */ 111 ret[i] = (char *) ret /* base address */
112 n * sizeof(void *) + /* skip 1. dim header */ 112 + n * sizeof(void *) /* skip 1. dim header */
113 i * m * elementSize; /* skip to 2. dim row header */ 113 + i * m * elementSize; /* skip to 2. dim row header */
114 return (void **)ret; 114 return (void **) ret;
115} 115}
116 116
117 117
@@ -131,34 +131,34 @@ GNUNET_xnew_array_2d_(size_t n,
131 * @return allocated memory, never NULL 131 * @return allocated memory, never NULL
132 */ 132 */
133void *** 133void ***
134GNUNET_xnew_array_3d_(size_t n, 134GNUNET_xnew_array_3d_ (size_t n,
135 size_t m, 135 size_t m,
136 size_t o, 136 size_t o,
137 size_t elementSize, 137 size_t elementSize,
138 const char *filename, 138 const char *filename,
139 int linenumber) 139 int linenumber)
140{ 140{
141 /* use char pointer internally to avoid void pointer arithmetic warnings */ 141 /* use char pointer internally to avoid void pointer arithmetic warnings */
142 char ***ret = GNUNET_xmalloc_(n * sizeof(void **) + /* 1. dim header */ 142 char ***ret = GNUNET_xmalloc_ (n * sizeof(void **) /* 1. dim header */
143 n * m * sizeof(void *) + /* 2. dim header */ 143 + n * m * sizeof(void *) /* 2. dim header */
144 n * m * o * elementSize, /* element data */ 144 + n * m * o * elementSize, /* element data */
145 filename, 145 filename,
146 linenumber); 146 linenumber);
147 147
148 for (size_t i = 0; i < n; i++) 148 for (size_t i = 0; i < n; i++)
149 { 149 {
150 /* need to cast to (char *) temporarily for byte level acuracy */ 150 /* need to cast to (char *) temporarily for byte level acuracy */
151 ret[i] = (char **)((char *)ret + /* base address */ 151 ret[i] = (char **) ((char *) ret /* base address */
152 n * sizeof(void **) + /* skip 1. dim header */ 152 + n * sizeof(void **) /* skip 1. dim header */
153 i * m * sizeof(void *)); /* skip to 2. dim header */ 153 + i * m * sizeof(void *)); /* skip to 2. dim header */
154 for (size_t j = 0; j < m; j++) 154 for (size_t j = 0; j < m; j++)
155 ret[i][j] = (char *)ret + /* base address */ 155 ret[i][j] = (char *) ret /* base address */
156 n * sizeof(void **) + /* skip 1. dim header */ 156 + n * sizeof(void **) /* skip 1. dim header */
157 n * m * sizeof(void *) + /* skip 2. dim header */ 157 + n * m * sizeof(void *) /* skip 2. dim header */
158 i * m * o * elementSize + /* skip to 2. dim part */ 158 + i * m * o * elementSize /* skip to 2. dim part */
159 j * o * elementSize; /* skip to 3. dim row data */ 159 + j * o * elementSize; /* skip to 3. dim row data */
160 } 160 }
161 return (void ***)ret; 161 return (void ***) ret;
162} 162}
163 163
164 164
@@ -174,34 +174,34 @@ GNUNET_xnew_array_3d_(size_t n,
174 * @return allocated memory, never NULL 174 * @return allocated memory, never NULL
175 */ 175 */
176void * 176void *
177GNUNET_xmemdup_(const void *buf, 177GNUNET_xmemdup_ (const void *buf,
178 size_t size, 178 size_t size,
179 const char *filename, 179 const char *filename,
180 int linenumber) 180 int linenumber)
181{ 181{
182 void *ret; 182 void *ret;
183 183
184 /* As a security precaution, we generally do not allow very large 184 /* As a security precaution, we generally do not allow very large
185 * allocations here */ 185 * allocations here */
186 GNUNET_assert_at(size <= GNUNET_MAX_MALLOC_CHECKED, filename, linenumber); 186 GNUNET_assert_at (size <= GNUNET_MAX_MALLOC_CHECKED, filename, linenumber);
187#ifdef W32_MEM_LIMIT 187#ifdef W32_MEM_LIMIT
188 size += sizeof(size_t); 188 size += sizeof(size_t);
189 if (mem_used + size > W32_MEM_LIMIT) 189 if (mem_used + size > W32_MEM_LIMIT)
190 return NULL; 190 return NULL;
191#endif 191#endif
192 GNUNET_assert_at(size < INT_MAX, filename, linenumber); 192 GNUNET_assert_at (size < INT_MAX, filename, linenumber);
193 ret = malloc(size); 193 ret = malloc (size);
194 if (ret == NULL) 194 if (ret == NULL)
195 { 195 {
196 LOG_STRERROR(GNUNET_ERROR_TYPE_ERROR, "malloc"); 196 LOG_STRERROR (GNUNET_ERROR_TYPE_ERROR, "malloc");
197 GNUNET_assert(0); 197 GNUNET_assert (0);
198 } 198 }
199#ifdef W32_MEM_LIMIT 199#ifdef W32_MEM_LIMIT
200 *((size_t *)ret) = size; 200 *((size_t *) ret) = size;
201 ret = &((size_t *)ret)[1]; 201 ret = &((size_t *) ret)[1];
202 mem_used += size; 202 mem_used += size;
203#endif 203#endif
204 GNUNET_memcpy(ret, buf, size); 204 GNUNET_memcpy (ret, buf, size);
205 return ret; 205 return ret;
206} 206}
207 207
@@ -216,26 +216,26 @@ GNUNET_xmemdup_(const void *buf,
216 * @return pointer to size bytes of memory, NULL if we do not have enough memory 216 * @return pointer to size bytes of memory, NULL if we do not have enough memory
217 */ 217 */
218void * 218void *
219GNUNET_xmalloc_unchecked_(size_t size, const char *filename, int linenumber) 219GNUNET_xmalloc_unchecked_ (size_t size, const char *filename, int linenumber)
220{ 220{
221 void *result; 221 void *result;
222 222
223 (void)filename; 223 (void) filename;
224 (void)linenumber; 224 (void) linenumber;
225#ifdef W32_MEM_LIMIT 225#ifdef W32_MEM_LIMIT
226 size += sizeof(size_t); 226 size += sizeof(size_t);
227 if (mem_used + size > W32_MEM_LIMIT) 227 if (mem_used + size > W32_MEM_LIMIT)
228 return NULL; 228 return NULL;
229#endif 229#endif
230 230
231 result = malloc(size); 231 result = malloc (size);
232 if (NULL == result) 232 if (NULL == result)
233 return NULL; 233 return NULL;
234 memset(result, 0, size); 234 memset (result, 0, size);
235 235
236#ifdef W32_MEM_LIMIT 236#ifdef W32_MEM_LIMIT
237 *((size_t *)result) = size; 237 *((size_t *) result) = size;
238 result = &((size_t *)result)[1]; 238 result = &((size_t *) result)[1];
239 mem_used += size; 239 mem_used += size;
240#endif 240#endif
241 241
@@ -255,24 +255,24 @@ GNUNET_xmalloc_unchecked_(size_t size, const char *filename, int linenumber)
255 * @return pointer to size bytes of memory 255 * @return pointer to size bytes of memory
256 */ 256 */
257void * 257void *
258GNUNET_xrealloc_(void *ptr, size_t n, const char *filename, int linenumber) 258GNUNET_xrealloc_ (void *ptr, size_t n, const char *filename, int linenumber)
259{ 259{
260 (void)filename; 260 (void) filename;
261 (void)linenumber; 261 (void) linenumber;
262 262
263#ifdef W32_MEM_LIMIT 263#ifdef W32_MEM_LIMIT
264 n += sizeof(size_t); 264 n += sizeof(size_t);
265 ptr = &((size_t *)ptr)[-1]; 265 ptr = &((size_t *) ptr)[-1];
266 mem_used = mem_used - *((size_t *)ptr) + n; 266 mem_used = mem_used - *((size_t *) ptr) + n;
267#endif 267#endif
268 ptr = realloc(ptr, n); 268 ptr = realloc (ptr, n);
269 if ((NULL == ptr) && (n > 0)) 269 if ((NULL == ptr) && (n > 0))
270 { 270 {
271 LOG_STRERROR(GNUNET_ERROR_TYPE_ERROR, "realloc"); 271 LOG_STRERROR (GNUNET_ERROR_TYPE_ERROR, "realloc");
272 GNUNET_assert(0); 272 GNUNET_assert (0);
273 } 273 }
274#ifdef W32_MEM_LIMIT 274#ifdef W32_MEM_LIMIT
275 ptr = &((size_t *)ptr)[1]; 275 ptr = &((size_t *) ptr)[1];
276#endif 276#endif
277 return ptr; 277 return ptr;
278} 278}
@@ -289,9 +289,9 @@ GNUNET_xrealloc_(void *ptr, size_t n, const char *filename, int linenumber)
289#include <malloc_np.h> 289#include <malloc_np.h>
290#endif 290#endif
291#if HAVE_MALLOC_USABLE_SIZE 291#if HAVE_MALLOC_USABLE_SIZE
292#define M_SIZE(p) malloc_usable_size(p) 292#define M_SIZE(p) malloc_usable_size (p)
293#elif HAVE_MALLOC_SIZE 293#elif HAVE_MALLOC_SIZE
294#define M_SIZE(p) malloc_size(p) 294#define M_SIZE(p) malloc_size (p)
295#endif 295#endif
296 296
297/** 297/**
@@ -303,28 +303,28 @@ GNUNET_xrealloc_(void *ptr, size_t n, const char *filename, int linenumber)
303 * @param linenumber where in the code was the call to GNUNET_free 303 * @param linenumber where in the code was the call to GNUNET_free
304 */ 304 */
305void 305void
306GNUNET_xfree_(void *ptr, const char *filename, int linenumber) 306GNUNET_xfree_ (void *ptr, const char *filename, int linenumber)
307{ 307{
308 GNUNET_assert_at(NULL != ptr, filename, linenumber); 308 GNUNET_assert_at (NULL != ptr, filename, linenumber);
309#ifdef W32_MEM_LIMIT 309#ifdef W32_MEM_LIMIT
310 ptr = &((size_t *)ptr)[-1]; 310 ptr = &((size_t *) ptr)[-1];
311 mem_used -= *((size_t *)ptr); 311 mem_used -= *((size_t *) ptr);
312#endif 312#endif
313#if defined(M_SIZE) 313#if defined(M_SIZE)
314#if ENABLE_POISONING 314#if ENABLE_POISONING
315 { 315 {
316 const uint64_t baadfood = GNUNET_ntohll(0xBAADF00DBAADF00DLL); 316 const uint64_t baadfood = GNUNET_ntohll (0xBAADF00DBAADF00DLL);
317 uint64_t *base = ptr; 317 uint64_t *base = ptr;
318 size_t s = M_SIZE(ptr); 318 size_t s = M_SIZE (ptr);
319 size_t i; 319 size_t i;
320 320
321 for (i = 0; i < s / 8; i++) 321 for (i = 0; i < s / 8; i++)
322 base[i] = baadfood; 322 base[i] = baadfood;
323 GNUNET_memcpy(&base[s / 8], &baadfood, s % 8); 323 GNUNET_memcpy (&base[s / 8], &baadfood, s % 8);
324 } 324 }
325#endif 325#endif
326#endif 326#endif
327 free(ptr); 327 free (ptr);
328} 328}
329 329
330 330
@@ -337,26 +337,26 @@ GNUNET_xfree_(void *ptr, const char *filename, int linenumber)
337 * @return `strdup(@a str)` 337 * @return `strdup(@a str)`
338 */ 338 */
339char * 339char *
340GNUNET_xstrdup_(const char *str, const char *filename, int linenumber) 340GNUNET_xstrdup_ (const char *str, const char *filename, int linenumber)
341{ 341{
342 char *res; 342 char *res;
343 size_t slen; 343 size_t slen;
344 344
345 GNUNET_assert_at(str != NULL, filename, linenumber); 345 GNUNET_assert_at (str != NULL, filename, linenumber);
346 slen = strlen(str) + 1; 346 slen = strlen (str) + 1;
347 res = GNUNET_xmalloc_(slen, filename, linenumber); 347 res = GNUNET_xmalloc_ (slen, filename, linenumber);
348 GNUNET_memcpy(res, str, slen); 348 GNUNET_memcpy (res, str, slen);
349 return res; 349 return res;
350} 350}
351 351
352 352
353#if !HAVE_STRNLEN 353#if ! HAVE_STRNLEN
354static size_t 354static size_t
355strnlen(const char *s, size_t n) 355strnlen (const char *s, size_t n)
356{ 356{
357 const char *e; 357 const char *e;
358 358
359 e = memchr(s, '\0', n); 359 e = memchr (s, '\0', n);
360 if (NULL == e) 360 if (NULL == e)
361 return n; 361 return n;
362 return e - s; 362 return e - s;
@@ -374,19 +374,19 @@ strnlen(const char *s, size_t n)
374 * @return `strndup(@a str,@a len)` 374 * @return `strndup(@a str,@a len)`
375 */ 375 */
376char * 376char *
377GNUNET_xstrndup_(const char *str, 377GNUNET_xstrndup_ (const char *str,
378 size_t len, 378 size_t len,
379 const char *filename, 379 const char *filename,
380 int linenumber) 380 int linenumber)
381{ 381{
382 char *res; 382 char *res;
383 383
384 if (0 == len) 384 if (0 == len)
385 return GNUNET_strdup(""); 385 return GNUNET_strdup ("");
386 GNUNET_assert_at(NULL != str, filename, linenumber); 386 GNUNET_assert_at (NULL != str, filename, linenumber);
387 len = strnlen(str, len); 387 len = strnlen (str, len);
388 res = GNUNET_xmalloc_(len + 1, filename, linenumber); 388 res = GNUNET_xmalloc_ (len + 1, filename, linenumber);
389 GNUNET_memcpy(res, str, len); 389 GNUNET_memcpy (res, str, len);
390 /* res[len] = '\0'; 'malloc' zeros out anyway */ 390 /* res[len] = '\0'; 'malloc' zeros out anyway */
391 return res; 391 return res;
392} 392}
@@ -405,35 +405,35 @@ GNUNET_xstrndup_(const char *str,
405 * @param linenumber where in the code was the call to GNUNET_array_grow() 405 * @param linenumber where in the code was the call to GNUNET_array_grow()
406 */ 406 */
407void 407void
408GNUNET_xgrow_(void **old, 408GNUNET_xgrow_ (void **old,
409 size_t elementSize, 409 size_t elementSize,
410 unsigned int *oldCount, 410 unsigned int *oldCount,
411 unsigned int newCount, 411 unsigned int newCount,
412 const char *filename, 412 const char *filename,
413 int linenumber) 413 int linenumber)
414{ 414{
415 void *tmp; 415 void *tmp;
416 size_t size; 416 size_t size;
417 417
418 GNUNET_assert_at(INT_MAX / elementSize > newCount, filename, linenumber); 418 GNUNET_assert_at (INT_MAX / elementSize > newCount, filename, linenumber);
419 size = newCount * elementSize; 419 size = newCount * elementSize;
420 if (0 == size) 420 if (0 == size)
421 { 421 {
422 tmp = NULL; 422 tmp = NULL;
423 } 423 }
424 else 424 else
425 {
426 tmp = GNUNET_xmalloc_ (size, filename, linenumber);
427 if (NULL != *old)
425 { 428 {
426 tmp = GNUNET_xmalloc_(size, filename, linenumber); 429 GNUNET_memcpy (tmp, *old, elementSize * GNUNET_MIN (*oldCount, newCount));
427 if (NULL != *old)
428 {
429 GNUNET_memcpy(tmp, *old, elementSize * GNUNET_MIN(*oldCount, newCount));
430 }
431 } 430 }
431 }
432 432
433 if (NULL != *old) 433 if (NULL != *old)
434 { 434 {
435 GNUNET_xfree_(*old, filename, linenumber); 435 GNUNET_xfree_ (*old, filename, linenumber);
436 } 436 }
437 *old = tmp; 437 *old = tmp;
438 *oldCount = newCount; 438 *oldCount = newCount;
439} 439}
@@ -448,19 +448,19 @@ GNUNET_xgrow_(void **old,
448 * @return number of bytes in `*@a buf`, excluding 0-termination 448 * @return number of bytes in `*@a buf`, excluding 0-termination
449 */ 449 */
450int 450int
451GNUNET_asprintf(char **buf, const char *format, ...) 451GNUNET_asprintf (char **buf, const char *format, ...)
452{ 452{
453 int ret; 453 int ret;
454 va_list args; 454 va_list args;
455 455
456 va_start(args, format); 456 va_start (args, format);
457 ret = vsnprintf(NULL, 0, format, args); 457 ret = vsnprintf (NULL, 0, format, args);
458 va_end(args); 458 va_end (args);
459 GNUNET_assert(ret >= 0); 459 GNUNET_assert (ret >= 0);
460 *buf = GNUNET_malloc(ret + 1); 460 *buf = GNUNET_malloc (ret + 1);
461 va_start(args, format); 461 va_start (args, format);
462 ret = vsprintf(*buf, format, args); 462 ret = vsprintf (*buf, format, args);
463 va_end(args); 463 va_end (args);
464 return ret; 464 return ret;
465} 465}
466 466
@@ -475,15 +475,15 @@ GNUNET_asprintf(char **buf, const char *format, ...)
475 * @return number of bytes written to buf or negative value on error 475 * @return number of bytes written to buf or negative value on error
476 */ 476 */
477int 477int
478GNUNET_snprintf(char *buf, size_t size, const char *format, ...) 478GNUNET_snprintf (char *buf, size_t size, const char *format, ...)
479{ 479{
480 int ret; 480 int ret;
481 va_list args; 481 va_list args;
482 482
483 va_start(args, format); 483 va_start (args, format);
484 ret = vsnprintf(buf, size, format, args); 484 ret = vsnprintf (buf, size, format, args);
485 va_end(args); 485 va_end (args);
486 GNUNET_assert((ret >= 0) && (((size_t)ret) < size)); 486 GNUNET_assert ((ret >= 0) && (((size_t) ret) < size));
487 return ret; 487 return ret;
488} 488}
489 489
@@ -495,15 +495,15 @@ GNUNET_snprintf(char *buf, size_t size, const char *format, ...)
495 * @return duplicate of the message 495 * @return duplicate of the message
496 */ 496 */
497struct GNUNET_MessageHeader * 497struct GNUNET_MessageHeader *
498GNUNET_copy_message(const struct GNUNET_MessageHeader *msg) 498GNUNET_copy_message (const struct GNUNET_MessageHeader *msg)
499{ 499{
500 struct GNUNET_MessageHeader *ret; 500 struct GNUNET_MessageHeader *ret;
501 uint16_t msize; 501 uint16_t msize;
502 502
503 msize = ntohs(msg->size); 503 msize = ntohs (msg->size);
504 GNUNET_assert(msize >= sizeof(struct GNUNET_MessageHeader)); 504 GNUNET_assert (msize >= sizeof(struct GNUNET_MessageHeader));
505 ret = GNUNET_malloc(msize); 505 ret = GNUNET_malloc (msize);
506 GNUNET_memcpy(ret, msg, msize); 506 GNUNET_memcpy (ret, msg, msize);
507 return ret; 507 return ret;
508} 508}
509 509