all: handle properly OOM on *_create()

Fix dereferencing of malloc() on OOM conditions (NULL dereferrencing)

Added OOM test and CHANGELOG entries.

Reported-by: CodexGPT-5.3 <noreply@openai.com>

Author: msune

CHANGELOG.md

@@ -13,7 +13,9 @@ Legend:
 
 - [B] utils: fix `cdada_strerr()` bounds handling for invalid and negative error codes
 - [B] utils: add missing human-readable message for `CDADA_E_FULL`
+- [B] list/map/queue/set/stack: return `NULL` when constructor `malloc()` fails (avoid null dereference)
 - [O] tests: add coverage for `cdada_strerr()` valid, boundary and high invalid values
+- [O] tests: add `oom_create_test` coverage for create paths (`list`, `map`, `queue`, `set`, `stack`, `str`, `bbitmap`)
 
 ### v0.6.3 (28th January 2026)
 

src/list.cc

@@ -16,6 +16,8 @@ cdada_list_t* __cdada_list_create(const uint16_t val_size,
 		return m;
 
 	m = (__cdada_list_int_t*)malloc(sizeof(__cdada_list_int_t));
+	if(!m)
+		return NULL;
 	memset(m, 0, sizeof(__cdada_list_int_t));
 	m->magic_num = CDADA_MAGIC;
 	m->user_val_len = val_size;

src/map.cc

@@ -16,6 +16,8 @@ cdada_map_t* __cdada_map_create(const uint16_t key_size,
 		return m;
 
 	m = (__cdada_map_int_t*)malloc(sizeof(__cdada_map_int_t));
+	if(!m)
+		return NULL;
 	memset(m, 0, sizeof(__cdada_map_int_t));
 	m->magic_num = CDADA_MAGIC;
 	m->user_key_len = key_size;

src/queue.cc

@@ -16,6 +16,8 @@ cdada_queue_t* __cdada_queue_create(const uint16_t val_size,
 		return m;
 
 	m = (__cdada_queue_int_t*)malloc(sizeof(__cdada_queue_int_t));
+	if(!m)
+		return NULL;
 	memset(m, 0, sizeof(__cdada_queue_int_t));
 	m->magic_num = CDADA_MAGIC;
 	m->user_val_len = val_size;

src/set.cc

@@ -16,6 +16,8 @@ cdada_set_t* __cdada_set_create(const uint16_t key_size,
 		return m;
 
 	m = (__cdada_set_int_t*)malloc(sizeof(__cdada_set_int_t));
+	if(!m)
+		return NULL;
 	memset(m, 0, sizeof(__cdada_set_int_t));
 	m->magic_num = CDADA_MAGIC;
 	m->user_key_len = key_size;

src/stack.cc

@@ -16,6 +16,8 @@ cdada_stack_t* __cdada_stack_create(const uint16_t val_size,
 		return m;
 
 	m = (__cdada_stack_int_t*)malloc(sizeof(__cdada_stack_int_t));
+	if(!m)
+		return NULL;
 	memset(m, 0, sizeof(__cdada_stack_int_t));
 	m->magic_num = CDADA_MAGIC;
 	m->user_val_len = val_size;

test/Makefile.am

@@ -8,6 +8,7 @@ check_PROGRAMS= bbitmap_test       \
                 cdada_include_test \
                 list_test          \
                 map_test           \
+                oom_create_test    \
                 queue_test         \
                 set_test           \
                 stack_test         \
@@ -18,6 +19,7 @@ TESTS = bbitmap_test       \
         cdada_include_test \
         list_test          \
         map_test           \
+        oom_create_test    \
         queue_test         \
         set_test           \
         stack_test         \
@@ -40,6 +42,10 @@ map_test_SOURCES= map_test.c map_custom.cc
 map_test_CPPFLAGS= -I$(top_builddir)/include/ -I$(top_srcdir)/include/
 map_test_LDADD= -lpthread ../src/libcdada.la
 
+oom_create_test_SOURCES= oom_create_test.c
+oom_create_test_CPPFLAGS= -I$(top_builddir)/include/ -I$(top_srcdir)/include/
+oom_create_test_LDADD= -lpthread ../src/libcdada.la
+
 queue_test_SOURCES= queue_test.c queue_custom.cc
 queue_test_CPPFLAGS= -I$(top_builddir)/include/ -I$(top_srcdir)/include/
 queue_test_LDADD= -lpthread ../src/libcdada.la

test/oom_create_test.c

@@ -0,0 +1,103 @@
+#include <stdint.h>
+#include <stdlib.h>
+
+#include "cdada/bbitmap.h"
+#include "cdada/list.h"
+#include "cdada/map.h"
+#include "cdada/queue.h"
+#include "cdada/set.h"
+#include "cdada/stack.h"
+#include "cdada/str.h"
+#include "common.h"
+
+static int g_fail_next_malloc = 0;
+
+#ifdef __GLIBC__
+extern void* __libc_malloc(size_t size);
+
+void* malloc(size_t size){
+	if(g_fail_next_malloc){
+		g_fail_next_malloc = 0;
+		return NULL;
+	}
+	return __libc_malloc(size);
+}
+#endif
+
+int main(int argc, char** argv){
+	cdada_list_t* list;
+	cdada_map_t* map;
+	cdada_queue_t* queue;
+	cdada_set_t* set;
+	cdada_stack_t* stack;
+	cdada_str_t* str;
+	cdada_bbitmap_t* bbitmap;
+
+	(void)argc;
+	(void)argv;
+
+	g_fail_next_malloc = 0;
+	list = cdada_list_create(uint32_t);
+	TEST_ASSERT(list != NULL);
+	TEST_ASSERT(cdada_list_destroy(list) == CDADA_SUCCESS);
+
+	g_fail_next_malloc = 1;
+	list = cdada_list_create(uint32_t);
+	TEST_ASSERT(list == NULL);
+
+	g_fail_next_malloc = 0;
+	map = cdada_map_create(uint32_t);
+	TEST_ASSERT(map != NULL);
+	TEST_ASSERT(cdada_map_destroy(map) == CDADA_SUCCESS);
+
+	g_fail_next_malloc = 1;
+	map = cdada_map_create(uint32_t);
+	TEST_ASSERT(map == NULL);
+
+	g_fail_next_malloc = 0;
+	queue = cdada_queue_create(uint32_t);
+	TEST_ASSERT(queue != NULL);
+	TEST_ASSERT(cdada_queue_destroy(queue) == CDADA_SUCCESS);
+
+	g_fail_next_malloc = 1;
+	queue = cdada_queue_create(uint32_t);
+	TEST_ASSERT(queue == NULL);
+
+	g_fail_next_malloc = 0;
+	set = cdada_set_create(uint32_t);
+	TEST_ASSERT(set != NULL);
+	TEST_ASSERT(cdada_set_destroy(set) == CDADA_SUCCESS);
+
+	g_fail_next_malloc = 1;
+	set = cdada_set_create(uint32_t);
+	TEST_ASSERT(set == NULL);
+
+	g_fail_next_malloc = 0;
+	stack = cdada_stack_create(uint32_t);
+	TEST_ASSERT(stack != NULL);
+	TEST_ASSERT(cdada_stack_destroy(stack) == CDADA_SUCCESS);
+
+	g_fail_next_malloc = 1;
+	stack = cdada_stack_create(uint32_t);
+	TEST_ASSERT(stack == NULL);
+
+	g_fail_next_malloc = 0;
+	str = cdada_str_create("oom");
+	TEST_ASSERT(str != NULL);
+	TEST_ASSERT(cdada_str_destroy(str) == CDADA_SUCCESS);
+
+	g_fail_next_malloc = 1;
+	str = cdada_str_create("oom");
+	TEST_ASSERT(str == NULL);
+
+	g_fail_next_malloc = 0;
+	bbitmap = cdada_bbitmap_create(64);
+	TEST_ASSERT(bbitmap != NULL);
+	TEST_ASSERT(cdada_bbitmap_destroy(bbitmap) == CDADA_SUCCESS);
+
+	g_fail_next_malloc = 1;
+	bbitmap = cdada_bbitmap_create(64);
+	TEST_ASSERT(bbitmap == NULL);
+
+	return EXIT_SUCCESS;
+}