X-Git-Url: http://git.ozlabs.org/?p=ccan;a=blobdiff_plain;f=ccan%2Ftal%2Ftal.c;h=331f7ea5ca5bca91fd7249bbdc0ca8f83300b73d;hp=9b84c6e17bdf9b94856157d54bbab4f648981406;hb=ed6dd33e06c0e8f1c4dd006e0b70d9f2d6ba6c09;hpb=d73a2bcb320a016aa74262991cfd7685dc132056

diff --git a/ccan/tal/tal.c b/ccan/tal/tal.c
index 9b84c6e1..331f7ea5 100644
--- a/ccan/tal/tal.c
+++ b/ccan/tal/tal.c
@@ -2,10 +2,9 @@
 #include <ccan/tal/tal.h>
 #include <ccan/compiler/compiler.h>
 #include <ccan/list/list.h>
-#include <ccan/take/take.h>
+#include <ccan/alignof/alignof.h>
 #include <assert.h>
 #include <stdio.h>
-#include <stdarg.h>
 #include <stddef.h>
 #include <string.h>
 #include <limits.h>
@@ -13,12 +12,15 @@
 
 //#define TAL_DEBUG 1
 
+#define NOTIFY_IS_DESTRUCTOR 512
+#define NOTIFY_EXTRA_ARG 1024
+
 /* 32-bit type field, first byte 0 in either endianness. */
 enum prop_type {
 	CHILDREN = 0x00c1d500,
-	DESTRUCTOR = 0x00de5700,
 	NAME = 0x00111100,
-	NOTIFIER = 0x00071f00
+	NOTIFIER = 0x00071f00,
+	LENGTH = 0x00515300
 };
 
 struct tal_hdr {
@@ -38,22 +40,34 @@ struct children {
 	struct list_head children; /* Head of siblings. */
 };
 
-struct destructor {
-	struct prop_hdr hdr; /* DESTRUCTOR */
-	void (*destroy)(void *me);
-};
-
 struct name {
 	struct prop_hdr hdr; /* NAME */
 	char name[];
 };
 
+struct length {
+	struct prop_hdr hdr; /* LENGTH */
+	size_t len;
+};
+
 struct notifier {
 	struct prop_hdr hdr; /* NOTIFIER */
 	enum tal_notify_type types;
-	void (*notifyfn)(tal_t *, enum tal_notify_type, void *);
+	union {
+		void (*notifyfn)(tal_t *, enum tal_notify_type, void *);
+		void (*destroy)(tal_t *); /* If NOTIFY_IS_DESTRUCTOR set */
+		void (*destroy2)(tal_t *, void *); /* If NOTIFY_EXTRA_ARG */
+	} u;
+};
+
+/* Extra arg */
+struct notifier_extra_arg {
+	struct notifier n;
+	void *arg;
 };
 
+#define EXTRA_ARG(n) (((struct notifier_extra_arg *)(n))->arg)
+
 static struct {
 	struct tal_hdr hdr;
 	struct children c;
@@ -71,6 +85,8 @@ static void *(*allocfn)(size_t size) = malloc;
 static void *(*resizefn)(void *, size_t size) = realloc;
 static void (*freefn)(void *) = free;
 static void (*errorfn)(const char *msg) = (void *)abort;
+/* Count on non-destrutor notifiers; often stays zero. */
+static size_t notifiers = 0;
 
 static inline void COLD call_error(const char *msg)
 {
@@ -92,26 +108,20 @@ static struct children *ignore_destroying_bit(struct children *parent_child)
 	return (void *)((size_t)parent_child & ~(size_t)1);
 }
 
-static bool initialized = false;
-
 /* This means valgrind can see leaks. */
-static void tal_cleanup(void)
+void tal_cleanup(void)
 {
 	struct tal_hdr *i;
 
-	while ((i = list_top(&null_parent.c.children, struct tal_hdr, list)))
+	while ((i = list_top(&null_parent.c.children, struct tal_hdr, list))) {
 		list_del(&i->list);
+		memset(i, 0, sizeof(*i));
+	}
 
 	/* Cleanup any taken pointers. */
 	take_cleanup();
 }
 
-/* For allocation failures inside ccan/take */
-static void take_alloc_failed(const void *p)
-{
-	tal_free(p);
-}
-
 /* We carefully start all real properties with a zero byte. */
 static bool is_literal(const struct prop_hdr *prop)
 {
@@ -202,7 +212,8 @@ static struct tal_hdr *debug_tal(struct tal_hdr *tal)
 #endif
 
 static void notify(const struct tal_hdr *ctx,
-		   enum tal_notify_type type, const void *info)
+		   enum tal_notify_type type, const void *info,
+		   int saved_errno)
 {
         const struct prop_hdr *p;
 
@@ -214,22 +225,24 @@ static void notify(const struct tal_hdr *ctx,
                 if (p->type != NOTIFIER)
 			continue;
 		n = (struct notifier *)p;
-		if (n->types & type)
-			n->notifyfn(from_tal_hdr(ctx), type, (void *)info);
+		if (n->types & type) {
+			errno = saved_errno;
+			if (n->types & NOTIFY_IS_DESTRUCTOR) {
+				if (n->types & NOTIFY_EXTRA_ARG)
+					n->u.destroy2(from_tal_hdr(ctx),
+						      EXTRA_ARG(n));
+				else
+					n->u.destroy(from_tal_hdr(ctx));
+			} else
+				n->u.notifyfn(from_tal_hdr(ctx), type,
+					      (void *)info);
+		}
 	}
 }
 
 static void *allocate(size_t size)
 {
-	void *ret;
-
-	/* Don't hand silly sizes to malloc. */
-	if (size >> (CHAR_BIT*sizeof(size) - 1)) {
-		call_error("allocation size overflow");
-		return NULL;
-	}
-
-	ret = allocfn(size);
+	void *ret = allocfn(size);
 	if (!ret)
 		call_error("allocation failed");
 	else
@@ -272,75 +285,62 @@ static void init_property(struct prop_hdr *hdr,
 	parent->prop = hdr;
 }
 
-static struct destructor *add_destructor_property(struct tal_hdr *t,
-						  void (*destroy)(void *))
-{
-	struct destructor *prop = allocate(sizeof(*prop));
-	if (prop) {
-		init_property(&prop->hdr, t, DESTRUCTOR);
-		prop->destroy = destroy;
-	}
-	return prop;
-}
-
-static bool del_destructor_property(struct tal_hdr *t,
-				    void (*destroy)(void *))
-{
-        struct prop_hdr **p;
-
-        for (p = (struct prop_hdr **)&t->prop; *p; p = &(*p)->next) {
-		struct destructor *d;
-
-                if (is_literal(*p))
-			break;
-                if ((*p)->type != DESTRUCTOR)
-			continue;
-		d = (struct destructor *)*p;
-		if (d->destroy == destroy) {
-			*p = (*p)->next;
-			freefn(d);
-			return true;
-		}
-        }
-        return false;
-}
-
 static struct notifier *add_notifier_property(struct tal_hdr *t,
 					      enum tal_notify_type types,
 					      void (*fn)(void *,
 							 enum tal_notify_type,
-							 void *))
+							 void *),
+					      void *extra_arg)
 {
-	struct notifier *prop = allocate(sizeof(*prop));
+	struct notifier *prop;
+
+	if (types & NOTIFY_EXTRA_ARG)
+		prop = allocate(sizeof(struct notifier_extra_arg));
+	else
+		prop = allocate(sizeof(struct notifier));
+
 	if (prop) {
 		init_property(&prop->hdr, t, NOTIFIER);
 		prop->types = types;
-		prop->notifyfn = fn;
+		prop->u.notifyfn = fn;
+		if (types & NOTIFY_EXTRA_ARG)
+			EXTRA_ARG(prop) = extra_arg;
 	}
 	return prop;
 }
 
-static bool del_notifier_property(struct tal_hdr *t,
-				  void (*fn)(tal_t *,
-					     enum tal_notify_type, void *))
+static enum tal_notify_type del_notifier_property(struct tal_hdr *t,
+						  void (*fn)(tal_t *,
+							     enum tal_notify_type,
+							     void *),
+						  bool match_extra_arg,
+						  void *extra_arg)
 {
         struct prop_hdr **p;
 
         for (p = (struct prop_hdr **)&t->prop; *p; p = &(*p)->next) {
 		struct notifier *n;
+		enum tal_notify_type types;
 
                 if (is_literal(*p))
 			break;
                 if ((*p)->type != NOTIFIER)
 			continue;
 		n = (struct notifier *)*p;
-		if (n->notifyfn == fn) {
-			*p = (*p)->next;
-			freefn(n);
-			return true;
-		}
+		if (n->u.notifyfn != fn)
+			continue;
+
+		types = n->types;
+		if ((types & NOTIFY_EXTRA_ARG)
+		    && match_extra_arg
+		    && extra_arg != EXTRA_ARG(n))
+			continue;
+
+		*p = (*p)->next;
+		freefn(n);
+		return types & ~(NOTIFY_IS_DESTRUCTOR|NOTIFY_EXTRA_ARG);
         }
-        return false;
+        return 0;
 }
 
 static struct name *add_name_property(struct tal_hdr *t, const char *name)
@@ -356,7 +356,7 @@ static struct name *add_name_property(struct tal_hdr *t, const char *name)
 }
 
 static struct children *add_child_property(struct tal_hdr *parent,
-					   struct tal_hdr *child)
+					   struct tal_hdr *child UNNEEDED)
 {
 	struct children *prop = allocate(sizeof(*prop));
 	if (prop) {
@@ -372,11 +372,6 @@ static bool add_child(struct tal_hdr *parent, struct tal_hdr *child)
 	struct children *children = find_property(parent, CHILDREN);
 
         if (!children) {
-		if (unlikely(!initialized)) {
-			atexit(tal_cleanup);
-			take_allocfail(take_alloc_failed);
-			initialized = true;
-		}
 		children = add_child_property(parent, child);
 		if (!children)
 			return false;
@@ -386,7 +381,7 @@ static bool add_child(struct tal_hdr *parent, struct tal_hdr *child)
 	return true;
 }
 
-static void del_tree(struct tal_hdr *t, const tal_t *orig)
+static void del_tree(struct tal_hdr *t, const tal_t *orig, int saved_errno)
 {
 	struct prop_hdr **prop, *p, *next;
 
@@ -396,16 +391,8 @@ static void del_tree(struct tal_hdr *t, const tal_t *orig)
 
         set_destroying_bit(&t->parent_child);
 
-        /* Carefully call destructors, removing as we go. */
-        while ((prop = find_property_ptr(t, DESTRUCTOR))) {
-		struct destructor *d = (struct destructor *)*prop;
-                d->destroy(from_tal_hdr(t));
-                *prop = d->hdr.next;
-		freefn(d);
-        }
-
 	/* Call free notifiers. */
-	notify(t, TAL_NOTIFY_FREE, (tal_t *)orig);
+	notify(t, TAL_NOTIFY_FREE, (tal_t *)orig, saved_errno);
 
 	/* Now free children and groups. */
 	prop = find_property_ptr(t, CHILDREN);
@@ -415,47 +402,106 @@ static void del_tree(struct tal_hdr *t, const tal_t *orig)
 
 		while ((i = list_top(&c->children, struct tal_hdr, list))) {
 			list_del(&i->list);
-			del_tree(i, orig);
+			del_tree(i, orig, saved_errno);
 		}
 	}
 
         /* Finally free our properties. */
         for (p = t->prop; p && !is_literal(p); p = next) {
                 next = p->next;
-		freefn(p);
+		/* LENGTH is appended, so don't free separately! */
+		if (p->type != LENGTH)
+			freefn(p);
         }
         freefn(t);
 }
 
-void *tal_alloc_(const tal_t *ctx, size_t size, bool clear, const char *label)
+static size_t extra_for_length(size_t size)
 {
+	size_t extra;
+	const size_t align = ALIGNOF(struct length);
+
+	/* Round up size, and add tailer. */
+	extra = ((size + align-1) & ~(align-1)) - size;
+	extra += sizeof(struct length);
+	return extra;
+}
+
+void *tal_alloc_(const tal_t *ctx, size_t size,
+		 bool clear, bool add_length, const char *label)
+{
+	size_t req_size = size;
         struct tal_hdr *child, *parent = debug_tal(to_tal_hdr_or_null(ctx));
 
+#ifdef CCAN_TAL_DEBUG
+	/* Always record length if debugging. */
+	add_length = true;
+#endif
+	if (add_length)
+		size += extra_for_length(size);
+
         child = allocate(sizeof(struct tal_hdr) + size);
 	if (!child)
 		return NULL;
 	if (clear)
-		memset(from_tal_hdr(child), 0, size);
+		memset(from_tal_hdr(child), 0, req_size);
         child->prop = (void *)label;
+
+	if (add_length) {
+		struct length *lprop;
+		lprop = (struct length *)((char *)(child+1) + size) - 1;
+		init_property(&lprop->hdr, child, LENGTH);
+		lprop->len = req_size;
+	}
         if (!add_child(parent, child)) {
 		freefn(child);
 		return NULL;
 	}
 	debug_tal(parent);
-	notify(parent, TAL_NOTIFY_ADD_CHILD, from_tal_hdr(debug_tal(child)));
+	if (notifiers)
+		notify(parent, TAL_NOTIFY_ADD_CHILD, from_tal_hdr(child), 0);
 	return from_tal_hdr(debug_tal(child));
 }
 
+static bool adjust_size(size_t *size, size_t count)
+{
+	const size_t extra = sizeof(struct tal_hdr) + sizeof(struct length)*2;
+
+	/* Multiplication wrap */
+        if (count && unlikely(*size * count / *size != count))
+		goto overflow;
+
+        *size *= count;
+
+        /* Make sure we don't wrap adding header/tailer. */
+        if (*size + extra < extra)
+		goto overflow;
+	return true;
+overflow:
+	call_error("allocation size overflow");
+	return false;
+}
+
+void *tal_alloc_arr_(const tal_t *ctx, size_t size, size_t count, bool clear,
+		     bool add_length, const char *label)
+{
+	if (!adjust_size(&size, count))
+		return NULL;
+
+	return tal_alloc_(ctx, size, clear, add_length, label);
+}
+
 void *tal_free(const tal_t *ctx)
 {
         if (ctx) {
 		struct tal_hdr *t;
 		int saved_errno = errno;
 		t = debug_tal(to_tal_hdr(ctx));
-		notify(ignore_destroying_bit(t->parent_child)->parent,
-		       TAL_NOTIFY_DEL_CHILD, ctx);
+		if (notifiers)
+			notify(ignore_destroying_bit(t->parent_child)->parent,
+			       TAL_NOTIFY_DEL_CHILD, ctx, saved_errno);
 		list_del(&t->list);
-		del_tree(t, ctx);
+		del_tree(t, ctx, saved_errno);
 		errno = saved_errno;
 	}
 	return NULL;
@@ -481,18 +527,30 @@ void *tal_steal_(const tal_t *new_parent, const tal_t *ctx)
 			return NULL;
 		}
 		debug_tal(newpar);
-		notify(t, TAL_NOTIFY_STEAL, new_parent);
+		if (notifiers)
+			notify(t, TAL_NOTIFY_STEAL, new_parent, 0);
         }
         return (void *)ctx;
 }
 
