remove unused functions

Author: alandekok

src/lib/util/talloc.c

@@ -779,30 +779,6 @@ char *talloc_buffer_append_variadic_buffer(TALLOC_CTX *ctx, char *to, int argc,
 	return out;
 }
 
-/** Compares two talloced uint8_t arrays with memcmp
- *
- * Talloc arrays carry their length as part of the structure, so can be passed to a generic
- * comparison function.
- *
- * @param a	Pointer to first array.
- * @param b	Pointer to second array.
- * @return
- *	- 0 if the arrays match.
- *	- a positive or negative integer otherwise.
- */
-int talloc_memcmp_array(uint8_t const *a, uint8_t const *b)
-{
-	size_t a_len, b_len;
-
-	a_len = talloc_array_length(a);
-	b_len = talloc_array_length(b);
-
-	if (a_len > b_len) return +1;
-	if (a_len < b_len) return -1;
-
-	return memcmp(a, b, a_len);
-}
-
 /** Compares two talloced char arrays with memcmp
  *
  * Talloc arrays carry their length as part of the structure, so can be passed to a generic
@@ -892,38 +868,6 @@ void **talloc_array_null_terminate(void **array)
 	return new;
 }
 
-/** Remove a NULL termination pointer from an array of pointers
- *
- * If the end of the array is not NULL, NULL will be returned (error).
- *
- * @param[in] array to null strip.  Will be invalidated (realloced).
- * @return
- *	- NULL if array is NULL, if terminating element is not NULL, or reallocation fails.
- *	- A realloced version of array without the terminating NULL element.
- */
-void **talloc_array_null_strip(void **array)
-{
-	size_t		len;
-	TALLOC_CTX	*ctx;
-	void		**new;
-	size_t		size;
-
-	if (!array) return NULL;
-
-	len = talloc_array_length(array);
-	ctx = talloc_parent(array);
-	size = talloc_get_size(array) / talloc_array_length(array);
-
-	if ((len - 1) == 0) return NULL;
-
-	if (array[len - 1] != NULL) return NULL;
-
-	new = _talloc_realloc_array(ctx, array, size, len - 1, talloc_get_name(array));
-	if (!new) return NULL;
-
-	return new;
-}
-
 /** Callback to free the autofree ctx on global exit
  *
  */
@@ -988,64 +932,3 @@ TALLOC_CTX *talloc_autofree_context_thread_local(void)
 
 	return af;
 }
-
-
-struct talloc_child_ctx_s {
-	struct talloc_child_ctx_s *next;
-};
-
-static int _child_ctx_free(TALLOC_CHILD_CTX *list)
-{
-	while (list->next != NULL) {
-		TALLOC_CHILD_CTX *entry = list->next;
-		TALLOC_CHILD_CTX *next = entry->next;
-
-		if (talloc_free(entry) < 0) return -1;
-
-		list->next = next;
-	}
-
-	return 0;
-}
-
-/** Allocate and initialize a TALLOC_CHILD_CTX
- *
- *  The TALLOC_CHILD_CTX ensures ordering for allocators and
- *  destructors.  When a TALLOC_CHILD_CTX is created, it is added to
- *  parent, in LIFO order.  In contrast, the basic talloc operations
- *  do not guarantee any kind of order.
- *
- *  When the TALLOC_CHILD_CTX is freed, the children are freed in FILO
- *  order.  That process ensures that the children are freed before
- *  the parent, and that the younger siblings are freed before the
- *  older siblings.
- *
- *  The idea is that if we have an initializer for A, which in turn
- *  initializes B and C.  When the memory is freed, we should do the
- *  operations in the reverse order.
- */
-TALLOC_CHILD_CTX *talloc_child_ctx_init(TALLOC_CTX *ctx)
-{
-	TALLOC_CHILD_CTX *child;
-
-	child = talloc_zero(ctx, TALLOC_CHILD_CTX);
-	if (!child) return NULL;
-
-	talloc_set_destructor(child, _child_ctx_free);
-	return child;
-}
-
-/** Allocate a TALLOC_CHILD_CTX from a parent.
- *
- */
-TALLOC_CHILD_CTX *talloc_child_ctx_alloc(TALLOC_CHILD_CTX *parent)
-{
-	TALLOC_CHILD_CTX *child;
-
-	child = talloc(parent, TALLOC_CHILD_CTX);
-	if (!child) return NULL;
-
-	child->next = parent->next;
-	parent->next = child;
-	return child;
-}

