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   ptr = realloc (ptr, n);
 269   if ((NULL == ptr) && (n > 0))
 270   {
 271     LOG_STRERROR (GNUNET_ERROR_TYPE_ERROR, "realloc");
 272     GNUNET_assert (0);
 273   }
 274 #ifdef W32_MEM_LIMIT
 275   ptr = &((size_t *) ptr)[1];
 276 #endif
 277   return ptr;
 278 }
 279
 280
 281 #if __BYTE_ORDER == __LITTLE_ENDIAN
 282 #define BAADFOOD_STR "\x0D\xF0\xAD\xBA"
 283 #endif
 284 #if __BYTE_ORDER == __BIG_ENDIAN
 285 #define BAADFOOD_STR "\xBA\xAD\xF0\x0D"
 286 #endif
 287
 288 #if WINDOWS
 289 #define M_SIZE(p) _msize (p)
 290 #endif
 291 #if HAVE_MALLOC_NP_H
 292 #include <malloc_np.h>
 293 #endif
 294 #if HAVE_MALLOC_USABLE_SIZE
 295 #define M_SIZE(p) malloc_usable_size (p)
 296 #elif HAVE_MALLOC_SIZE
 297 #define M_SIZE(p) malloc_size (p)
 298 #endif
 299
 300 /**
 301  * Free memory. Merely a wrapper for the case that we
 302  * want to keep track of allocations.
 303  *
 304  * @param ptr the pointer to free
 305  * @param filename where in the code was the call to GNUNET_free
 306  * @param linenumber where in the code was the call to GNUNET_free
 307  */
 308 void
 309 GNUNET_xfree_ (void *ptr, const char *filename, int linenumber)
 310 {
 311   GNUNET_assert_at (NULL != ptr, filename, linenumber);
 312 #ifdef W32_MEM_LIMIT
 313   ptr = &((size_t *) ptr)[-1];
 314   mem_used -= *((size_t *) ptr);
 315 #endif
 316 #if defined(M_SIZE)
 317 #if ENABLE_POISONING
 318   {
 319     const uint64_t baadfood = GNUNET_ntohll (0xBAADF00DBAADF00DLL);
 320     uint64_t *base = ptr;
 321     size_t s = M_SIZE (ptr);
 322     size_t i;
 323
 324     for (i = 0; i < s / 8; i++)
 325       base[i] = baadfood;
 326     GNUNET_memcpy (&base[s / 8], &baadfood, s % 8);
 327   }
 328 #endif
 329 #endif
 330   free (ptr);
 331 }
 332
 333
 334 /**
 335  * Dup a string (same semantics as strdup).
 336  *
 337  * @param str the string to dup
 338  * @param filename where in the code was the call to GNUNET_strdup()
 339  * @param linenumber where in the code was the call to GNUNET_strdup()
 340  * @return `strdup(@a str)`
 341  */
 342 char *
 343 GNUNET_xstrdup_ (const char *str, const char *filename, int linenumber)
 344 {
 345   char *res;
 346   size_t slen;
 347
 348   GNUNET_assert_at (str != NULL, filename, linenumber);
 349   slen = strlen (str) + 1;
 350   res = GNUNET_xmalloc_ (slen, filename, linenumber);
 351   GNUNET_memcpy (res, str, slen);
 352   return res;
 353 }
 354
 355
 356 #if ! HAVE_STRNLEN
 357 static size_t
 358 strnlen (const char *s, size_t n)
 359 {
 360   const char *e;
 361
 362   e = memchr (s, '\0', n);
 363   if (NULL == e)
 364     return n;
 365   return e - s;
 366 }
 367 #endif
 368
 369
 370 /**
 371  * Dup partially a string (same semantics as strndup).
 372  *
 373  * @param str the string to dup
 374  * @param len the length of the string to dup
 375  * @param filename where in the code was the call to GNUNET_strndup()
 376  * @param linenumber where in the code was the call to GNUNET_strndup()
 377  * @return `strndup(@a str,@a len)`
 378  */
 379 char *
 380 GNUNET_xstrndup_ (const char *str,
 381                   size_t len,
 382                   const char *filename,
 383                   int linenumber)
 384 {
 385   char *res;
 386
 387   if (0 == len)
 388     return GNUNET_strdup ("");
 389   GNUNET_assert_at (NULL != str, filename, linenumber);
 390   len = strnlen (str, len);
 391   res = GNUNET_xmalloc_ (len + 1, filename, linenumber);
 392   GNUNET_memcpy (res, str, len);
 393   /* res[len] = '\0'; 'malloc' zeros out anyway */
 394   return res;
 395 }
 396
 397
 398 /**
 399  * Grow an array.  Grows old by (*oldCount-newCount)*elementSize bytes
 400  * and sets *oldCount to newCount.
 401  *
 402  * @param old address of the pointer to the array
 403  *        *old may be NULL
 404  * @param elementSize the size of the elements of the array
 405  * @param oldCount address of the number of elements in the *old array
 406  * @param newCount number of elements in the new array, may be 0
 407  * @param filename where in the code was the call to GNUNET_array_grow()
 408  * @param linenumber where in the code was the call to GNUNET_array_grow()
 409  */
 410 void
 411 GNUNET_xgrow_ (void **old,
 412                size_t elementSize,
 413                unsigned int *oldCount,
 414                unsigned int newCount,
 415                const char *filename,
 416                int linenumber)
 417 {
 418   void *tmp;
 419   size_t size;
 420
 421   GNUNET_assert_at (INT_MAX / elementSize > newCount, filename, linenumber);
 422   size = newCount * elementSize;
 423   if (0 == size)
 424   {
 425     tmp = NULL;
 426   }
 427   else
 428   {
 429     tmp = GNUNET_xmalloc_ (size, filename, linenumber);
 430     if (NULL != *old)
 431     {
 432       GNUNET_memcpy (tmp, *old, elementSize * GNUNET_MIN (*oldCount, newCount));
 433     }
 434   }
 435
 436   if (NULL != *old)
 437   {
 438     GNUNET_xfree_ (*old, filename, linenumber);
 439   }
 440   *old = tmp;
 441   *oldCount = newCount;
 442 }
 443
 444
 445 /**
 446  * Like asprintf(), just portable.
 447  *
 448  * @param buf set to a buffer of sufficient size (allocated, caller must free)
 449  * @param format format string (see printf(), fprintf(), etc.)
 450  * @param ... data for format string
 451  * @return number of bytes in `*@a buf`, excluding 0-termination
 452  */
 453 int
 454 GNUNET_asprintf (char **buf, const char *format, ...)
 455 {
 456   int ret;
 457   va_list args;
 458
 459   va_start (args, format);
 460   ret = vsnprintf (NULL, 0, format, args);
 461   va_end (args);
 462   GNUNET_assert (ret >= 0);
 463   *buf = GNUNET_malloc (ret + 1);
 464   va_start (args, format);
 465   ret = vsprintf (*buf, format, args);
 466   va_end (args);
 467   return ret;
 468 }
 469
 470
 471 /**
 472  * Like snprintf(), just aborts if the buffer is of insufficient size.
 473  *
 474  * @param buf pointer to buffer that is written to
 475  * @param size number of bytes in buf
 476  * @param format format strings
 477  * @param ... data for format string
 478  * @return number of bytes written to buf or negative value on error
 479  */
 480 int
 481 GNUNET_snprintf (char *buf, size_t size, const char *format, ...)
 482 {
 483   int ret;
 484   va_list args;
 485
 486   va_start (args, format);
 487   ret = vsnprintf (buf, size, format, args);
 488   va_end (args);
 489   GNUNET_assert ((ret >= 0) && (((size_t) ret) < size));
 490   return ret;
 491 }
 492
 493
 494 /**
 495  * Create a copy of the given message.
 496  *
 497  * @param msg message to copy
 498  * @return duplicate of the message
 499  */
 500 struct GNUNET_MessageHeader *
 501 GNUNET_copy_message (const struct GNUNET_MessageHeader *msg)
 502 {
 503   struct GNUNET_MessageHeader *ret;
 504   uint16_t msize;
 505
 506   msize = ntohs (msg->size);
 507   GNUNET_assert (msize >= sizeof (struct GNUNET_MessageHeader));
 508   ret = GNUNET_malloc (msize);
 509   GNUNET_memcpy (ret, msg, msize);
 510   return ret;
 511 }
 512
 513
 514 /* end of common_allocation.c */