-bool tal_add_destructor_(tal_t *ctx, void (*destroy)(void *me))
+bool tal_add_destructor_(const tal_t *ctx, void (*destroy)(void *me))
 {
 	tal_t *t = debug_tal(to_tal_hdr(ctx));
-        return add_destructor_property(t, destroy);
+	return add_notifier_property(t, TAL_NOTIFY_FREE|NOTIFY_IS_DESTRUCTOR,
+				     (void *)destroy, NULL);
 }
 
-bool tal_add_notifier_(tal_t *ctx, enum tal_notify_type types,
+bool tal_add_destructor2_(const tal_t *ctx, void (*destroy)(void *me, void *arg),
+			  void *arg)
+{
+	tal_t *t = debug_tal(to_tal_hdr(ctx));
+	return add_notifier_property(t, TAL_NOTIFY_FREE|NOTIFY_IS_DESTRUCTOR
+				     |NOTIFY_EXTRA_ARG,
+				     (void *)destroy, arg);
+}
+
+/* We could support notifiers with an extra arg, but we didn't add to API */
+bool tal_add_notifier_(const tal_t *ctx, enum tal_notify_type types,
 		       void (*callback)(tal_t *, enum tal_notify_type, void *))
 {
 	tal_t *t = debug_tal(to_tal_hdr(ctx));
@@ -506,31 +564,45 @@ bool tal_add_notifier_(tal_t *ctx, enum tal_notify_type types,
 			  | TAL_NOTIFY_DEL_NOTIFIER)) == 0);
 
 	/* Don't call notifier about itself: set types after! */
