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