src/util/common_allocation.c

   1 /*
   2      This file is part of GNUnet.
   3      Copyright (C) 2001, 2002, 2003, 2005, 2006 GNUnet e.V.
   4
   5      GNUnet is free software: you can redistribute it and/or modify it
   6      under the terms of the GNU Affero General Public License as published
   7      by the Free Software Foundation, either version 3 of the License,
   8      or (at your option) any later version.
   9
  10      GNUnet is distributed in the hope that it will be useful, but
  11      WITHOUT ANY WARRANTY; without even the implied warranty of
  12      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13      Affero General Public License for more details.
  14
  15      You should have received a copy of the GNU Affero General Public License
  16      along with this program.  If not, see <http://www.gnu.org/licenses/>.
  17
  18      SPDX-License-Identifier: AGPL3.0-or-later
  19  */
  20
  21 /**
  22  * @file util/common_allocation.c
  23  * @brief wrapper around malloc/free
  24  * @author Christian Grothoff
  25  */
  26 #include "platform.h"
  27 #include "gnunet_crypto_lib.h"
  28 #if HAVE_MALLOC_H
  29 #include <malloc.h>
  30 #endif
  31 #if HAVE_MALLOC_MALLOC_H
  32 #include <malloc/malloc.h>
  33 #endif
  34
  35 #define LOG(kind, ...) \
  36   GNUNET_log_from (kind, "util-common-allocation", __VA_ARGS__)
  37
  38 #define LOG_STRERROR(kind, syscall) \
  39   GNUNET_log_from_strerror (kind, "util-common-allocation", syscall)
  40
  41 #ifndef INT_MAX
  42 #define INT_MAX 0x7FFFFFFF
  43 #endif
  44
  45 #if 0
  46 #define W32_MEM_LIMIT 200000000
  47 #endif
  48
  49 #ifdef W32_MEM_LIMIT
  50 static LONG mem_used = 0;
  51 #endif
  52
  53 /**
  54  * Allocate memory. Checks the return value, aborts if no more
  55  * memory is available.
  56  *
  57  * @param size how many bytes of memory to allocate, do NOT use
  58  *  this function (or GNUNET_malloc()) to allocate more than several MB
  59  *  of memory, if you are possibly needing a very large chunk use
  60  *  #GNUNET_xmalloc_unchecked_() instead.
  61  * @param filename where in the code was the call to GNUNET_malloc()
  62  * @param linenumber where in the code was the call to GNUNET_malloc()
  63  * @return pointer to size bytes of memory
  64  */
  65 void *
  66 GNUNET_xmalloc_ (size_t size, const char *filename, int linenumber)
  67 {
  68   void *ret;
  69
  70   /* As a security precaution, we generally do not allow very large
  71    * allocations using the default 'GNUNET_malloc()' macro */
  72   GNUNET_assert_at (size <= GNUNET_MAX_MALLOC_CHECKED, filename, linenumber);
  73   ret = GNUNET_xmalloc_unchecked_ (size, filename, linenumber);
  74   if (NULL == ret)
  75   {
  76     LOG_STRERROR (GNUNET_ERROR_TYPE_ERROR, "malloc");
  77     GNUNET_assert (0);
  78   }
  79   return ret;
  80 }
  81
  82
  83 /**
  84  * Allocate memory for a two dimensional array in one block
  85  * and set up pointers. Aborts if no more memory is available.
  86  * Don't use GNUNET_xnew_array_2d_ directly. Use the
  87  * #GNUNET_new_array_2d macro.
  88  * The memory of the elements will be zero'ed out.
  89  *
  90  * @param n size of the first dimension
  91  * @param m size of the second dimension
  92  * @param elementSize size of a single element in bytes
  93  * @param filename where is this call being made (for debugging)
  94  * @param linenumber line where this call is being made (for debugging)
  95  * @return allocated memory, never NULL
  96  */
  97 void **
  98 GNUNET_xnew_array_2d_ (size_t n,
  99                        size_t m,
 100                        size_t elementSize,
 101                        const char *filename,
 102                        int linenumber)
 103 {
 104   /* use char pointer internally to avoid void pointer arithmetic warnings */
 105   char **ret = GNUNET_xmalloc_ (n * sizeof(void *)     /* 1. dim header */
 106                                 + n * m * elementSize, /* element data */
 107                                 filename,
 108                                 linenumber);
 109
 110   for (size_t i = 0; i < n; i++)
 111     ret[i] = (char *) ret    /* base address */
 112              + n * sizeof(void *)  /* skip 1. dim header */
 113              + i * m * elementSize; /* skip to 2. dim row header */
 114   return (void **) ret;
 115 }
 116
 117
 118 /**
 119  * Allocate memory for a three dimensional array in one block
 120  * and set up pointers. Aborts if no more memory is available.
 121  * Don't use GNUNET_xnew_array_3d_ directly. Use the
 122  * #GNUNET_new_array_3d macro.
 123  * The memory of the elements will be zero'ed out.
 124  *
 125  * @param n size of the first dimension
 126  * @param m size of the second dimension
 127  * @param o size of the third dimension
 128  * @param elementSize size of a single element in bytes
 129  * @param filename where is this call being made (for debugging)
 130  * @param linenumber line where this call is being made (for debugging)
 131  * @return allocated memory, never NULL
 132  */
 133 void ***
 134 GNUNET_xnew_array_3d_ (size_t n,
 135                        size_t m,
 136                        size_t o,
 137                        size_t elementSize,
 138                        const char *filename,
 139                        int linenumber)
 140 {
 141   /* use char pointer internally to avoid void pointer arithmetic warnings */
 142   char ***ret = GNUNET_xmalloc_ (n * sizeof(void **)     /* 1. dim header */
 143                                  + n * m * sizeof(void *)    /* 2. dim header */
 144                                  + n * m * o * elementSize, /* element data */
 145                                  filename,
 146                                  linenumber);
 147
 148   for (size_t i = 0; i < n; i++)
 149   {
 150     /* need to cast to (char *) temporarily for byte level acuracy */
 151     ret[i] = (char **) ((char *) ret   /* base address */
 152                         + n * sizeof(void **)  /* skip 1. dim header */
 153                         + i * m * sizeof(void *)); /* skip to 2. dim header */
 154     for (size_t j = 0; j < m; j++)
 155       ret[i][j] = (char *) ret    /* base address */
 156                   + n * sizeof(void **)   /* skip 1. dim header */
 157                   + n * m * sizeof(void *)   /* skip 2. dim header */
 158                   + i * m * o * elementSize   /* skip to 2. dim part */
 159                   + j * o * elementSize; /* skip to 3. dim row data */
 160   }
 161   return (void ***) ret;
 162 }
 163
 164
 165 /**
 166  * Allocate and initialize memory. Checks the return value, aborts if no more
 167  * memory is available.  Don't use #GNUNET_xmemdup_() directly. Use the
 168  * GNUNET_memdup() macro.
 169  *
 170  * @param buf buffer to initialize from (must contain size bytes)
 171  * @param size number of bytes to allocate
 172  * @param filename where is this call being made (for debugging)
 173  * @param linenumber line where this call is being made (for debugging)
 174  * @return allocated memory, never NULL
 175  */
 176 void *
 177 GNUNET_xmemdup_ (const void *buf,
 178                  size_t size,
 179                  const char *filename,
 180                  int linenumber)
 181 {
 182   void *ret;
 183
 184   /* As a security precaution, we generally do not allow very large
 185    * allocations here */
 186   GNUNET_assert_at (size <= GNUNET_MAX_MALLOC_CHECKED, filename, linenumber);
 187 #ifdef W32_MEM_LIMIT
 188   size += sizeof(size_t);
 189   if (mem_used + size > W32_MEM_LIMIT)
 190     return NULL;
 191 #endif
 192   GNUNET_assert_at (size < INT_MAX, filename, linenumber);
 193   ret = malloc (size);
 194   if (ret == NULL)
 195   {
 196     LOG_STRERROR (GNUNET_ERROR_TYPE_ERROR, "malloc");
 197     GNUNET_assert (0);
 198   }
 199 #ifdef W32_MEM_LIMIT
 200   *((size_t *) ret) = size;
 201   ret = &((size_t *) ret)[1];
 202   mem_used += size;
 203 #endif
 204   GNUNET_memcpy (ret, buf, size);
 205   return ret;
 206 }
 207
 208
 209 /**
 210  * Wrapper around malloc(). Allocates size bytes of memory.
 211  * The memory will be zero'ed out.
 212  *
 213  * @param size the number of bytes to allocate
 214  * @param filename where in the code was the call to GNUNET_malloc_unchecked()
 215  * @param linenumber where in the code was the call to GNUNET_malloc_unchecked()
 216  * @return pointer to size bytes of memory, NULL if we do not have enough memory
 217  */
 218 void *
 219 GNUNET_xmalloc_unchecked_ (size_t size, const char *filename, int linenumber)
 220 {
 221   void *result;
 222
 223   (void) filename;
 224   (void) linenumber;
 225 #ifdef W32_MEM_LIMIT
 226   size += sizeof(size_t);
 227   if (mem_used + size > W32_MEM_LIMIT)
 228     return NULL;
 229 #endif
 230
 231   result = malloc (size);
 232   if (NULL == result)
 233     return NULL;
 234   memset (result, 0, size);
 235
 236 #ifdef W32_MEM_LIMIT
 237   *((size_t *) result) = size;
 238   result = &((size_t *) result)[1];
 239   mem_used += size;
 240 #endif
 241
 242   return result;
 243 }
 244
 245
 246 /**
 247  * Reallocate memory. Checks the return value, aborts if no more
 248  * memory is available.
 249  * The content of the intersection of the new and old size will be unchanged.
 250  *
 251  * @param ptr the pointer to reallocate
 252  * @param n how many bytes of memory to allocate
 253  * @param filename where in the code was the call to GNUNET_realloc()
 254  * @param linenumber where in the code was the call to GNUNET_realloc()
 255  * @return pointer to size bytes of memory
 256  */
 257 void *
 258 GNUNET_xrealloc_ (void *ptr, size_t n, const char *filename, int linenumber)
 259 {
 260   (void) filename;
 261   (void) linenumber;
 262
 263 #ifdef W32_MEM_LIMIT
 264   n += sizeof(size_t);
 265   ptr = &((size_t *) ptr)[-1];
 266   mem_used = mem_used - *((size_t *) ptr) + n;
 267 #endif
 268 #if defined(M_SIZE)
 269 #if ENABLE_POISONING
 270   {
 271     uint64_t *base = ptr;
 272     size_t s = M_SIZE (ptr);
 273
 274     if (s > n)
 275     {
 276       const uint64_t baadfood = GNUNET_ntohll (0xBAADF00DBAADF00DLL);
 277       char *cbase = ptr;
 278
 279       GNUNET_memcpy (&cbase[n],
 280                      &baadfood,
 281                      GNUNET_MIN (8 - (n % 8),
 282                                  s - n));
 283       for (size_t i = 1 + (n + 7) / 8; i < s / 8; i++)
 284         base[i] = baadfood;
 285       GNUNET_memcpy (&base[s / 8],
 286                      &baadfood,
 287                      s % 8);
 288     }
 289   }
 290 #endif
 291 #endif
 292   ptr = realloc (ptr, n);
 293   if ((NULL == ptr) && (n > 0))
 294   {
 295     LOG_STRERROR (GNUNET_ERROR_TYPE_ERROR, "realloc");
 296     GNUNET_assert (0);
 297   }
 298 #ifdef W32_MEM_LIMIT
 299   ptr = &((size_t *) ptr)[1];
 300 #endif
 301   return ptr;
 302 }
 303
 304
 305 #if __BYTE_ORDER == __LITTLE_ENDIAN
 306 #define BAADFOOD_STR "\x0D\xF0\xAD\xBA"
 307 #endif
 308 #if __BYTE_ORDER == __BIG_ENDIAN
 309 #define BAADFOOD_STR "\xBA\xAD\xF0\x0D"
 310 #endif
 311
 312 #if HAVE_MALLOC_NP_H
 313 #include <malloc_np.h>
 314 #endif
 315 #if HAVE_MALLOC_USABLE_SIZE
 316 #define M_SIZE(p) malloc_usable_size (p)
 317 #elif HAVE_MALLOC_SIZE
 318 #define M_SIZE(p) malloc_size (p)
 319 #endif
 320
 321 /**
 322  * Free memory. Merely a wrapper for the case that we
 323  * want to keep track of allocations.
 324  *
 325  * @param ptr the pointer to free
 326  * @param filename where in the code was the call to GNUNET_free
 327  * @param linenumber where in the code was the call to GNUNET_free
 328  */
 329 void
 330 GNUNET_xfree_ (void *ptr, const char *filename, int linenumber)
 331 {
 332   GNUNET_assert_at (NULL != ptr, filename, linenumber);
 333 #ifdef W32_MEM_LIMIT
 334   ptr = &((size_t *) ptr)[-1];
 335   mem_used -= *((size_t *) ptr);
 336 #endif
 337 #if defined(M_SIZE)
 338 #if ENABLE_POISONING
 339   {
 340     const uint64_t baadfood = GNUNET_ntohll (0xBAADF00DBAADF00DLL);
 341     uint64_t *base = ptr;
 342     size_t s = M_SIZE (ptr);
 343
 344     for (size_t i = 0; i < s / 8; i++)
 345       base[i] = baadfood;
 346     GNUNET_memcpy (&base[s / 8], &baadfood, s % 8);
 347   }
 348 #endif
 349 #endif
 350   free (ptr);
 351 }
 352
 353
 354 /**
 355  * Dup a string (same semantics as strdup).
 356  *
 357  * @param str the string to dup
 358  * @param filename where in the code was the call to GNUNET_strdup()
 359  * @param linenumber where in the code was the call to GNUNET_strdup()
 360  * @return `strdup(@a str)`
 361  */
 362 char *
 363 GNUNET_xstrdup_ (const char *str, const char *filename, int linenumber)
 364 {
 365   char *res;
 366   size_t slen;
 367
 368   GNUNET_assert_at (str != NULL, filename, linenumber);
 369   slen = strlen (str) + 1;
 370   res = GNUNET_xmalloc_ (slen, filename, linenumber);
 371   GNUNET_memcpy (res, str, slen);
 372   return res;
 373 }
 374
 375
 376 #if ! HAVE_STRNLEN
 377 static size_t
 378 strnlen (const char *s, size_t n)
 379 {
 380   const char *e;
 381
 382   e = memchr (s, '\0', n);
 383   if (NULL == e)
 384     return n;
 385   return e - s;
 386 }
 387
 388
 389 #endif
 390
 391
 392 /**
 393  * Dup partially a string (same semantics as strndup).
 394  *
 395  * @param str the string to dup
 396  * @param len the length of the string to dup
 397  * @param filename where in the code was the call to GNUNET_strndup()
 398  * @param linenumber where in the code was the call to GNUNET_strndup()
 399  * @return `strndup(@a str,@a len)`
 400  */
 401 char *
 402 GNUNET_xstrndup_ (const char *str,
 403                   size_t len,
 404                   const char *filename,
 405                   int linenumber)
 406 {
 407   char *res;
 408
 409   if (0 == len)
 410     return GNUNET_strdup ("");
 411   GNUNET_assert_at (NULL != str, filename, linenumber);
 412   len = strnlen (str, len);
 413   res = GNUNET_xmalloc_ (len + 1, filename, linenumber);
 414   GNUNET_memcpy (res, str, len);
 415   /* res[len] = '\0'; 'malloc' zeros out anyway */
 416   return res;
 417 }
 418
 419
 420 /**
 421  * Grow an array.  Grows old by (*oldCount-newCount)*elementSize bytes
 422  * and sets *oldCount to newCount.
 423  *
 424  * @param old address of the pointer to the array
 425  *        *old may be NULL
 426  * @param elementSize the size of the elements of the array
 427  * @param oldCount address of the number of elements in the *old array
 428  * @param newCount number of elements in the new array, may be 0
 429  * @param filename where in the code was the call to GNUNET_array_grow()
 430  * @param linenumber where in the code was the call to GNUNET_array_grow()
 431  */
 432 void
 433 GNUNET_xgrow_ (void **old,
 434                size_t elementSize,
 435                unsigned int *oldCount,
 436                unsigned int newCount,
 437                const char *filename,
 438                int linenumber)
 439 {
 440   void *tmp;
 441   size_t size;
 442
 443   GNUNET_assert_at (INT_MAX / elementSize > newCount, filename, linenumber);
 444   size = newCount * elementSize;
 445   if (0 == size)
 446   {
 447     tmp = NULL;
 448   }
 449   else
 450   {
 451     tmp = GNUNET_xmalloc_ (size, filename, linenumber);
 452     if (NULL != *old)
 453     {
 454       GNUNET_memcpy (tmp, *old, elementSize * GNUNET_MIN (*oldCount, newCount));
 455     }
 456   }
 457
 458   if (NULL != *old)
 459   {
 460     GNUNET_xfree_ (*old, filename, linenumber);
 461   }
 462   *old = tmp;
 463   *oldCount = newCount;
 464 }
 465
 466
 467 /**
 468  * Like asprintf(), just portable.
 469  *
 470  * @param buf set to a buffer of sufficient size (allocated, caller must free)
 471  * @param format format string (see printf(), fprintf(), etc.)
 472  * @param ... data for format string
 473  * @return number of bytes in `*@a buf`, excluding 0-termination
 474  */
 475 int
 476 GNUNET_asprintf (char **buf, const char *format, ...)
 477 {
 478   int ret;
 479   va_list args;
 480
 481   va_start (args, format);
 482   ret = vsnprintf (NULL, 0, format, args);
 483   va_end (args);
 484   GNUNET_assert (ret >= 0);
 485   *buf = GNUNET_malloc (ret + 1);
 486   va_start (args, format);
 487   ret = vsprintf (*buf, format, args);
 488   va_end (args);
 489   return ret;
 490 }
 491
 492
 493 /**
 494  * Like snprintf(), just aborts if the buffer is of insufficient size.
 495  *
 496  * @param buf pointer to buffer that is written to
 497  * @param size number of bytes in buf
 498  * @param format format strings
 499  * @param ... data for format string
 500  * @return number of bytes written to buf or negative value on error
 501  */
 502 int
 503 GNUNET_snprintf (char *buf, size_t size, const char *format, ...)
 504 {
 505   int ret;
 506   va_list args;
 507
 508   va_start (args, format);
 509   ret = vsnprintf (buf, size, format, args);
 510   va_end (args);
 511   GNUNET_assert ((ret >= 0) && (((size_t) ret) < size));
 512   return ret;
 513 }
 514
 515
 516 /**
 517  * Create a copy of the given message.
 518  *
 519  * @param msg message to copy
 520  * @return duplicate of the message
 521  */
 522 struct GNUNET_MessageHeader *
 523 GNUNET_copy_message (const struct GNUNET_MessageHeader *msg)
 524 {
 525   struct GNUNET_MessageHeader *ret;
 526   uint16_t msize;
 527
 528   msize = ntohs (msg->size);
 529   GNUNET_assert (msize >= sizeof(struct GNUNET_MessageHeader));
 530   ret = GNUNET_malloc (msize);
 531   GNUNET_memcpy (ret, msg, msize);
 532   return ret;
 533 }
 534
 535
 536 /* end of common_allocation.c */