-        n = add_notifier_property(t, 0, callback);
+        n = add_notifier_property(t, 0, callback, NULL);
 	if (unlikely(!n))
 		return false;
 
-	notify(t, TAL_NOTIFY_ADD_NOTIFIER, callback);
+	if (notifiers)
+		notify(t, TAL_NOTIFY_ADD_NOTIFIER, callback, 0);
+
 	n->types = types;
+	if (types != TAL_NOTIFY_FREE)
+		notifiers++;
 	return true;
 }
 
-bool tal_del_notifier_(tal_t *ctx,
-		       void (*callback)(tal_t *, enum tal_notify_type, void *))
+bool tal_del_notifier_(const tal_t *ctx,
+		       void (*callback)(tal_t *, enum tal_notify_type, void *),
+		       bool match_extra_arg, void *extra_arg)
 {
 	struct tal_hdr *t = debug_tal(to_tal_hdr(ctx));
-	bool ret;
+	enum tal_notify_type types;
 
-        ret = del_notifier_property(t, callback);
-	if (ret)
-		notify(t, TAL_NOTIFY_DEL_NOTIFIER, callback);
-	return ret;
+        types = del_notifier_property(t, callback, match_extra_arg, extra_arg);
+	if (types) {
+		notify(t, TAL_NOTIFY_DEL_NOTIFIER, callback, 0);
+		if (types != TAL_NOTIFY_FREE)
+			notifiers--;
+		return true;
+	}
+	return false;
 }
 
