Helper to reallocate and append to an array.
Signed-off-by: Rusty Russell <rusty@rustcorp.com.au>
return true;
}
+bool tal_expand_(tal_t **ctxp, const void *src, size_t size, size_t count)
+{
+ struct length *l;
+ bool ret = false;
+
+ l = find_property(debug_tal(to_tal_hdr(*ctxp)), LENGTH);
+
+ /* Check for additive overflow */
+ if (l->count + count < count) {
+ call_error("dup size overflow");
+ goto out;
+ }
+
+ /* Don't point src inside thing we're expanding! */
+ assert(src < *ctxp
+ || (char *)src >= (char *)(*ctxp) + (size * l->count));
+
+ /* Note: updates l->count. */
+ if (!tal_resize_(ctxp, size, l->count + count))
+ goto out;
+
+ memcpy((char *)*ctxp + size * (l->count - count),
+ src, count * size);
+ ret = true;
+
+out:
+ if (taken(src))
+ tal_free(src);
+ return ret;
+}
+
void *tal_dup_(const tal_t *ctx, const void *p, size_t size,
size_t n, size_t extra, bool add_count,
const char *label)
void (*free_fn)(void *),
void (*error_fn)(const char *msg));
+/**
+ * tal_expand - expand a tal array with contents.
+ * @a1p: a pointer to the tal array to expand.
+ * @a2: the second array (can be take()).
+ * @num2: the number of elements in the second array.
+ *
+ * Note that *@a1 and @a2 should be the same type. tal_count(@a1) will
+ * be increased by @num2.
+ *
+ * Example:
+ * int *arr1 = tal_arrz(NULL, int, 2);
+ * int arr2[2] = { 1, 3 };
+ *
+ * tal_expand(&arr1, arr2, 2);
+ * assert(tal_count(arr1) == 4);
+ * assert(arr1[2] == 1);
+ * assert(arr1[3] == 3);
+ */
+#define tal_expand(a1p, a2, num2) \
+ tal_expand_((void **)(a1p), (a2), sizeof**(a1p), \
+ (num2) + 0*sizeof(*(a1p) == (a2)))
+
/**
* tal_check - set the allocation or error functions to use
tal_t *tal_steal_(const tal_t *new_parent, const tal_t *t);
bool tal_resize_(tal_t **ctxp, size_t size, size_t count);
+bool tal_expand_(tal_t **ctxp, const void *src, size_t size, size_t count);
bool tal_add_destructor_(const tal_t *ctx, void (*destroy)(void *me));
bool tal_del_destructor_(const tal_t *ctx, void (*destroy)(void *me));
--- /dev/null
+#include <ccan/tal/tal.h>
+#include <ccan/tal/tal.c>
+#include <ccan/tap/tap.h>
+
+int main(void)
+{
+ int *a;
+ const int arr[] = { 1, 2 };
+
+ plan_tests(13);
+
+ a = tal_arrz(NULL, int, 1);
+ ok1(a);
+
+ ok1(tal_expand(&a, arr, 2));
+ ok1(tal_count(a) == 3);
+ ok1(a[0] == 0);
+ ok1(a[1] == 1);
+ ok1(a[2] == 2);
+
+ ok1(tal_expand(&a, take(tal_arrz(NULL, int, 1)), 1));
+ ok1(tal_count(a) == 4);
+ ok1(a[0] == 0);
+ ok1(a[1] == 1);
+ ok1(a[2] == 2);
+ ok1(a[3] == 0);
+ ok1(tal_first(NULL) == a && !tal_next(NULL, a));
+
+ tal_free(a);
+
+ return exit_status();
+}
{
void *p;
int *pi, *origpi;
+ char *cp;
- plan_tests(26);
+ plan_tests(30);
tal_set_backend(NULL, NULL, NULL, my_error);
ok1(error_count == 1);
ok1(!tal_first(NULL));
+ /* Overflow on expand addition. */
+ cp = tal_arr(p, char, 100);
+ ok1(!tal_expand(&cp, NULL, (size_t)-99UL));
+ ok1(error_count == 2);
+ tal_free(cp);
+
+ /* Overflow when multiplied by size */
+ origpi = tal_arr(NULL, int, 100);
+ ok1(!tal_expand(&origpi, NULL, (size_t)-1UL / sizeof(int)));
+ ok1(error_count == 3);
+ tal_free(origpi);
+
return exit_status();
}