1 files changed, 51 insertions, 12 deletions

diff --git a/src/include/gnunet_common.h b/src/include/gnunet_common.h
index 78aeb3de7..033a68894 100644
--- a/src/include/gnunet_common.h
+++ b/src/include/gnunet_common.h
@@ -1209,7 +1209,10 @@ GNUNET_is_zero_ (const void *a,
  * @param n number of elements in the array
  * @param type name of the struct or union, i.e. pass 'struct Foo'.
  */
-#define GNUNET_new_array(n, type) (type *) GNUNET_malloc ((n) * sizeof(type))
+#define GNUNET_new_array(n, type) ({ \
+    GNUNET_assert (SIZE_MAX / sizeof (type) >= n); \
+    (type *) GNUNET_malloc ((n) * sizeof(type));   \
+  })
 
 /**
  * @ingroup memory
@@ -1284,23 +1287,23 @@ GNUNET_is_zero_ (const void *a,
  * @ingroup memory
  * Wrapper around free. Frees the memory referred to by ptr.
  * Note that it is generally better to free memory that was
- * allocated with #GNUNET_array_grow using #GNUNET_array_grow(mem, size, 0) instead of #GNUNET_free.
+ * allocated with #GNUNET_array_grow using #GNUNET_array_grow(mem, size, 0) instead of #GNUNET_free_nz.
  *
  * @param ptr location where to free the memory. ptr must have
  *     been returned by #GNUNET_strdup, #GNUNET_strndup, #GNUNET_malloc or #GNUNET_array_grow earlier.
  */
-#define GNUNET_free(ptr) GNUNET_xfree_ (ptr, __FILE__, __LINE__)
+#define GNUNET_free_nz(ptr) GNUNET_xfree_ (ptr, __FILE__, __LINE__)
 
 /**
  * @ingroup memory
  * Wrapper around free. Frees the memory referred to by ptr and sets ptr to NULL.
  * Note that it is generally better to free memory that was
- * allocated with #GNUNET_array_grow using #GNUNET_array_grow(mem, size, 0) instead of #GNUNET_freez.
+ * allocated with #GNUNET_array_grow using #GNUNET_array_grow(mem, size, 0) instead of #GNUNET_free.
  *
  * @param ptr location where to free the memory. ptr must have
  *     been returned by #GNUNET_strdup, #GNUNET_strndup, #GNUNET_malloc or #GNUNET_array_grow earlier.
  */
-#define GNUNET_freez(ptr) do { \
+#define GNUNET_free(ptr) do { \
     GNUNET_xfree_ (ptr, __FILE__, __LINE__); \
     ptr = NULL; \
 } while (0)
@@ -1389,22 +1392,58 @@ GNUNET_is_zero_ (const void *a,
 
 /**
  * @ingroup memory
- * Append an element to a list (growing the list by one).
+ * Append an element to an array (growing the array by one).
  *
- * @param arr base-pointer of the vector, may be NULL if size is 0;
+ * @param arr base-pointer of the vector, may be NULL if @a len is 0;
  *        will be updated to reflect the new address. The TYPE of
  *        arr is important since size is the number of elements and
  *        not the size in bytes
- * @param size the number of elements in the existing vector (number
+ * @param len the number of elements in the existing vector (number
  *        of elements to copy over), will be updated with the new
- *        array size
+ *        array length
  * @param element the element that will be appended to the array
  */
-#define GNUNET_array_append(arr, size, element) \
+#define GNUNET_array_append(arr, len, element) \
+  do                                            \
+  {                                             \
+    GNUNET_assert ((len) + 1 > (len)); \
+    GNUNET_array_grow (arr, len, len + 1);    \
+    (arr) [len - 1] = element;                  \
+  } while (0)
+
+
+/**
+ * @ingroup memory
+ * Append @a arr2 to @a arr1 (growing @a arr1
+ * as needed).  The @a arr2 array is left unchanged. Naturally
+ * this function performs a shallow copy. Both arrays must have
+ * the same type for their elements.
+ *
+ * @param arr1 base-pointer of the vector, may be NULL if @a len is 0;
+ *        will be updated to reflect the new address. The TYPE of
+ *        arr is important since size is the number of elements and
+ *        not the size in bytes
+ * @param len1 the number of elements in the existing vector (number
+ *        of elements to copy over), will be updated with the new
+ *        array size
+ * @param arr2 base-pointer a second array to concatenate, may be NULL if @a len2 is 0;
+ *        will be updated to reflect the new address. The TYPE of
+ *        arr is important since size is the number of elements and
+ *        not the size in bytes
+ * @param len the number of elements in the existing vector (number
+ *        of elements to copy over), will be updated with the new
+ *        array size
+
+ */
+#define GNUNET_array_concatenate(arr1, len1, arr2, len2)   \
   do                                            \
   {                                             \
-    GNUNET_array_grow (arr, size, size + 1);    \
-    (arr) [size - 1] = element;                  \
+    const typeof (*arr2) * _a1 = (arr1);  \
+    const typeof (*arr1) * _a2 = (arr2);  \
+    GNUNET_assert ((len1) + (len2) >= (len1));                    \
+    GNUNET_assert (SIZE_MAX / sizeof (*_a1) >= ((len1) + (len2))); \
+    GNUNET_array_grow (arr1, len1, (len1) + (len2));            \
+    memcpy (&(arr1) [(len1) - (len2)], _a2, (len2) * sizeof (*arr1));    \
   } while (0)
 
 /**