-bool tal_del_destructor_(tal_t *ctx, void (*destroy)(void *me))
+bool tal_del_destructor_(const tal_t *ctx, void (*destroy)(void *me))
 {
-	struct tal_hdr *t = debug_tal(to_tal_hdr(ctx));
-        return del_destructor_property(t, destroy);
+	return tal_del_notifier_(ctx, (void *)destroy, false, NULL);
+}
+
+bool tal_del_destructor2_(const tal_t *ctx, void (*destroy)(void *me, void *arg),
+			  void *arg)
+{
+	return tal_del_notifier_(ctx, (void *)destroy, true, arg);
 }
 
 bool tal_set_name_(tal_t *ctx, const char *name, bool literal)
@@ -559,7 +631,8 @@ bool tal_set_name_(tal_t *ctx, const char *name, bool literal)
 		return false;
 
 	debug_tal(t);
-	notify(t, TAL_NOTIFY_RENAME, name);
+	if (notifiers)
+		notify(t, TAL_NOTIFY_RENAME, name, 0);
 	return true;
 }
 
@@ -576,6 +649,19 @@ const char *tal_name(const tal_t *t)
 	return n->name;
 }
 
+size_t tal_len(const tal_t *ptr)
+{
+	struct length *l;
+
+	if (!ptr)
+		return 0;
+
+	l = find_property(debug_tal(to_tal_hdr(ptr)), LENGTH);
+	if (!l)
+		return 0;
+	return l->len;
+}
+
 /* Start one past first child: make stopping natural in circ. list. */
 static struct tal_hdr *first_child(struct tal_hdr *parent)
 {
@@ -598,31 +684,16 @@ tal_t *tal_first(const tal_t *root)
 	return from_tal_hdr(c);
 }
 
