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 2, 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_common.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     size_t i;
 226     char baadfood[5] = BAADFOOD_STR;
 227     size_t s = M_SIZE (ptr);
 228     for (i = 0; i < s; i++)
 229       ((char *) ptr)[i] = baadfood[i % 4];
 230   }
 231 #endif
 232 #endif
 233   free (ptr);
 234 }
 235
 236 /**
 237  * Dup a string (same semantics as strdup).
 238  *
 239  * @param str the string to dup
 240  * @param filename where in the code was the call to GNUNET_strdup
 241  * @param linenumber where in the code was the call to GNUNET_strdup
 242  * @return strdup(str)
 243  */
 244 char *
 245 GNUNET_xstrdup_ (const char *str, const char *filename, int linenumber)
 246 {
 247   char *res;
 248
 249   GNUNET_assert_at (str != NULL, filename, linenumber);
 250   res = GNUNET_xmalloc_ (strlen (str) + 1, filename, linenumber);
 251   memcpy (res, str, strlen (str) + 1);
 252   return res;
 253 }
 254
 255
 256 /**
 257  * Dup partially a string (same semantics as strndup).
 258  *
 259  * @param str the string to dup
 260  * @param len the length of the string to dup
 261  * @param filename where in the code was the call to GNUNET_strndup
 262  * @param linenumber where in the code was the call to GNUNET_strndup
 263  * @return strndup(str,len)
 264  */
 265 char *
 266 GNUNET_xstrndup_ (const char *str, size_t len, const char *filename,
 267                   int linenumber)
 268 {
 269   char *res;
 270
 271   GNUNET_assert_at (str != NULL, filename, linenumber);
 272   len = GNUNET_MIN (len, strlen (str));
 273   res = GNUNET_xmalloc_ (len + 1, filename, linenumber);
 274   memcpy (res, str, len);
 275   /* res[len] = '\0'; 'malloc' zeros out anyway */
 276   return res;
 277 }
 278
 279
 280 /**
 281  * Grow an array.  Grows old by (*oldCount-newCount)*elementSize bytes
 282  * and sets *oldCount to newCount.
 283  *
 284  * @param old address of the pointer to the array
 285  *        *old may be NULL
 286  * @param elementSize the size of the elements of the array
 287  * @param oldCount address of the number of elements in the *old array
 288  * @param newCount number of elements in the new array, may be 0
 289  * @param filename where in the code was the call to GNUNET_array_grow
 290  * @param linenumber where in the code was the call to GNUNET_array_grow
 291  */
 292 void
 293 GNUNET_xgrow_ (void **old, size_t elementSize, unsigned int *oldCount,
 294                unsigned int newCount, const char *filename, int linenumber)
 295 {
 296   void *tmp;
 297   size_t size;
 298
 299   GNUNET_assert_at (INT_MAX / elementSize > newCount, filename, linenumber);
 300   size = newCount * elementSize;
 301   if (size == 0)
 302   {
 303     tmp = NULL;
 304   }
 305   else
 306   {
 307     tmp = GNUNET_xmalloc_ (size, filename, linenumber);
 308     memset (tmp, 0, size);      /* client code should not rely on this, though... */
 309     if (*oldCount > newCount)
 310       *oldCount = newCount;     /* shrink is also allowed! */
 311     memcpy (tmp, *old, elementSize * (*oldCount));
 312   }
 313
 314   if (*old != NULL)
 315   {
 316     GNUNET_xfree_ (*old, filename, linenumber);
 317   }
 318   *old = tmp;
 319   *oldCount = newCount;
 320 }
 321
 322
 323 /**
 324  * Like asprintf, just portable.
 325  *
 326  * @param buf set to a buffer of sufficient size (allocated, caller must free)
 327  * @param format format string (see printf, fprintf, etc.)
 328  * @param ... data for format string
 329  * @return number of bytes in "*buf" excluding 0-termination
 330  */
 331 int
 332 GNUNET_asprintf (char **buf, const char *format, ...)
 333 {
 334   int ret;
 335   va_list args;
 336
 337   va_start (args, format);
 338   ret = VSNPRINTF (NULL, 0, format, args);
 339   va_end (args);
 340   *buf = GNUNET_malloc (ret + 1);
 341   va_start (args, format);
 342   ret = VSPRINTF (*buf, format, args);
 343   va_end (args);
 344   return ret;
 345 }
 346
 347
 348 /**
 349  * Like snprintf, just aborts if the buffer is of insufficient size.
 350  *
 351  * @param buf pointer to buffer that is written to
 352  * @param size number of bytes in buf
 353  * @param format format strings
 354  * @param ... data for format string
 355  * @return number of bytes written to buf or negative value on error
 356  */
 357 int
 358 GNUNET_snprintf (char *buf, size_t size, const char *format, ...)
 359 {
 360   int ret;
 361   va_list args;
 362
 363   va_start (args, format);
 364   ret = VSNPRINTF (buf, size, format, args);
 365   va_end (args);
 366   GNUNET_assert (ret <= size);
 367   return ret;
 368 }
 369
 370
 371 /**
 372  * Create a copy of the given message.
 373  *
 374  * @param msg message to copy
 375  * @return duplicate of the message
 376  */
 377 struct GNUNET_MessageHeader *
 378 GNUNET_copy_message (const struct GNUNET_MessageHeader *msg)
 379 {
 380   struct GNUNET_MessageHeader *ret;
 381   uint16_t msize;
 382
 383   msize = ntohs (msg->size);
 384   GNUNET_assert (msize >= sizeof (struct GNUNET_MessageHeader));
 385   ret = GNUNET_malloc (msize);
 386   memcpy (ret, msg, msize);
 387   return ret;
 388 }
 389
 390
 391 /* end of common_allocation.c */