diff options
Diffstat (limited to 'src/util/common_allocation.c')
-rw-r--r-- | src/util/common_allocation.c | 284 |
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 | */ |
65 | void * | 65 | void * |
66 | GNUNET_xmalloc_(size_t size, const char *filename, int linenumber) | 66 | GNUNET_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 | */ |
97 | void ** | 97 | void ** |
98 | GNUNET_xnew_array_2d_(size_t n, | 98 | GNUNET_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 | */ |
133 | void *** | 133 | void *** |
134 | GNUNET_xnew_array_3d_(size_t n, | 134 | GNUNET_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 | */ |
176 | void * | 176 | void * |
177 | GNUNET_xmemdup_(const void *buf, | 177 | GNUNET_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 | */ |
218 | void * | 218 | void * |
219 | GNUNET_xmalloc_unchecked_(size_t size, const char *filename, int linenumber) | 219 | GNUNET_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 | */ |
257 | void * | 257 | void * |
258 | GNUNET_xrealloc_(void *ptr, size_t n, const char *filename, int linenumber) | 258 | GNUNET_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 | */ |
305 | void | 305 | void |
306 | GNUNET_xfree_(void *ptr, const char *filename, int linenumber) | 306 | GNUNET_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 | */ |
339 | char * | 339 | char * |
340 | GNUNET_xstrdup_(const char *str, const char *filename, int linenumber) | 340 | GNUNET_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 |
354 | static size_t | 354 | static size_t |
355 | strnlen(const char *s, size_t n) | 355 | strnlen (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 | */ |
376 | char * | 376 | char * |
377 | GNUNET_xstrndup_(const char *str, | 377 | GNUNET_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 | */ |
407 | void | 407 | void |
408 | GNUNET_xgrow_(void **old, | 408 | GNUNET_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 | */ |
450 | int | 450 | int |
451 | GNUNET_asprintf(char **buf, const char *format, ...) | 451 | GNUNET_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 | */ |
477 | int | 477 | int |
478 | GNUNET_snprintf(char *buf, size_t size, const char *format, ...) | 478 | GNUNET_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 | */ |
497 | struct GNUNET_MessageHeader * | 497 | struct GNUNET_MessageHeader * |
498 | GNUNET_copy_message(const struct GNUNET_MessageHeader *msg) | 498 | GNUNET_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 | ||