src/util/common_allocation.c

   1 /*
   2      This file is part of GNUnet.
   3      (C) 2001, 2002, 2003, 2005, 2006 Christian Grothoff (and other contributing authors)
   4
   5      GNUnet is free software; you can redistribute it and/or modify
   6      it under the terms of the GNU General Public License as published
   7      by the Free Software Foundation; either version 3, or (at your
   8      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      General Public License for more details.
  14
  15      You should have received a copy of the GNU General Public License
  16      along with GNUnet; see the file COPYING.  If not, write to the
  17      Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  18      Boston, MA 02111-1307, USA.
  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_util_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,...) GNUNET_log_from (kind, "util",__VA_ARGS__)
  36
  37 #define LOG_STRERROR(kind,syscall) GNUNET_log_from_strerror (kind, "util", syscall)
  38
  39 #ifndef INT_MAX
  40 #define INT_MAX 0x7FFFFFFF
  41 #endif
  42
  43 #if 0
  44 #define W32_MEM_LIMIT 200000000
  45 #endif
  46
  47 #ifdef W32_MEM_LIMIT
  48 static LONG mem_used = 0;
  49 #endif
  50
  51 /**
  52  * Allocate memory. Checks the return value, aborts if no more
  53  * memory is available.
  54  *
  55  * @param size how many bytes of memory to allocate, do NOT use
  56  *  this function (or GNUNET_malloc) to allocate more than several MB
  57  *  of memory, if you are possibly needing a very large chunk use
  58  *  GNUNET_xmalloc_unchecked_ instead.
  59  * @param filename where in the code was the call to GNUNET_malloc
  60  * @param linenumber where in the code was the call to GNUNET_malloc
  61  * @return pointer to size bytes of memory
  62  */
  63 void *
  64 GNUNET_xmalloc_ (size_t size, const char *filename, int linenumber)
  65 {
  66   void *ret;
  67
  68   /* As a security precaution, we generally do not allow very large
  69    * allocations using the default 'GNUNET_malloc' macro */
  70   GNUNET_assert_at (size <= GNUNET_MAX_MALLOC_CHECKED, filename, linenumber);
  71   ret = GNUNET_xmalloc_unchecked_ (size, filename, linenumber);
  72   if (ret == NULL)
  73   {
  74     LOG_STRERROR (GNUNET_ERROR_TYPE_ERROR, "malloc");
  75     GNUNET_abort ();
  76   }
  77   return ret;
  78 }
  79
  80
  81 /**
  82  * Allocate and initialize memory. Checks the return value, aborts if no more
  83  * memory is available.  Don't use GNUNET_xmemdup_ directly. Use the
  84  * GNUNET_memdup macro.
  85  *
  86  * @param buf buffer to initialize from (must contain size bytes)
  87  * @param size number of bytes to allocate
  88  * @param filename where is this call being made (for debugging)
  89  * @param linenumber line where this call is being made (for debugging)
  90  * @return allocated memory, never NULL
  91  */
  92 void *
  93 GNUNET_xmemdup_ (const void *buf, size_t size, const char *filename,
  94                  int linenumber)
  95 {
  96   void *ret;
  97
  98   /* As a security precaution, we generally do not allow very large
  99    * allocations here */
 100   GNUNET_assert_at (size <= GNUNET_MAX_MALLOC_CHECKED, filename, linenumber);
 101 #ifdef W32_MEM_LIMIT
 102   size += sizeof (size_t);
 103   if (mem_used + size > W32_MEM_LIMIT)
 104     return NULL;
 105 #endif
 106   GNUNET_assert_at (size < INT_MAX, filename, linenumber);
 107   ret = malloc (size);
 108   if (ret == NULL)
 109   {
 110     LOG_STRERROR (GNUNET_ERROR_TYPE_ERROR, "malloc");
 111     GNUNET_abort ();
 112   }
 113 #ifdef W32_MEM_LIMIT
 114   *((size_t *) ret) = size;
 115   ret = &((size_t *) ret)[1];
 116   mem_used += size;
 117 #endif
 118   memcpy (ret, buf, size);
 119   return ret;
 120 }
 121
 122
 123
 124 /**
 125  * Wrapper around malloc. Allocates size bytes of memory.
 126  * The memory will be zero'ed out.
 127  *
 128  * @param size the number of bytes to allocate
 129  * @param filename where in the code was the call to GNUNET_malloc_large
 130  * @param linenumber where in the code was the call to GNUNET_malloc_large
 131  * @return pointer to size bytes of memory, NULL if we do not have enough memory
 132  */
 133 void *
 134 GNUNET_xmalloc_unchecked_ (size_t size, const char *filename, int linenumber)
 135 {
 136   void *result;
 137
 138 #ifdef W32_MEM_LIMIT
 139   size += sizeof (size_t);
 140   if (mem_used + size > W32_MEM_LIMIT)
 141     return NULL;
 142 #endif
 143
 144   result = malloc (size);
 145   if (result == NULL)
 146     return NULL;
 147   memset (result, 0, size);
 148
 149 #ifdef W32_MEM_LIMIT
 150   *((size_t *) result) = size;
 151   result = &((size_t *) result)[1];
 152   mem_used += size;
 153 #endif
 154
 155   return result;
 156 }
 157
 158
 159 /**
 160  * Reallocate memory. Checks the return value, aborts if no more
 161  * memory is available.
 162  *
 163  * @param ptr the pointer to reallocate
 164  * @param n how many bytes of memory to allocate
 165  * @param filename where in the code was the call to GNUNET_realloc
 166  * @param linenumber where in the code was the call to GNUNET_realloc
 167  * @return pointer to size bytes of memory
 168  */
 169 void *
 170 GNUNET_xrealloc_ (void *ptr, size_t n, const char *filename, int linenumber)
 171 {
 172 #ifdef W32_MEM_LIMIT
 173   n += sizeof (size_t);
 174   ptr = &((size_t *) ptr)[-1];
 175   mem_used = mem_used - *((size_t *) ptr) + n;
 176 #endif
 177   ptr = realloc (ptr, n);
 178   if ((NULL == ptr) && (n > 0))
 179   {
 180     LOG_STRERROR (GNUNET_ERROR_TYPE_ERROR, "realloc");
 181     GNUNET_abort ();
 182   }
 183 #ifdef W32_MEM_LIMIT
 184   ptr = &((size_t *) ptr)[1];
 185 #endif
 186   return ptr;
 187 }
 188
 189
 190 # if __BYTE_ORDER == __LITTLE_ENDIAN
 191 #define BAADFOOD_STR "\x0D\xF0\xAD\xBA"
 192 #endif
 193 # if __BYTE_ORDER == __BIG_ENDIAN
 194 #define BAADFOOD_STR "\xBA\xAD\xF0\x0D"
 195 #endif
 196
 197 #if WINDOWS
 198 #define M_SIZE(p) _msize (p)
 199 #endif
 200 #if HAVE_MALLOC_USABLE_SIZE
 201 #define M_SIZE(p) malloc_usable_size (p)
 202 #elif HAVE_MALLOC_SIZE
 203 #define M_SIZE(p) malloc_size (p)
 204 #endif
 205
 206 /**
 207  * Free memory. Merely a wrapper for the case that we
 208  * want to keep track of allocations.
 209  *
 210  * @param ptr the pointer to free
 211  * @param filename where in the code was the call to GNUNET_array_grow
 212  * @param linenumber where in the code was the call to GNUNET_array_grow
 213  */
 214 void
 215 GNUNET_xfree_ (void *ptr, const char *filename, int linenumber)
 216 {
 217   GNUNET_assert_at (ptr != NULL, filename, linenumber);
 218 #ifdef W32_MEM_LIMIT
 219   ptr = &((size_t *) ptr)[-1];
 220   mem_used -= *((size_t *) ptr);
 221 #endif
 222 #if defined(M_SIZE)
 223 #if ENABLE_POISONING
 224   {
 225     const uint64_t baadfood = GNUNET_ntohll (0xBAADF00DBAADF00DLL);
 226     uint64_t *base = ptr;
 227     size_t s = M_SIZE (ptr);
 228     size_t i;
 229
 230     for (i=0;i<s/8;i++)
 231       base[i] = baadfood;
 232     memcpy (&base[s/8], &baadfood, s % 8);
 233   }
 234 #endif
 235 #endif
 236   free (ptr);
 237 }
 238
 239 /**
 240  * Dup a string (same semantics as strdup).
 241  *
 242  * @param str the string to dup
 243  * @param filename where in the code was the call to GNUNET_strdup
 244  * @param linenumber where in the code was the call to GNUNET_strdup
 245  * @return strdup(str)
 246  */
 247 char *
 248 GNUNET_xstrdup_ (const char *str, const char *filename, int linenumber)
 249 {
 250   char *res;
 251
 252   GNUNET_assert_at (str != NULL, filename, linenumber);
 253   res = GNUNET_xmalloc_ (strlen (str) + 1, filename, linenumber);
 254   memcpy (res, str, strlen (str) + 1);
 255   return res;
 256 }
 257
 258
 259 #if ! HAVE_STRNLEN
 260 static size_t
 261 strnlen (const char *s,
 262          size_t n)
 263 {
 264   const char *e;
 265
 266   e = memchr (s, '\0', n);
 267   if (NULL == e)
 268     return n;
 269   return e - s;
 270 }
 271 #endif
 272
 273
 274 /**
 275  * Dup partially a string (same semantics as strndup).
 276  *
 277  * @param str the string to dup
 278  * @param len the length of the string to dup
 279  * @param filename where in the code was the call to GNUNET_strndup
 280  * @param linenumber where in the code was the call to GNUNET_strndup
 281  * @return strndup(str,len)
 282  */
 283 char *
 284 GNUNET_xstrndup_ (const char *str, size_t len, const char *filename,
 285                   int linenumber)
 286 {
 287   char *res;
 288
 289   if (0 == len)
 290     return GNUNET_strdup ("");
 291   GNUNET_assert_at (str != NULL, filename, linenumber);
 292   len = strnlen (str, len);
 293   res = GNUNET_xmalloc_ (len + 1, filename, linenumber);
 294   memcpy (res, str, len);
 295   /* res[len] = '\0'; 'malloc' zeros out anyway */
 296   return res;
 297 }
 298
 299
 300 /**
 301  * Grow an array.  Grows old by (*oldCount-newCount)*elementSize bytes
 302  * and sets *oldCount to newCount.
 303  *
 304  * @param old address of the pointer to the array
 305  *        *old may be NULL
 306  * @param elementSize the size of the elements of the array
 307  * @param oldCount address of the number of elements in the *old array
 308  * @param newCount number of elements in the new array, may be 0
 309  * @param filename where in the code was the call to GNUNET_array_grow
 310  * @param linenumber where in the code was the call to GNUNET_array_grow
 311  */
 312 void
 313 GNUNET_xgrow_ (void **old, size_t elementSize, unsigned int *oldCount,
 314                unsigned int newCount, const char *filename, int linenumber)
 315 {
 316   void *tmp;
 317   size_t size;
 318
 319   GNUNET_assert_at (INT_MAX / elementSize > newCount, filename, linenumber);
 320   size = newCount * elementSize;
 321   if (size == 0)
 322   {
 323     tmp = NULL;
 324   }
 325   else
 326   {
 327     tmp = GNUNET_xmalloc_ (size, filename, linenumber);
 328     memset (tmp, 0, size);      /* client code should not rely on this, though... */
 329     if (*oldCount > newCount)
 330       *oldCount = newCount;     /* shrink is also allowed! */
 331     memcpy (tmp, *old, elementSize * (*oldCount));
 332   }
 333
 334   if (*old != NULL)
 335   {
 336     GNUNET_xfree_ (*old, filename, linenumber);
 337   }
 338   *old = tmp;
 339   *oldCount = newCount;
 340 }
 341
 342
 343 /**
 344  * Like asprintf, just portable.
 345  *
 346  * @param buf set to a buffer of sufficient size (allocated, caller must free)
 347  * @param format format string (see printf, fprintf, etc.)
 348  * @param ... data for format string
 349  * @return number of bytes in "*buf" excluding 0-termination
 350  */
 351 int
 352 GNUNET_asprintf (char **buf, const char *format, ...)
 353 {
 354   int ret;
 355   va_list args;
 356
 357   va_start (args, format);
 358   ret = VSNPRINTF (NULL, 0, format, args);
 359   va_end (args);
 360   *buf = GNUNET_malloc (ret + 1);
 361   va_start (args, format);
 362   ret = VSPRINTF (*buf, format, args);
 363   va_end (args);
 364   return ret;
 365 }
 366
 367
 368 /**
 369  * Like snprintf, just aborts if the buffer is of insufficient size.
 370  *
 371  * @param buf pointer to buffer that is written to
 372  * @param size number of bytes in buf
 373  * @param format format strings
 374  * @param ... data for format string
 375  * @return number of bytes written to buf or negative value on error
 376  */
 377 int
 378 GNUNET_snprintf (char *buf, size_t size, const char *format, ...)
 379 {
 380   int ret;
 381   va_list args;
 382
 383   va_start (args, format);
 384   ret = VSNPRINTF (buf, size, format, args);
 385   va_end (args);
 386   GNUNET_assert (ret <= size);
 387   return ret;
 388 }
 389
 390
 391 /**
 392  * Create a copy of the given message.
 393  *
 394  * @param msg message to copy
 395  * @return duplicate of the message
 396  */
 397 struct GNUNET_MessageHeader *
 398 GNUNET_copy_message (const struct GNUNET_MessageHeader *msg)
 399 {
 400   struct GNUNET_MessageHeader *ret;
 401   uint16_t msize;
 402
 403   msize = ntohs (msg->size);
 404   GNUNET_assert (msize >= sizeof (struct GNUNET_MessageHeader));
 405   ret = GNUNET_malloc (msize);
 406   memcpy (ret, msg, msize);
 407   return ret;
 408 }
 409
 410
 411 /* end of common_allocation.c */