made data structures immune to call term/destroy twice

tezc · Apr 13, 2021 · 57e67dc · 57e67dc
1 parent 3d11311
commit 57e67dc
Show file tree

Hide file tree

Showing 24 changed files with 223 additions and 124 deletions.
diff --git a/.clang-format b/.clang-format
@@ -2,9 +2,9 @@
 Language:        Cpp
 AccessModifierOffset: -4
 AlignAfterOpenBracket: Align
-AlignConsecutiveAssignments: false
-AlignConsecutiveDeclarations: false
-AlignConsecutiveMacros: true
+AlignConsecutiveAssignments: None
+AlignConsecutiveDeclarations: None
+AlignConsecutiveMacros: None
 AlignEscapedNewlines: Right
 AlignOperands: Align
 AlignTrailingComments: true
@@ -100,7 +100,7 @@ PenaltyReturnTypeOnItsOwnLine: 60
 
 PointerAlignment: Right
 ReflowComments:  true
-SortIncludes:    true
+SortIncludes:    CaseSensitive
 SortUsingDeclarations: true
 SpaceAfterCStyleCast: true
 SpaceAfterTemplateKeyword: true

diff --git a/array/array_test.c b/array/array_test.c
@@ -46,6 +46,11 @@ static void test1(void)
 {
 	int *arr, total = 0;
 
+	sc_array_create(arr, 10);
+	assert(arr != NULL);
+	sc_array_destroy(arr);
+	assert(arr == NULL);
+
 	sc_array_create(arr, 5);
 	sc_array_add(arr, 3);
 	sc_array_add(arr, 4);

diff --git a/buffer/buf_test.c b/buffer/buf_test.c
@@ -9,6 +9,24 @@ void test1()
 	const char *xstr;
 	struct sc_buf buf, buf2;
 
+	sc_buf_init(&buf, 100);
+	assert(buf.mem != NULL);
+	sc_buf_term(&buf);
+
+	sc_buf_init(&buf2, 0);
+	assert(buf.mem == buf2.mem);
+	assert(buf.limit == buf2.limit);
+	assert(buf.wpos == buf2.wpos);
+	assert(buf.rpos == buf2.rpos);
+	assert(buf.ref == buf2.ref);
+	assert(buf.cap == buf2.cap);
+	assert(buf.err == buf2.err);
+	sc_buf_term(&buf2);
+
+	sc_buf_put_64(&buf, 100);
+	assert(sc_buf_get_64(&buf) == 100);
+	sc_buf_term(&buf);
+
 	sc_buf_init(&buf, 100);
 	sc_buf_set_rpos(&buf, 1);
 	assert(sc_buf_valid(&buf) == false);

diff --git a/buffer/sc_buf.c b/buffer/sc_buf.c
@@ -69,6 +69,8 @@ void sc_buf_term(struct sc_buf *b)
 	if (!b->ref) {
 		sc_buf_free(b->mem);
 	}
+
+	sc_buf_init(b, 0);
 }
 
 void sc_buf_limit(struct sc_buf *b, uint32_t limit)

