add realloc_array function

Adds a new memory reallocation function for arrays which
includes an overflow check on the size multiplication.

include/private/memory.h

@@ -114,6 +114,11 @@ size_t get_paged_size( size_t size );
  *         allocation failure error.
  */
 void *realloc_mem( const void *mem, size_t size );
+
+// A wrapper for alloc_mem that checks for overflow before proper allocation
 void *alloc_array( size_t item_count, size_t item_size );
 
+// A wrapper for realloc_mem that checks for overflow before proper allocation
+void *realloc_array( const void *mem, size_t item_count, size_t item_size );
+
 #endif /* __STUMPLESS_PRIVATE_MEMORY_H */

src/cache.c

@@ -67,7 +67,7 @@ add_page( struct cache *c ) {
   char **new_pages;
   char *new_page;
 
-  new_pages = realloc_mem( c->pages, sizeof( char * ) * ( c->page_count + 1 ) );
+  new_pages = realloc_array( c->pages, ( c->page_count + 1 ), sizeof( char * ) );
   if( !new_pages ) {
     return -1;
   }

src/element.c

@@ -56,18 +56,13 @@ struct stumpless_element *
 stumpless_add_param( struct stumpless_element *element,
                      struct stumpless_param *param ) {
   struct stumpless_param **new_params;
-  size_t old_params_size;
-  size_t new_params_size;
 
   VALIDATE_ARG_NOT_NULL( element );
   VALIDATE_ARG_NOT_NULL( param );
 
   lock_element( element );
 
-  old_params_size = sizeof( param ) * element->param_count;
-  new_params_size = old_params_size + sizeof( param );
-
-  new_params = realloc_mem( element->params, new_params_size );
+  new_params = realloc_array( element->params, element->param_count + 1, sizeof( struct stumpless_param * ) );
   if( !new_params ) {
     unlock_element( element );
     return NULL;

src/memory.c

@@ -136,6 +136,15 @@ alloc_array( size_t item_count, size_t item_size ) {
   return alloc_mem(item_count * item_size);
 }
 
+void *
+realloc_array( const void *mem, size_t item_count, size_t item_size ) {
+  if (item_count && item_count >= (size_t)-1/item_size) {
+    raise_memory_allocation_failure();
+    return NULL;
+  }
+  return realloc_mem(mem, item_count * item_size);
+}
+
 malloc_func_t stumpless_get_malloc(void) {
     return stumpless_malloc ? stumpless_malloc : NULL;
 }
@@ -146,4 +155,4 @@ free_func_t stumpless_get_free(void) {
 
 realloc_func_t stumpless_get_realloc(void) {
     return stumpless_realloc ? stumpless_realloc : NULL;
-}
+}

src/target/journald.c

@@ -191,7 +191,7 @@ void
 init_fields( size_t field_count ) {
   struct iovec *new_fields;
 
-  new_fields = realloc_mem( fields, sizeof( *fields ) * field_count );
+  new_fields = realloc_array( fields, field_count, sizeof( *fields ) );
   if( !new_fields ) {
     return;
   }

test/function/element.cpp

@@ -607,6 +607,23 @@ namespace {
     EXPECT_ERROR_ID_EQ( STUMPLESS_INVALID_ENCODING );
   }
 
+  TEST_F( ElementTest, HighParamCount ) {
+    size_t original_param_count;
+    const struct stumpless_element *result;
+
+    original_param_count = stumpless_get_param_count( basic_element );
+    basic_element->param_count = SIZE_MAX - 1;
+
+    result = stumpless_add_new_param( basic_element, "high-param-count-name", "high-param-count-value" );
+    EXPECT_NULL( result );
+
+    EXPECT_ERROR_ID_EQ( STUMPLESS_MEMORY_ALLOCATION_FAILURE );
+
+    basic_element->param_count = original_param_count;
+    EXPECT_EQ( stumpless_get_param_count( basic_element ),
+               original_param_count );
+  }
+
   TEST_F( ElementTest, SetName ) {
     const char *new_name = "awesome-new-name";
     const struct stumpless_element *result;