src/lib/util/talloc.h

@@ -234,16 +234,12 @@ char		*talloc_bstr_realloc(TALLOC_CTX *ctx, char *in, size_t inlen);
 
 char		*talloc_buffer_append_variadic_buffer(TALLOC_CTX *ctx, char *to, int argc, ...);
 
-int		talloc_memcmp_array(uint8_t const *a, uint8_t const *b);
-
 int		talloc_memcmp_bstr(char const *a, char const *b);
 
 int		talloc_decrease_ref_count(void const *ptr);
 
 void		**talloc_array_null_terminate(void **array);
 
-void		**talloc_array_null_strip(void **array);
-
 /** Free const'd memory
  *
  * @param[in] ptr	to free.
@@ -258,11 +254,6 @@ static inline int talloc_const_free(void const *ptr)
 TALLOC_CTX		*talloc_autofree_context_global(void);
 TALLOC_CTX		*talloc_autofree_context_thread_local(void);
 
-typedef struct talloc_child_ctx_s TALLOC_CHILD_CTX;
-
-TALLOC_CHILD_CTX	*talloc_child_ctx_init(TALLOC_CTX *ctx);
-TALLOC_CHILD_CTX	*talloc_child_ctx_alloc(TALLOC_CHILD_CTX *parent) CC_HINT(nonnull);
-
 #ifdef __cplusplus
 }
 #endif

src/lib/util/test/talloc_tests.c

@@ -865,40 +865,6 @@ static void test_talloc_bstr_realloc(void)
 	talloc_free(ctx);
 }
 
-/*
- *	talloc_memcmp_array - compare uint8_t arrays
- */
-static void test_talloc_memcmp_array(void)
-{
-	TALLOC_CTX	*ctx;
-	uint8_t		*a, *b;
-	uint8_t		data3[] = {1, 2, 3};
-	uint8_t		data4a[] = {1, 2, 3, 4};
-	uint8_t		data4b[] = {1, 2, 4, 4};
-
-	ctx = talloc_init_const("test");
-
-	TEST_CASE("Equal arrays");
-	a = talloc_typed_memdup(ctx, data3, sizeof(data3));
-	b = talloc_typed_memdup(ctx, data3, sizeof(data3));
-	TEST_CHECK(talloc_memcmp_array(a, b) == 0);
-
-	TEST_CASE("First array longer");
-	talloc_free(a);
-	a = talloc_typed_memdup(ctx, data4a, sizeof(data4a));
-	TEST_CHECK(talloc_memcmp_array(a, b) > 0);
-
-	TEST_CASE("Second array longer");
-	TEST_CHECK(talloc_memcmp_array(b, a) < 0);
-
-	TEST_CASE("Same length, different content");
-	talloc_free(b);
-	b = talloc_typed_memdup(ctx, data4b, sizeof(data4b));
-	TEST_CHECK(talloc_memcmp_array(a, b) < 0);  /* 3 < 4 */
-
-	talloc_free(ctx);
-}
-
 /*
  *	talloc_memcmp_bstr - compare char arrays
  */