diff --git a/condition/cond_test.c b/condition/cond_test.c
@@ -113,16 +113,17 @@ int sc_thread_start(struct sc_thread *thread, void *(*fn)(void *), void *arg)
 
 int sc_thread_join(struct sc_thread *thread, void **ret)
 {
-	int rc;
-	void *val;
+	int rc = 0;
+	void *val = NULL;
 
 	if (thread->id == 0) {
-		return -1;
+		goto out;
 	}
 
 	rc = pthread_join(thread->id, &val);
 	thread->id = 0;
 
+out:
 	if (ret != NULL) {
 		*ret = val;
 	}

diff --git a/heap/heap_test.c b/heap/heap_test.c
@@ -4,6 +4,7 @@
 #include <stddef.h>
 #include <stdint.h>
 #include <stdio.h>
+#include <string.h>
 
 int example(void)
 {
@@ -54,6 +55,19 @@ void test1(void)
 	void *data;
 	struct sc_heap heap;
 
+	sc_heap_init(&heap, 0);
+	sc_heap_add(&heap, 100, "test");
+	sc_heap_pop(&heap, &key, &data);
+	assert(key == 100);
+	assert(strcmp("test", data) == 0);
+	sc_heap_term(&heap);
+
+	sc_heap_add(&heap, 100, "test");
+	sc_heap_pop(&heap, &key, &data);
+	assert(key == 100);
+	assert(strcmp("test", data) == 0);
+	sc_heap_term(&heap);
+
 	assert(sc_heap_init(&heap, SIZE_MAX / 2) == false);
 	assert(sc_heap_init(&heap, 3) == true);
 
@@ -67,7 +81,7 @@ void test1(void)
 
 	for (int i = 0; i < 10; i++) {
 		assert(sc_heap_add(&heap, arr[i],
-				   (void *) (uintptr_t)(arr[i] * 2)) == true);
+				   (void *) (uintptr_t) (arr[i] * 2)) == true);
 	}
 
 	for (int i = 0; i < 10; i++) {
@@ -97,7 +111,7 @@ void test2(void)
 
 	for (int i = 0; i < 10; i++) {
 		assert(sc_heap_add(&heap, -arr[i],
-				   (void *) (uintptr_t)(arr[i] * 2)) == true);
+				   (void *) (uintptr_t) (arr[i] * 2)) == true);
 	}
 
 	for (int i = 0; i < 10; i++) {

diff --git a/heap/sc_heap.c b/heap/sc_heap.c
@@ -54,6 +54,10 @@ bool sc_heap_init(struct sc_heap *h, size_t cap)
 void sc_heap_term(struct sc_heap *h)
 {
 	sc_heap_free(h->elems);
+
+	*h = (struct sc_heap){
+		.elems = NULL,
+	};
 }
 
 size_t sc_heap_size(struct sc_heap *h)

diff --git a/ini/sc_ini.c b/ini/sc_ini.c
@@ -29,7 +29,6 @@
 #include "sc_ini.h"
 
 #include <ctype.h>
-#include <stdint.h>
 #include <string.h>
 
 #if defined(_WIN32) || defined(_WIN64)

diff --git a/logger/sc_log.c b/logger/sc_log.c
@@ -186,9 +186,12 @@ int sc_log_term(void)
 		if (rc != 0) {
 			rc = -1;
 		}
+		sc_log_mutex_term(&sc_log.mtx);
 	}
 
-	sc_log_mutex_term(&sc_log.mtx);
+	sc_log = (struct sc_log){
+		.fp = NULL,
+	};
 
 	return rc;
 }

diff --git a/map/map_test.c b/map/map_test.c
@@ -518,6 +518,17 @@ void test1()
 		values[i] = str_random((rand() % 64) + 32);
 	}
 
+	sc_map_init_str(&map, 0, 0);
+	sc_map_put_str(&map, "100", "200");
+	sc_map_get_str(&map, "100", &value);
+	assert(strcmp(value, "200") == 0);
+	sc_map_term_str(&map);
+	sc_map_put_str(&map, "100", "200");
+	sc_map_get_str(&map, "100", &value);
+	assert(strcmp(value, "200") == 0);
+	sc_map_term_str(&map);
+
+
 	assert(!sc_map_init_str(&map, 0, -1));
 	assert(!sc_map_init_str(&map, 0, 24));
 	assert(!sc_map_init_str(&map, 0, 96));

diff --git a/map/sc_map.c b/map/sc_map.c
@@ -131,7 +131,7 @@
 		m->used = false;                                               \
 		m->cap = cap;                                                  \
 		m->load_fac = f;                                               \
-		m->remap = (uint32_t)(m->cap * ((double) m->load_fac / 100));  \
+		m->remap = (uint32_t) (m->cap * ((double) m->load_fac / 100)); \
                                                                                \
 		return true;                                                   \
 	}                                                                      \
@@ -140,6 +140,7 @@
 	{                                                                      \
 		if (m->mem != sc_map_empty_##name.mem) {                       \
 			sc_map_free(&m->mem[-1]);                              \
+			*m = sc_map_empty_##name;                              \
 		}                                                              \
 	}                                                                      \
                                                                                \
@@ -199,7 +200,7 @@
                                                                                \
 		m->mem = new;                                                  \
 		m->cap = cap;                                                  \
