WiP

[oweals/gnunet.git] / src / util / common_allocation.c

diff --git a/src/util/common_allocation.c b/src/util/common_allocation.c
index 748ca620dff67a717f1b820683bc5b77fedd74e6..59fa2dc05209058bf75a572789c8288555e1115e 100644 (file)
--- a/src/util/common_allocation.c
+++ b/src/util/common_allocation.c
@@ -31,6 +31,14 @@
 #define INT_MAX 0x7FFFFFFF
 #endif
 
+#if 0
+#define W32_MEM_LIMIT 200000000
+#endif
+
+#ifdef W32_MEM_LIMIT
+static LONG mem_used = 0;
+#endif
+
 /**
  * Allocate memory. Checks the return value, aborts if no more
  * memory is available.
@@ -39,35 +47,103 @@
  *  this function (or GNUNET_malloc) to allocate more than several MB
  *  of memory, if you are possibly needing a very large chunk use
  *  GNUNET_xmalloc_unchecked_ instead.
- * @param filename where in the code was the call to GNUNET_array_grow
- * @param linenumber where in the code was the call to GNUNET_array_grow
+ * @param filename where in the code was the call to GNUNET_malloc
+ * @param linenumber where in the code was the call to GNUNET_malloc
  * @return pointer to size bytes of memory
  */
 void *
 GNUNET_xmalloc_ (size_t size, const char *filename, int linenumber)
 {
+  void *ret;
   /* As a security precaution, we generally do not allow very large
      allocations using the default 'GNUNET_malloc' macro */
   GNUNET_assert_at (size <= GNUNET_MAX_MALLOC_CHECKED, filename, linenumber);
-  return GNUNET_xmalloc_unchecked_ (size, filename, linenumber);
+  ret = GNUNET_xmalloc_unchecked_ (size, filename, linenumber);
+  if (ret == NULL)
+    {
+      GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "malloc");
+      abort ();
+    }
+  return ret;
+}
+
+
+/**
+ * Allocate and initialize memory. Checks the return value, aborts if no more
+ * memory is available.  Don't use GNUNET_xmemdup_ directly. Use the
+ * GNUNET_memdup macro.
+ *
+ * @param buf buffer to initialize from (must contain size bytes)
+ * @param size number of bytes to allocate
+ * @param filename where is this call being made (for debugging)
+ * @param linenumber line where this call is being made (for debugging)
+ * @return allocated memory, never NULL
+ */
+void *GNUNET_xmemdup_ (const void *buf, size_t size, const char *filename, int linenumber)
+{
+  void *ret;
+  /* As a security precaution, we generally do not allow very large
+     allocations here */
+  GNUNET_assert_at (size <= GNUNET_MAX_MALLOC_CHECKED, filename, linenumber);
+#ifdef W32_MEM_LIMIT
+  size += sizeof (size_t);
+  if (mem_used + size > W32_MEM_LIMIT)
+    return NULL;
+#endif
+  GNUNET_assert_at (size < INT_MAX, filename, linenumber);
+  ret = malloc (size);
+  if (ret == NULL)
+    {
+      GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "malloc");
+      abort ();
+    }
+#ifdef W32_MEM_LIMIT
+  *((size_t *) ret) = size;
+  ret = &((size_t *) ret)[1];
+  mem_used += size;
+#endif
+  memcpy (ret, buf, size);
+  return ret;
 }
 
+
+
+/**
+ * Wrapper around malloc. Allocates size bytes of memory.
+ * The memory will be zero'ed out.
+ *
+ * @param size the number of bytes to allocate
+ * @param filename where in the code was the call to GNUNET_malloc_large
+ * @param linenumber where in the code was the call to GNUNET_malloc_large
+ * @return pointer to size bytes of memory, NULL if we do not have enough memory
+ */
 void *
 GNUNET_xmalloc_unchecked_ (size_t size, const char *filename, int linenumber)
 {
   void *result;
 
+#ifdef W32_MEM_LIMIT
+  size += sizeof (size_t);
+  if (mem_used + size > W32_MEM_LIMIT)
+    return NULL;
+#endif
+
   GNUNET_assert_at (size < INT_MAX, filename, linenumber);
   result = malloc (size);
   if (result == NULL)
-    {
-      GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "malloc");
-      abort ();
-    }
+    return NULL;
   memset (result, 0, size);
+
+#ifdef W32_MEM_LIMIT
+  *((size_t *) result) = size;
+  result = &((size_t *) result)[1];
+  mem_used += size;
+#endif
+
   return result;
 }
 
+
 /**
  * Reallocate memory. Checks the return value, aborts if no more
  * memory is available.
@@ -80,17 +156,27 @@ GNUNET_xmalloc_unchecked_ (size_t size, const char *filename, int linenumber)
  */
 void *
 GNUNET_xrealloc_ (void *ptr,
-                  const size_t n, const char *filename, int linenumber)
+                  size_t n,
+                  const char *filename, int linenumber)
 {
+#ifdef W32_MEM_LIMIT
+  n += sizeof (size_t);
+  ptr = &((size_t *) ptr)[-1];
+  mem_used = mem_used - *((size_t *) ptr) + n;
+#endif
   ptr = realloc (ptr, n);
   if (!ptr)
     {
       GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "realloc");
       abort ();
     }
+#ifdef W32_MEM_LIMIT
+  ptr = &((size_t *) ptr)[1];
+#endif
   return ptr;
 }
 
+
 /**
  * Free memory. Merely a wrapper for the case that we
  * want to keep track of allocations.
@@ -103,6 +189,10 @@ void
 GNUNET_xfree_ (void *ptr, const char *filename, int linenumber)
 {
   GNUNET_assert_at (ptr != NULL, filename, linenumber);
+#ifdef W32_MEM_LIMIT
+  ptr = &((size_t *) ptr)[-1];
+  mem_used -= *((size_t *) ptr);
+#endif
   free (ptr);
 }
 
@@ -110,8 +200,8 @@ GNUNET_xfree_ (void *ptr, const char *filename, int linenumber)
  * Dup a string (same semantics as strdup).
  *
  * @param str the string to dup
- * @param filename where in the code was the call to GNUNET_array_grow
- * @param linenumber where in the code was the call to GNUNET_array_grow
+ * @param filename where in the code was the call to GNUNET_strdup
+ * @param linenumber where in the code was the call to GNUNET_strdup
  * @return strdup(str)
  */
 char *
@@ -217,5 +307,4 @@ GNUNET_snprintf (char *buf, size_t size, const char *format, ...)
   return ret;
 }
 
-
 /* end of common_allocation.c */