diff options
Diffstat (limited to 'src/util/common_allocation.c')
-rw-r--r-- | src/util/common_allocation.c | 199 |
1 files changed, 83 insertions, 116 deletions
diff --git a/src/util/common_allocation.c b/src/util/common_allocation.c index 20333ce56..94890a7f4 100644 --- a/src/util/common_allocation.c +++ b/src/util/common_allocation.c | |||
@@ -32,9 +32,11 @@ | |||
32 | #include <malloc/malloc.h> | 32 | #include <malloc/malloc.h> |
33 | #endif | 33 | #endif |
34 | 34 | ||
35 | #define LOG(kind,...) GNUNET_log_from (kind, "util-common-allocation",__VA_ARGS__) | 35 | #define LOG(kind, ...) \ |
36 | GNUNET_log_from (kind, "util-common-allocation", __VA_ARGS__) | ||
36 | 37 | ||
37 | #define LOG_STRERROR(kind,syscall) GNUNET_log_from_strerror (kind, "util-common-allocation", syscall) | 38 | #define LOG_STRERROR(kind, syscall) \ |
39 | GNUNET_log_from_strerror (kind, "util-common-allocation", syscall) | ||
38 | 40 | ||
39 | #ifndef INT_MAX | 41 | #ifndef INT_MAX |
40 | #define INT_MAX 0x7FFFFFFF | 42 | #define INT_MAX 0x7FFFFFFF |
@@ -61,24 +63,17 @@ static LONG mem_used = 0; | |||
61 | * @return pointer to size bytes of memory | 63 | * @return pointer to size bytes of memory |
62 | */ | 64 | */ |
63 | void * | 65 | void * |
64 | GNUNET_xmalloc_ (size_t size, | 66 | GNUNET_xmalloc_ (size_t size, const char *filename, int linenumber) |
65 | const char *filename, | ||
66 | 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, | 72 | GNUNET_assert_at (size <= GNUNET_MAX_MALLOC_CHECKED, filename, linenumber); |
73 | filename, | 73 | ret = GNUNET_xmalloc_unchecked_ (size, filename, linenumber); |
74 | linenumber); | ||
75 | ret = GNUNET_xmalloc_unchecked_ (size, | ||
76 | filename, | ||
77 | linenumber); | ||
78 | if (NULL == ret) | 74 | if (NULL == ret) |
79 | { | 75 | { |
80 | LOG_STRERROR (GNUNET_ERROR_TYPE_ERROR, | 76 | LOG_STRERROR (GNUNET_ERROR_TYPE_ERROR, "malloc"); |
81 | "malloc"); | ||
82 | GNUNET_assert (0); | 77 | GNUNET_assert (0); |
83 | } | 78 | } |
84 | return ret; | 79 | return ret; |
@@ -101,21 +96,22 @@ GNUNET_xmalloc_ (size_t size, | |||
101 | */ | 96 | */ |
102 | void ** | 97 | void ** |
103 | GNUNET_xnew_array_2d_ (size_t n, | 98 | GNUNET_xnew_array_2d_ (size_t n, |
104 | size_t m, | 99 | size_t m, |
105 | size_t elementSize, | 100 | size_t elementSize, |
106 | const char *filename, | 101 | const char *filename, |
107 | int linenumber) | 102 | int linenumber) |
108 | { | 103 | { |
109 | /* use char pointer internally to avoid void pointer arithmetic warnings */ | 104 | /* use char pointer internally to avoid void pointer arithmetic warnings */ |
110 | char **ret = GNUNET_xmalloc_ (n * sizeof (void *) + /* 1. dim header */ | 105 | char **ret = GNUNET_xmalloc_ (n * sizeof (void *) + /* 1. dim header */ |
111 | n * m * elementSize, /* element data */ | 106 | n * m * elementSize, /* element data */ |
112 | filename, linenumber); | 107 | filename, |
113 | 108 | linenumber); | |
114 | for (size_t i = 0; i < n; i++) | 109 | |
115 | ret[i] = (char *)ret + /* base address */ | 110 | for (size_t i = 0; i < n; i++) |
116 | n * sizeof (void *) + /* skip 1. dim header */ | 111 | ret[i] = (char *) ret + /* base address */ |
117 | i * m * elementSize; /* skip to 2. dim row header */ | 112 | n * sizeof (void *) + /* skip 1. dim header */ |
118 | return (void **)ret; | 113 | i * m * elementSize; /* skip to 2. dim row header */ |
114 | return (void **) ret; | ||
119 | } | 115 | } |
120 | 116 | ||
121 | 117 | ||
@@ -135,29 +131,34 @@ GNUNET_xnew_array_2d_ (size_t n, | |||
135 | * @return allocated memory, never NULL | 131 | * @return allocated memory, never NULL |
136 | */ | 132 | */ |
137 | void *** | 133 | void *** |
138 | GNUNET_xnew_array_3d_ (size_t n, size_t m, size_t o, size_t elementSize, | 134 | GNUNET_xnew_array_3d_ (size_t n, |
139 | const char *filename, int linenumber) | 135 | size_t m, |
136 | size_t o, | ||
137 | size_t elementSize, | ||
138 | const char *filename, | ||
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, linenumber); | 145 | filename, |
146 | 146 | linenumber); | |
147 | for (size_t i = 0; i < n; i++) | 147 | |
148 | { | 148 | for (size_t i = 0; i < n; i++) |
149 | /* need to cast to (char *) temporarily for byte level acuracy */ | 149 | { |
150 | ret[i] = (char **)((char *)ret + /* base address */ | 150 | /* need to cast to (char *) temporarily for byte level acuracy */ |
151 | n * sizeof (void **) + /* skip 1. dim header */ | 151 | ret[i] = (char **) ((char *) ret + /* base address */ |
152 | i * m * sizeof (void *)); /* skip to 2. dim header */ | 152 | n * sizeof (void **) + /* skip 1. dim header */ |
153 | for (size_t j = 0; j < m; j++) | 153 | i * m * sizeof (void *)); /* skip to 2. dim header */ |
154 | ret[i][j] = (char *)ret + /* base address */ | 154 | for (size_t j = 0; j < m; j++) |
155 | n * sizeof (void **) + /* skip 1. dim header */ | 155 | ret[i][j] = (char *) ret + /* base address */ |
156 | n * m * sizeof (void *) + /* skip 2. dim header */ | 156 | n * sizeof (void **) + /* skip 1. dim header */ |
157 | i * m * o * elementSize + /* skip to 2. dim part */ | 157 | n * m * sizeof (void *) + /* skip 2. dim header */ |
158 | j * o * elementSize; /* skip to 3. dim row data */ | 158 | i * m * o * elementSize + /* skip to 2. dim part */ |
159 | } | 159 | j * o * elementSize; /* skip to 3. dim row data */ |
160 | return (void ***)ret; | 160 | } |
161 | return (void ***) ret; | ||
161 | } | 162 | } |
162 | 163 | ||
163 | 164 | ||
@@ -174,8 +175,8 @@ GNUNET_xnew_array_3d_ (size_t n, size_t m, size_t o, size_t elementSize, | |||
174 | */ | 175 | */ |
175 | void * | 176 | void * |
176 | GNUNET_xmemdup_ (const void *buf, | 177 | GNUNET_xmemdup_ (const void *buf, |
177 | size_t size, | 178 | size_t size, |
178 | const char *filename, | 179 | const char *filename, |
179 | int linenumber) | 180 | int linenumber) |
180 | { | 181 | { |
181 | void *ret; | 182 | void *ret; |
@@ -215,9 +216,7 @@ GNUNET_xmemdup_ (const void *buf, | |||
215 | * @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 |
216 | */ | 217 | */ |
217 | void * | 218 | void * |
218 | GNUNET_xmalloc_unchecked_ (size_t size, | 219 | GNUNET_xmalloc_unchecked_ (size_t size, const char *filename, int linenumber) |
219 | const char *filename, | ||
220 | int linenumber) | ||
221 | { | 220 | { |
222 | void *result; | 221 | void *result; |
223 | 222 | ||
@@ -256,10 +255,7 @@ GNUNET_xmalloc_unchecked_ (size_t size, | |||
256 | * @return pointer to size bytes of memory | 255 | * @return pointer to size bytes of memory |
257 | */ | 256 | */ |
258 | void * | 257 | void * |
259 | GNUNET_xrealloc_ (void *ptr, | 258 | GNUNET_xrealloc_ (void *ptr, size_t n, const char *filename, int linenumber) |
260 | size_t n, | ||
261 | const char *filename, | ||
262 | int linenumber) | ||
263 | { | 259 | { |
264 | (void) filename; | 260 | (void) filename; |
265 | (void) linenumber; | 261 | (void) linenumber; |
@@ -272,8 +268,7 @@ GNUNET_xrealloc_ (void *ptr, | |||
272 | ptr = realloc (ptr, n); | 268 | ptr = realloc (ptr, n); |
273 | if ((NULL == ptr) && (n > 0)) | 269 | if ((NULL == ptr) && (n > 0)) |
274 | { | 270 | { |
275 | LOG_STRERROR (GNUNET_ERROR_TYPE_ERROR, | 271 | LOG_STRERROR (GNUNET_ERROR_TYPE_ERROR, "realloc"); |
276 | "realloc"); | ||
277 | GNUNET_assert (0); | 272 | GNUNET_assert (0); |
278 | } | 273 | } |
279 | #ifdef W32_MEM_LIMIT | 274 | #ifdef W32_MEM_LIMIT |
@@ -283,10 +278,10 @@ GNUNET_xrealloc_ (void *ptr, | |||
283 | } | 278 | } |
284 | 279 | ||
285 | 280 | ||
286 | # if __BYTE_ORDER == __LITTLE_ENDIAN | 281 | #if __BYTE_ORDER == __LITTLE_ENDIAN |
287 | #define BAADFOOD_STR "\x0D\xF0\xAD\xBA" | 282 | #define BAADFOOD_STR "\x0D\xF0\xAD\xBA" |
288 | #endif | 283 | #endif |
289 | # if __BYTE_ORDER == __BIG_ENDIAN | 284 | #if __BYTE_ORDER == __BIG_ENDIAN |
290 | #define BAADFOOD_STR "\xBA\xAD\xF0\x0D" | 285 | #define BAADFOOD_STR "\xBA\xAD\xF0\x0D" |
291 | #endif | 286 | #endif |
292 | 287 | ||
@@ -311,13 +306,9 @@ GNUNET_xrealloc_ (void *ptr, | |||
311 | * @param linenumber where in the code was the call to GNUNET_free | 306 | * @param linenumber where in the code was the call to GNUNET_free |
312 | */ | 307 | */ |
313 | void | 308 | void |
314 | GNUNET_xfree_ (void *ptr, | 309 | GNUNET_xfree_ (void *ptr, const char *filename, int linenumber) |
315 | const char *filename, | ||
316 | int linenumber) | ||
317 | { | 310 | { |
318 | GNUNET_assert_at (NULL != ptr, | 311 | GNUNET_assert_at (NULL != ptr, filename, linenumber); |
319 | filename, | ||
320 | linenumber); | ||
321 | #ifdef W32_MEM_LIMIT | 312 | #ifdef W32_MEM_LIMIT |
322 | ptr = &((size_t *) ptr)[-1]; | 313 | ptr = &((size_t *) ptr)[-1]; |
323 | mem_used -= *((size_t *) ptr); | 314 | mem_used -= *((size_t *) ptr); |
@@ -330,9 +321,9 @@ GNUNET_xfree_ (void *ptr, | |||
330 | size_t s = M_SIZE (ptr); | 321 | size_t s = M_SIZE (ptr); |
331 | size_t i; | 322 | size_t i; |
332 | 323 | ||
333 | for (i=0;i<s/8;i++) | 324 | for (i = 0; i < s / 8; i++) |
334 | base[i] = baadfood; | 325 | base[i] = baadfood; |
335 | GNUNET_memcpy (&base[s/8], &baadfood, s % 8); | 326 | GNUNET_memcpy (&base[s / 8], &baadfood, s % 8); |
336 | } | 327 | } |
337 | #endif | 328 | #endif |
338 | #endif | 329 | #endif |
@@ -349,31 +340,22 @@ GNUNET_xfree_ (void *ptr, | |||
349 | * @return `strdup(@a str)` | 340 | * @return `strdup(@a str)` |
350 | */ | 341 | */ |
351 | char * | 342 | char * |
352 | GNUNET_xstrdup_ (const char *str, | 343 | GNUNET_xstrdup_ (const char *str, const char *filename, int linenumber) |
353 | const char *filename, | ||
354 | int linenumber) | ||
355 | { | 344 | { |
356 | char *res; | 345 | char *res; |
357 | size_t slen; | 346 | size_t slen; |
358 | 347 | ||
359 | GNUNET_assert_at (str != NULL, | 348 | GNUNET_assert_at (str != NULL, filename, linenumber); |
360 | filename, | ||
361 | linenumber); | ||
362 | slen = strlen (str) + 1; | 349 | slen = strlen (str) + 1; |
363 | res = GNUNET_xmalloc_ (slen, | 350 | res = GNUNET_xmalloc_ (slen, filename, linenumber); |
364 | filename, | 351 | GNUNET_memcpy (res, str, slen); |
365 | linenumber); | ||
366 | GNUNET_memcpy (res, | ||
367 | str, | ||
368 | slen); | ||
369 | return res; | 352 | return res; |
370 | } | 353 | } |
371 | 354 | ||
372 | 355 | ||
373 | #if ! HAVE_STRNLEN | 356 | #if ! HAVE_STRNLEN |
374 | static size_t | 357 | static size_t |
375 | strnlen (const char *s, | 358 | strnlen (const char *s, size_t n) |
376 | size_t n) | ||
377 | { | 359 | { |
378 | const char *e; | 360 | const char *e; |
379 | 361 | ||
@@ -396,22 +378,17 @@ strnlen (const char *s, | |||
396 | */ | 378 | */ |
397 | char * | 379 | char * |
398 | GNUNET_xstrndup_ (const char *str, | 380 | GNUNET_xstrndup_ (const char *str, |
399 | size_t len, | 381 | size_t len, |
400 | const char *filename, | 382 | const char *filename, |
401 | int linenumber) | 383 | int linenumber) |
402 | { | 384 | { |
403 | char *res; | 385 | char *res; |
404 | 386 | ||
405 | if (0 == len) | 387 | if (0 == len) |
406 | return GNUNET_strdup (""); | 388 | return GNUNET_strdup (""); |
407 | GNUNET_assert_at (NULL != str, | 389 | GNUNET_assert_at (NULL != str, filename, linenumber); |
408 | filename, | 390 | len = strnlen (str, len); |
409 | linenumber); | 391 | res = GNUNET_xmalloc_ (len + 1, filename, linenumber); |
410 | len = strnlen (str, | ||
411 | len); | ||
412 | res = GNUNET_xmalloc_ (len + 1, | ||
413 | filename, | ||
414 | linenumber); | ||
415 | GNUNET_memcpy (res, str, len); | 392 | GNUNET_memcpy (res, str, len); |
416 | /* res[len] = '\0'; 'malloc' zeros out anyway */ | 393 | /* res[len] = '\0'; 'malloc' zeros out anyway */ |
417 | return res; | 394 | return res; |
@@ -432,11 +409,11 @@ GNUNET_xstrndup_ (const char *str, | |||
432 | */ | 409 | */ |
433 | void | 410 | void |
434 | GNUNET_xgrow_ (void **old, | 411 | GNUNET_xgrow_ (void **old, |
435 | size_t elementSize, | 412 | size_t elementSize, |
436 | unsigned int *oldCount, | 413 | unsigned int *oldCount, |
437 | unsigned int newCount, | 414 | unsigned int newCount, |
438 | const char *filename, | 415 | const char *filename, |
439 | int linenumber) | 416 | int linenumber) |
440 | { | 417 | { |
441 | void *tmp; | 418 | void *tmp; |
442 | size_t size; | 419 | size_t size; |
@@ -452,7 +429,7 @@ GNUNET_xgrow_ (void **old, | |||
452 | tmp = GNUNET_xmalloc_ (size, filename, linenumber); | 429 | tmp = GNUNET_xmalloc_ (size, filename, linenumber); |
453 | if (NULL != *old) | 430 | if (NULL != *old) |
454 | { | 431 | { |
455 | GNUNET_memcpy (tmp, *old, elementSize * GNUNET_MIN(*oldCount, newCount)); | 432 | GNUNET_memcpy (tmp, *old, elementSize * GNUNET_MIN (*oldCount, newCount)); |
456 | } | 433 | } |
457 | } | 434 | } |
458 | 435 | ||
@@ -474,20 +451,18 @@ GNUNET_xgrow_ (void **old, | |||
474 | * @return number of bytes in `*@a buf`, excluding 0-termination | 451 | * @return number of bytes in `*@a buf`, excluding 0-termination |
475 | */ | 452 | */ |
476 | int | 453 | int |
477 | GNUNET_asprintf (char **buf, | 454 | GNUNET_asprintf (char **buf, const char *format, ...) |
478 | const char *format, | ||
479 | ...) | ||
480 | { | 455 | { |
481 | int ret; | 456 | int ret; |
482 | va_list args; | 457 | va_list args; |
483 | 458 | ||
484 | va_start (args, format); | 459 | va_start (args, format); |
485 | ret = VSNPRINTF (NULL, 0, format, args); | 460 | ret = vsnprintf (NULL, 0, format, args); |
486 | va_end (args); | 461 | va_end (args); |
487 | GNUNET_assert (ret >= 0); | 462 | GNUNET_assert (ret >= 0); |
488 | *buf = GNUNET_malloc (ret + 1); | 463 | *buf = GNUNET_malloc (ret + 1); |
489 | va_start (args, format); | 464 | va_start (args, format); |
490 | ret = VSPRINTF (*buf, format, args); | 465 | ret = vsprintf (*buf, format, args); |
491 | va_end (args); | 466 | va_end (args); |
492 | return ret; | 467 | return ret; |
493 | } | 468 | } |
@@ -503,21 +478,15 @@ GNUNET_asprintf (char **buf, | |||
503 | * @return number of bytes written to buf or negative value on error | 478 | * @return number of bytes written to buf or negative value on error |
504 | */ | 479 | */ |
505 | int | 480 | int |
506 | GNUNET_snprintf (char *buf, | 481 | GNUNET_snprintf (char *buf, size_t size, const char *format, ...) |
507 | size_t size, | ||
508 | const char *format, ...) | ||
509 | { | 482 | { |
510 | int ret; | 483 | int ret; |
511 | va_list args; | 484 | va_list args; |
512 | 485 | ||
513 | va_start (args, format); | 486 | va_start (args, format); |
514 | ret = VSNPRINTF (buf, | 487 | ret = vsnprintf (buf, size, format, args); |
515 | size, | ||
516 | format, | ||
517 | args); | ||
518 | va_end (args); | 488 | va_end (args); |
519 | GNUNET_assert ( (ret >= 0) && | 489 | GNUNET_assert ((ret >= 0) && (((size_t) ret) < size)); |
520 | (((size_t) ret) < size) ); | ||
521 | return ret; | 490 | return ret; |
522 | } | 491 | } |
523 | 492 | ||
@@ -537,9 +506,7 @@ GNUNET_copy_message (const struct GNUNET_MessageHeader *msg) | |||
537 | msize = ntohs (msg->size); | 506 | msize = ntohs (msg->size); |
538 | GNUNET_assert (msize >= sizeof (struct GNUNET_MessageHeader)); | 507 | GNUNET_assert (msize >= sizeof (struct GNUNET_MessageHeader)); |
539 | ret = GNUNET_malloc (msize); | 508 | ret = GNUNET_malloc (msize); |
540 | GNUNET_memcpy (ret, | 509 | GNUNET_memcpy (ret, msg, msize); |
541 | msg, | ||
542 | msize); | ||
543 | return ret; | 510 | return ret; |
544 | } | 511 | } |
545 | 512 | ||