Merge remote-tracking branch 'origin/master' into gh-pages

Author: msune

.github/workflows/test_script.sh

@@ -20,6 +20,8 @@ echo "Building out-tree"
 cd build
 ../configure $CONFIG_FLAGS || (cat config.log && /bin/false)
 make check || ((for f in `find test/ -name "*.log"`; do cat $f; done;) && /bin/false)
+echo "Running oom_create_test without valgrind..."
+./test/oom_create_test
 
 echo "Running examples..."
 valgrind --leak-check=full examples/bbitmap

CHANGELOG.md

@@ -9,6 +9,30 @@ Legend:
 - [O] Other
 ```
 
+### v0.6.4 (27th February 2026)
+
+- [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)
+- [B] str: fix `cdada_str_replace*()` to reject empty match and self-replacement issues
+- [B] str: return `NULL` in `cdada_str_create()` when input C string is `NULL`
+- [B] str: align `cdada_str()` invalid-handle behavior with API docs (return `NULL`, not empty string)
+- [B] bbitmap: make `cdada_bbitmap_dump()` set `size_used` in buffered paths too
+- [B] bbitmap: fix corrupted BSD license header in `bbitmap.h`
+- [B] str: fix underflow in `cdada_str_rtraverse()` on empty strings
+- [B] list: fix `cdada_list_first()`/`cdada_list_last()` returning `CDADA_SUCCESS` on invalid input
+- [B] set: fix `cdada_set_find()` returning `true` on internal error
+- [B] str: fix uint32_t overflow in `cdada_str_erase()` bounds check
+- [B] str: fix `cdada_str_find_count()`/`cdada_str_find_all()` not returning `CDADA_E_NOT_FOUND`
+- [B] str: reject empty `substr` in `cdada_str_find_count()`/`cdada_str_find_all()`
+- [B] list/map/queue/set/stack: report `size_used` as bytes written on incomplete `dump()`
+- [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`)
+- [O] tests: add coverage for `cdada_str_replace_all()` empty-match invalid input and self-overlap replacement
+- [O] tests: add `cdada_str_create(NULL)` regression coverage
+- [O] tests: align invalid `cdada_str()` assertion with documented `NULL` return
+- [O] tests: validate `cdada_bbitmap_dump()` updates `size_used` for both incomplete and complete buffered dumps
+
 ### v0.6.3 (28th January 2026)
 
 - [O] tests/CI: fixed compilation with GCC 16 (thanks A. Stieger). Added CI coverage for GCC 15.

VERSION

@@ -1 +1 @@
-v0.6.3
+v0.6.4

include/cdada/bbitmap.h

@@ -2,15 +2,15 @@
 Copyright (c) 2020, Marc Sune Clos
 All rights reserved.
 
-Redibbitmapibution and use in source and binary forms, with or without
+Redistribution and use in source and binary forms, with or without
 modification, are permitted provided that the following conditions are met:
 
-* Redibbitmapibutions of source code must retain the above copyright notice, this
+* Redistributions of source code must retain the above copyright notice, this
   list of conditions and the following disclaimer.
 
-* Redibbitmapibutions in binary form must reproduce the above copyright notice,
+* Redistributions in binary form must reproduce the above copyright notice,
   this list of conditions and the following disclaimer in the documentation
-  and/or other materials provided with the dibbitmapibution.
+  and/or other materials provided with the distribution.
 
 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

src/bbitmap.cc

@@ -112,15 +112,16 @@ int cdada_bbitmap_dump(cdada_bbitmap_t* b, uint32_t size, char* buffer,
 		std::stringstream ss;
 		for(i=0;i<b->n_words; ++i)
 			__cdada_bbitmap_dump_word(i, &b->ptr[i], ss);
+		*size_used = ss.str().length()+1;
 
-		if(!buffer){
-			*size_used = ss.str().length()+1;
+		if(!buffer)
 			return CDADA_SUCCESS;
-		}
 
 		snprintf(buffer, size, "%s", ss.str().c_str());
-		if(ss.str().length()+1 > size)
+		if(*size_used > size){
+			*size_used = size;
 			return CDADA_E_INCOMPLETE;
+		}
 	}catch(bad_alloc& e){
 		return CDADA_E_MEM;
 	}catch(...){

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;
@@ -401,7 +403,7 @@ static int __cdada_list_first_last(const cdada_list_t* list, bool first,
 	__cdada_list_int_t* m = (__cdada_list_int_t*)list;
 
 	if(unlikely(!m || m->magic_num != CDADA_MAGIC || !key))
-		return false;
+		return CDADA_E_INVALID;
 
 	try{
 		int c = m->ops? 0 : m->val_len;
@@ -450,7 +452,7 @@ static int __cdada_list_first_last(const cdada_list_t* list, bool first,
 	}catch(...){}
 
 	CDADA_ASSERT(0);
-	return false;
+	return CDADA_E_UNKNOWN;
 }
 
 int cdada_list_first(const cdada_list_t* list, void* key){
@@ -1104,8 +1106,10 @@ int cdada_list_dump(cdada_list_t* list, uint32_t size, char* buffer,
 			return CDADA_SUCCESS;
 
 		snprintf(buffer, size, "%s", ss.str().c_str());
-		if(ss.str().length()+1 > size)
+		if(*size_used > size){
+			*size_used = size;
 			return CDADA_E_INCOMPLETE;
+		}
 	}catch(bad_alloc& e){
 		return CDADA_E_MEM;
 	}catch(...){

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;
@@ -899,8 +901,10 @@ int cdada_map_dump(cdada_map_t* map, uint32_t size, char* buffer,
 			return CDADA_SUCCESS;
 
 		snprintf(buffer, size, "%s", ss.str().c_str());
-		if(ss.str().length()+1 > size)
+		if(*size_used > size){
+			*size_used = size;
 			return CDADA_E_INCOMPLETE;
+		}
 	}catch(bad_alloc& e){
 		return CDADA_E_MEM;
 	}catch(...){

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;
@@ -555,8 +557,10 @@ int cdada_queue_dump(cdada_queue_t* queue, uint32_t size, char* buffer,
 			return CDADA_SUCCESS;
 
 		snprintf(buffer, size, "%s", ss.str().c_str());
-		if(ss.str().length()+1 > size)
+		if(*size_used > size){
+			*size_used = size;
 			return CDADA_E_INCOMPLETE;
+		}
 	}catch(bad_alloc& e){
 		return CDADA_E_MEM;
 	}catch(...){

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;
@@ -446,7 +448,7 @@ bool cdada_set_find(const cdada_set_t* set, const void* key){
 				return (*m->ops->find)(m, key);
 			default:
 				CDADA_ASSERT(0);
-				return CDADA_E_UNKNOWN;
+				return false;
 		}
 	}catch(...){}
 
@@ -818,8 +820,10 @@ int cdada_set_dump(cdada_set_t* set, uint32_t size, char* buffer,
 			return CDADA_SUCCESS;
 
 		snprintf(buffer, size, "%s", ss.str().c_str());
-		if(ss.str().length()+1 > size)
+		if(*size_used > size){
+			*size_used = size;
 			return CDADA_E_INCOMPLETE;
+		}
 	}catch(bad_alloc& e){
 		return CDADA_E_MEM;
 	}catch(...){

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;
@@ -493,8 +495,10 @@ int cdada_stack_dump(cdada_stack_t* stack, uint32_t size, char* buffer,
 			return CDADA_SUCCESS;
 
 		snprintf(buffer, size, "%s", ss.str().c_str());
-		if(ss.str().length()+1 > size)
+		if(*size_used > size){
+			*size_used = size;
 			return CDADA_E_INCOMPLETE;
+		}
 	}catch(bad_alloc& e){
 		return CDADA_E_MEM;
 	}catch(...){