-tal_t *tal_next(const tal_t *root, const tal_t *prev)
+tal_t *tal_next(const tal_t *prev)
 {
-        struct tal_hdr *c, *t = debug_tal(to_tal_hdr(prev)), *top;
+        struct tal_hdr *next, *prevhdr = debug_tal(to_tal_hdr(prev));
+	struct list_head *head;
 
-        /* Children? */
-	c = first_child(t);
-	if (c)
-		return from_tal_hdr(c);
-
-        top = to_tal_hdr_or_null(root);
-        do {
-		struct tal_hdr *next;
-		struct list_node *end;
-
-		end = &ignore_destroying_bit(t->parent_child)->children.n;
-
-		next = list_entry(t->list.next, struct tal_hdr, list);
-		if (&next->list != end)
-			return from_tal_hdr(next);
-
-                /* OK, go back to parent. */
-                t = ignore_destroying_bit(t->parent_child)->parent;
-        } while (t != top);
-
-        return NULL;
+	head = &ignore_destroying_bit(prevhdr->parent_child)->children;
+	next = list_next(head, prevhdr, list);
+	if (!next)
+		return NULL;
+	return from_tal_hdr(next);
 }
 
 tal_t *tal_parent(const tal_t *ctx)
@@ -638,32 +709,61 @@ tal_t *tal_parent(const tal_t *ctx)
         return from_tal_hdr(ignore_destroying_bit(t->parent_child)->parent);
 }
 