@@ -944,7 +910,7 @@ static void test_talloc_typed_memdup(void)
 }
 
 /*
- *	talloc_array_null_terminate / talloc_array_null_strip
+ *	talloc_array_null_terminate
  */
 static void test_talloc_array_null_terminate(void)
 {
@@ -964,17 +930,9 @@ static void test_talloc_array_null_terminate(void)
 	TEST_CHECK(result[3] == NULL);
 	TEST_CHECK(result[0] == (void *)1);
 
-	TEST_CASE("Strip NULL termination");
-	result = talloc_array_null_strip(result);
-	TEST_ASSERT(result != NULL);
-	TEST_CHECK(talloc_array_length(result) == 3);
-
 	TEST_CASE("NULL terminate NULL returns NULL");
 	TEST_CHECK(talloc_array_null_terminate(NULL) == NULL);
 
-	TEST_CASE("NULL strip NULL returns NULL");
-	TEST_CHECK(talloc_array_null_strip(NULL) == NULL);
-
 	talloc_free(ctx);
 }
 
@@ -1056,61 +1014,6 @@ static void test_talloc_hdr_size(void)
 	TEST_CHECK(talloc_hdr_size() == hdr);
 }
 
-/*
- *	talloc_child_ctx - ordered allocation and deallocation
- */
-static int child_free_order[4];
-static int child_free_idx;
-
-static int _track_free_order(int *ptr)
-{
-	int val = *ptr;
-	if (child_free_idx < 4) child_free_order[child_free_idx++] = val;
-	return 0;
-}
-
-static void test_talloc_child_ctx(void)
-{
-	TALLOC_CTX	*ctx;
-	TALLOC_CHILD_CTX *list, *c1, *c2, *c3;
-	int		*v1, *v2, *v3;
-
-	ctx = talloc_init_const("test");
-
-	TEST_CASE("Child ctx init");
-	list = talloc_child_ctx_init(ctx);
-	TEST_ASSERT(list != NULL);
-
-	TEST_CASE("Allocate children in order");
-	c1 = talloc_child_ctx_alloc(list);
-	TEST_ASSERT(c1 != NULL);
-	v1 = talloc(c1, int);
-	*v1 = 1;
-	talloc_set_destructor(v1, _track_free_order);
-
-	c2 = talloc_child_ctx_alloc(list);
-	TEST_ASSERT(c2 != NULL);
-	v2 = talloc(c2, int);
-	*v2 = 2;
-	talloc_set_destructor(v2, _track_free_order);
-
-	c3 = talloc_child_ctx_alloc(list);
-	TEST_ASSERT(c3 != NULL);
-	v3 = talloc(c3, int);
-	*v3 = 3;
-	talloc_set_destructor(v3, _track_free_order);
-
-	TEST_CASE("Children freed in FILO order");
-	child_free_idx = 0;
-	memset(child_free_order, 0, sizeof(child_free_order));
-	talloc_free(ctx);
-
-	/* FILO: c3 (newest) freed first, then c2, then c1 */
-	TEST_CHECK(child_free_order[0] == 3);
-	TEST_CHECK(child_free_order[1] == 2);
-	TEST_CHECK(child_free_order[2] == 1);
-}
-
 /*
  *	talloc_realloc_zero - realloc that zeros new memory
  */
@@ -1230,14 +1133,12 @@ TEST_LIST = {
 	{ "talloc_bstrndup",			test_talloc_bstrndup },
 	{ "talloc_bstr_append",			test_talloc_bstr_append },
 	{ "talloc_bstr_realloc",		test_talloc_bstr_realloc },
-	{ "talloc_memcmp_array",		test_talloc_memcmp_array },
 	{ "talloc_memcmp_bstr",			test_talloc_memcmp_bstr },
 	{ "talloc_typed_memdup",		test_talloc_typed_memdup },
 	{ "talloc_array_null_terminate",	test_talloc_array_null_terminate },
 	{ "talloc_destructor_add",		test_talloc_destructor_add },
 	{ "talloc_link_ctx",			test_talloc_link_ctx },
 	{ "talloc_hdr_size",			test_talloc_hdr_size },
-	{ "talloc_child_ctx",			test_talloc_child_ctx },
 	{ "talloc_realloc_zero",		test_talloc_realloc_zero },
 	{ "talloc_decrease_ref_count",		test_talloc_decrease_ref_count },
 	{ "talloc_aligned_array",		test_talloc_aligned_array },