-		m->remap = (uint32_t)(m->cap * ((double) m->load_fac / 100));  \
+		m->remap = (uint32_t) (m->cap * ((double) m->load_fac / 100)); \
                                                                                \
 		return true;                                                   \
 	}                                                                      \
@@ -330,7 +331,7 @@ static uint32_t sc_map_hash_32(uint32_t a)
 
 static uint32_t sc_map_hash_64(uint64_t a)
 {
-	return ((uint32_t) a) ^ (uint32_t)(a >> 32u);
+	return ((uint32_t) a) ^ (uint32_t) (a >> 32u);
 }
 
 // clang-format off

diff --git a/memory-map/mmap_test.c b/memory-map/mmap_test.c
@@ -21,6 +21,8 @@ void test1()
 	assert(rc == 0);
 	rc = sc_mmap_term(&mmap);
 	assert(rc == 0);
+	rc = sc_mmap_term(&mmap);
+	assert(rc == 0);
 
 	rc = sc_mmap_init(&mmap, "x.txt", O_RDWR | O_CREAT | O_TRUNC,
 			  PROT_READ | PROT_WRITE, MAP_SHARED, 0, 8192);

diff --git a/memory-map/sc_mmap.c b/memory-map/sc_mmap.c
@@ -261,13 +261,23 @@ int sc_mmap_term(struct sc_mmap *m)
 {
 	int rc;
 
+	if (m->fd == -1) {
+		return 0;
+	}
+
 	close(m->fd);
 
 	rc = munmap(m->ptr, m->len);
 	if (rc != 0) {
 		strncpy(m->err, strerror(errno), sizeof(m->err) - 1);
 	}
 
+	*m = (struct sc_mmap) {
+		.ptr = NULL,
+		.fd = -1,
+		.len = 0,
+	};
+
 	return rc;
 }
 

diff --git a/string/sc_str.c b/string/sc_str.c
@@ -135,13 +135,14 @@ char *sc_str_create_fmt(const char *fmt, ...)
 	return str;
 }
 
-void sc_str_destroy(char *str)
+void sc_str_destroy(char **str)
 {
-	if (str == NULL) {
+	if (str == NULL || *str == NULL) {
 		return;
 	}
 
-	sc_str_free(sc_str_meta(str));
+	sc_str_free(sc_str_meta(*str));
+	*str = NULL;
 }
 
 int64_t sc_str_len(const char *str)
@@ -174,7 +175,7 @@ bool sc_str_set(char **str, const char *param)
 		return false;
 	}
 
-	sc_str_destroy(*str);
+	sc_str_destroy(str);
 	*str = c;
 
 	return true;
@@ -190,7 +191,7 @@ bool sc_str_set_fmt(char **str, const char *fmt, ...)
 	va_end(args);
 
 	if (ret != NULL) {
-		sc_str_destroy(*str);
+		sc_str_destroy(str);
 		*str = ret;
 	}
 
@@ -310,7 +311,7 @@ bool sc_str_trim(char **str, const char *list)
 			return false;
 		}
 
-		sc_str_destroy(*str);
+		sc_str_destroy(str);
 		*str = head;
 	}
 
@@ -336,7 +337,7 @@ bool sc_str_substring(char **str, uint32_t start, uint32_t end)
 		return false;
 	}
 
-	sc_str_destroy(*str);
+	sc_str_destroy(str);
 	*str = c;
 
 	return true;
@@ -416,7 +417,7 @@ bool sc_str_replace(char **str, const char *replace, const char *with)
 
 	memcpy(tmp, orig, orig_end - orig + 1);
 
-	sc_str_destroy(*str);
+	sc_str_destroy(str);
 	*str = dest->buf;
 
 	return true;

diff --git a/string/sc_str.h b/string/sc_str.h
@@ -82,7 +82,7 @@ char *sc_str_create_va(const char *fmt, va_list va);
  * Deallocate length prefixed string.
  * @param str length prefixed string. str may be NULL.
  */
-void sc_str_destroy(char *str);
+void sc_str_destroy(char **str);
 
 /**
  * @param str length prefixed string. NULL values are accepted.