-bool tal_resize_(tal_t **ctxp, size_t size)
+bool tal_resize_(tal_t **ctxp, size_t size, size_t count, bool clear)
 {
         struct tal_hdr *old_t, *t;
         struct children *child;
+	struct prop_hdr **lenp;
+	struct length len;
+	size_t extra = 0;
 
         old_t = debug_tal(to_tal_hdr(*ctxp));
 
-	/* Don't hand silly sizes to realloc. */
-	if (size >> (CHAR_BIT*sizeof(size) - 1)) {
-		call_error("Reallocation size overflow");
+	if (!adjust_size(&size, count))
 		return false;
-	}
 
-        t = resizefn(old_t, size + sizeof(struct tal_hdr));
+	lenp = find_property_ptr(old_t, LENGTH);
+	if (lenp) {
+		/* Copy here, in case we're shrinking! */
+		len = *(struct length *)*lenp;
+		extra = extra_for_length(size);
+	} else /* If we don't have an old length, we can't clear! */
+		assert(!clear);
+
+        t = resizefn(old_t, sizeof(struct tal_hdr) + size + extra);
 	if (!t) {
 		call_error("Reallocation failure");
 		return false;
 	}
 
+	/* Copy length to end. */
+	if (lenp) {
+		struct length *new_len;
+
+		/* Clear between old end and new end. */
+		if (clear && size > len.len) {
+			char *old_end = (char *)(t + 1) + len.len;
+			memset(old_end, 0, size - len.len);
+		}
+
+		new_len = (struct length *)((char *)(t + 1) + size
+					    + extra - sizeof(len));
+		len.len = size;
+		*new_len = len;
+
+		/* Be careful replacing next ptr; could be old hdr. */
+		if (lenp == &old_t->prop)
+			t->prop = &new_len->hdr;
+		else
+			*lenp = &new_len->hdr;
+	}
+
+	update_bounds(t, sizeof(struct tal_hdr) + size + extra);
+
 	/* If it didn't move, we're done! */
         if (t != old_t) {
-		update_bounds(t, size + sizeof(struct tal_hdr));
-
 		/* Fix up linked list pointers. */
-		if (list_entry(t->list.next, struct tal_hdr, list) != old_t)
-			t->list.next->prev = t->list.prev->next = &t->list;
+		t->list.next->prev = t->list.prev->next = &t->list;
 
 		/* Fix up child property's parent pointer. */
 		child = find_property(t, CHILDREN);
@@ -672,45 +772,61 @@ bool tal_resize_(tal_t **ctxp, size_t size)
 			child->parent = t;
 		}
 		*ctxp = from_tal_hdr(debug_tal(t));
-		notify(t, TAL_NOTIFY_MOVE, from_tal_hdr(old_t));
+		if (notifiers)
+			notify(t, TAL_NOTIFY_MOVE, from_tal_hdr(old_t), 0);
 	}
-	notify(t, TAL_NOTIFY_RESIZE, (void *)size);
+	if (notifiers)
+		notify(t, TAL_NOTIFY_RESIZE, (void *)size, 0);
 
 	return true;
 }
 
-char *tal_strdup(const tal_t *ctx, const char *p)
+bool tal_expand_(tal_t **ctxp, const void *src, size_t size, size_t count)
 {
-	/* We have to let through NULL for take(). */
-	return tal_dup(ctx, char, p, p ? strlen(p) + 1: 1, 0);
-}
+	struct length *l;
+	size_t old_len;
+	bool ret = false;
 
-char *tal_strndup(const tal_t *ctx, const char *p, size_t n)
-{
-	size_t len;
-	char *ret;
+	l = find_property(debug_tal(to_tal_hdr(*ctxp)), LENGTH);
+	old_len = l->len;
 
-	/* We have to let through NULL for take(). */
-	if (likely(p)) {
-		len = strlen(p);
-		if (len > n)
-			len = n;
-	} else
-		len = n;
+	/* Check for additive overflow */
+	if (old_len + count * size < old_len) {
+		call_error("dup size overflow");
+		goto out;
+	}
 
-	ret = tal_dup(ctx, char, p, len, 1);
-	if (ret)
-		ret[len] = '\0';
+	/* Don't point src inside thing we're expanding! */
+	assert(src < *ctxp
+	       || (char *)src >= (char *)(*ctxp) + old_len);
+
+	if (!tal_resize_(ctxp, size, old_len/size + count, false))
+		goto out;
+
+	memcpy((char *)*ctxp + old_len, 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 n, size_t extra,
+void *tal_dup_(const tal_t *ctx, const void *p, size_t size,
+	       size_t n, size_t extra, bool add_length,
 	       const char *label)
 {
 	void *ret;
+	size_t nbytes = size;
 
-	/* Beware overflow! */
-	if (n + extra < n || n + extra + sizeof(struct tal_hdr) < n) {
+	if (!adjust_size(&nbytes, n)) {
+		if (taken(p))
+			tal_free(p);
+		return NULL;
+	}
+
+	/* Beware addition overflow! */
+	if (n + extra < n) {
 		call_error("dup size overflow");
 		if (taken(p))
 			tal_free(p);
@@ -720,59 +836,19 @@ void *tal_dup_(const tal_t *ctx, const void *p, size_t n, size_t extra,
 	if (taken(p)) {
 		if (unlikely(!p))
 			return NULL;
-		if (unlikely(!tal_resize_((void **)&p, n + extra)))
+		if (unlikely(!tal_resize_((void **)&p, size, n + extra, false)))
 			return tal_free(p);
 		if (unlikely(!tal_steal(ctx, p)))
 			return tal_free(p);
 		return (void *)p;
 	}
-	ret = tal_alloc_(ctx, n + extra, false, label);
-	if (ret)
-		memcpy(ret, p, n);
-	return ret;
-}
-
-char *tal_asprintf(const tal_t *ctx, const char *fmt, ...)
-{
-	va_list ap;
-	char *ret;
-
-	va_start(ap, fmt);
-	ret = tal_vasprintf(ctx, fmt, ap);
-	va_end(ap);
 
+	ret = tal_alloc_arr_(ctx, size, n + extra, false, add_length, label);
+	if (ret)
+		memcpy(ret, p, nbytes);
 	return ret;
 }
 
-char *tal_vasprintf(const tal_t *ctx, const char *fmt, va_list ap)
-{
-	size_t max;
-	char *buf;
-	int ret;
-
-	if (!fmt && taken(fmt))
-		return NULL;
-
-	/* A decent guess to start. */
-	max = strlen(fmt) * 2;
-	buf = tal_arr(ctx, char, max);
-	while (buf) {
-		va_list ap2;
-
-		va_copy(ap2, ap);
-		ret = vsnprintf(buf, max, fmt, ap2);
-		va_end(ap2);
-
-		if (ret < max)
-			break;
-		if (!tal_resize(&buf, max *= 2))
-			buf = tal_free(buf);
-	}
-	if (taken(fmt))
-		tal_free(fmt);
-	return buf;
-}
-
 void tal_set_backend(void *(*alloc_fn)(size_t size),
 		     void *(*resize_fn)(void *, size_t size),
 		     void (*free_fn)(void *),
@@ -799,9 +875,9 @@ static void dump_node(unsigned int indent, const struct tal_hdr *t)
 	printf("%p", t);
         for (p = t->prop; p; p = p->next) {
 		struct children *c;
-		struct destructor *d;
 		struct name *n;
 		struct notifier *no;
+		struct length *l;
                 if (is_literal(p)) {
 			printf(" \"%s\"", (const char *)p);
 			break;
@@ -813,17 +889,17 @@ static void dump_node(unsigned int indent, const struct tal_hdr *t)
 			       p, c->parent,
 			       c->children.n.prev, c->children.n.next);
 			break;
-		case DESTRUCTOR:
-			d = (struct destructor *)p;
-			printf(" DESTRUCTOR(%p):fn=%p", p, d->destroy);
-			break;
 		case NAME:
 			n = (struct name *)p;
 			printf(" NAME(%p):%s", p, n->name);
 			break;
 		case NOTIFIER:
 			no = (struct notifier *)p;
-			printf(" NOTIFIER(%p):fn=%p", p, no->notifyfn);
+			printf(" NOTIFIER(%p):fn=%p", p, no->u.notifyfn);
+			break;
+		case LENGTH:
+			l = (struct length *)p;
+			printf(" LENGTH(%p):len=%zu", p, l->len);
 			break;
 		default:
 			printf(" **UNKNOWN(%p):%i**", p, p->type);
@@ -872,6 +948,7 @@ static bool check_node(struct children *parent_child,
 	struct prop_hdr *p;
 	struct name *name = NULL;
 	struct children *children = NULL;
+	struct length *length = NULL;
 
 	if (!in_bounds(t))
 		return check_err(t, errorstr, "invalid pointer");
@@ -884,7 +961,6 @@ static bool check_node(struct children *parent_child,
 			if (name)
 				return check_err(t, errorstr,
 						 "has extra literal");
-			name = (struct name *)p;
 			break;
 		}
 		if (!in_bounds(p))
@@ -898,7 +974,12 @@ static bool check_node(struct children *parent_child,
 						 "has two child nodes");
 			children = (struct children *)p;
 			break;
-		case DESTRUCTOR:
+		case LENGTH:
+			if (length)
+				return check_err(t, errorstr,
+						 "has two lengths");
+			length = (struct length *)p;
+			break;
 		case NOTIFIER:
 			break;
 		case NAME: