X-Git-Url: https://git.ozlabs.org/?p=ccan;a=blobdiff_plain;f=ccan%2Ftal%2Ftal.c;h=2d05dd93f73b06a35538b1697ccf2eb56cdce2e0;hp=194e74c68afc8d9662b00a2924a2b2cb1da28fb6;hb=HEAD;hpb=ca6991d861a02d1da8d51f71607a4d9d8e145850 diff --git a/ccan/tal/tal.c b/ccan/tal/tal.c index 194e74c6..1230d8ca 100644 --- a/ccan/tal/tal.c +++ b/ccan/tal/tal.c @@ -2,33 +2,43 @@ #include #include #include -#include +#include #include #include -#include #include #include #include +#include #include //#define TAL_DEBUG 1 +#define NOTIFY_IS_DESTRUCTOR 512 +#define NOTIFY_EXTRA_ARG 1024 + +/* This makes our parent_child ptr stand out for to_tal_hdr checks */ +#define TAL_PTR_OBFUSTICATOR ((intptr_t)0x1984200820142016ULL) + /* 32-bit type field, first byte 0 in either endianness. */ enum prop_type { CHILDREN = 0x00c1d500, - DESTRUCTOR = 0x00de5700, NAME = 0x00111100, + NOTIFIER = 0x00071f00, }; struct tal_hdr { struct list_node list; - struct prop_hdr *prop; - struct children *parent_child; + /* Use is_prop_hdr tell if this is a struct prop_hdr or string! */ + char *prop; + /* XOR with TAL_PTR_OBFUSTICATOR */ + intptr_t parent_child; + size_t bytelen; }; struct prop_hdr { enum prop_type type; - struct prop_hdr *next; + /* Use is_prop_hdr to tell if this is a struct prop_hdr or string! */ + char *next; }; struct children { @@ -37,21 +47,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 notifier { + struct prop_hdr hdr; /* NOTIFIER */ + enum tal_notify_type types; + union notifier_cb { + 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; } null_parent = { { { &null_parent.hdr.list, &null_parent.hdr.list }, - &null_parent.c.hdr, NULL }, + (char *)&null_parent.c.hdr, TAL_PTR_OBFUSTICATOR, 0 }, { { CHILDREN, NULL }, &null_parent.hdr, { { &null_parent.c.children.n, @@ -64,51 +87,49 @@ 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) { errorfn(msg); } -static bool get_destroying_bit(struct children *parent_child) +static bool get_destroying_bit(intptr_t parent_child) { - return (size_t)parent_child & 1; + return parent_child & 1; } -static void set_destroying_bit(struct children **parent_child) +static void set_destroying_bit(intptr_t *parent_child) { - *parent_child = (void *)((size_t)*parent_child | 1); + *parent_child |= 1; } -static struct children *ignore_destroying_bit(struct children *parent_child) +static struct children *ignore_destroying_bit(intptr_t parent_child) { - return (void *)((size_t)parent_child & ~(size_t)1); + return (void *)((parent_child ^ TAL_PTR_OBFUSTICATOR) & ~(intptr_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) +static struct prop_hdr *is_prop_hdr(const char *ptr) { - return ((char *)prop)[0] != 0; + if (*ptr != 0) + return NULL; + return (struct prop_hdr *)ptr; } #ifndef NDEBUG @@ -157,8 +178,11 @@ static struct tal_hdr *to_tal_hdr(const void *ctx) check_bounds(ignore_destroying_bit(t->parent_child)); check_bounds(t->list.next); check_bounds(t->list.prev); - if (t->prop && !is_literal(t->prop)) - check_bounds(t->prop); + if (t->prop) { + struct prop_hdr *p = is_prop_hdr(t->prop); + if (p) + check_bounds(p); + } return t; } @@ -169,19 +193,19 @@ static struct tal_hdr *to_tal_hdr_or_null(const void *ctx) return to_tal_hdr(ctx); } -static void *from_tal_hdr(struct tal_hdr *hdr) +static void *from_tal_hdr(const struct tal_hdr *hdr) { - return hdr + 1; + return (void *)(hdr + 1); } -#ifdef TAL_DEBUG -static void *from_tal_hdr_or_null(struct tal_hdr *hdr) +static void *from_tal_hdr_or_null(const struct tal_hdr *hdr) { if (hdr == &null_parent.hdr) return NULL; return from_tal_hdr(hdr); } +#ifdef TAL_DEBUG static struct tal_hdr *debug_tal(struct tal_hdr *tal) { tal_check(from_tal_hdr_or_null(tal), "TAL_DEBUG "); @@ -194,17 +218,42 @@ static struct tal_hdr *debug_tal(struct tal_hdr *tal) } #endif -static void *allocate(size_t size) +static void notify(const struct tal_hdr *ctx, + enum tal_notify_type type, const void *info, + int saved_errno) { - void *ret; + const char *ptr; + const struct prop_hdr *p; - /* Don't hand silly sizes to malloc. */ - if (size >> (CHAR_BIT*sizeof(size) - 1)) { - call_error("allocation size overflow"); - return NULL; + for (ptr = ctx->prop; ptr && (p = is_prop_hdr(ptr)) != NULL; ptr = p->next) { + struct notifier *n; + + if (p->type != NOTIFIER) + continue; + n = (struct notifier *)p; + if (n->types & type) { + errno = saved_errno; + if (n->types & NOTIFY_IS_DESTRUCTOR) { + /* Blatt this notifier in case it tries to + * tal_del_destructor() from inside */ + union notifier_cb cb = n->u; + /* It's a union, so this NULLs destroy2 too! */ + n->u.destroy = NULL; + if (n->types & NOTIFY_EXTRA_ARG) + cb.destroy2(from_tal_hdr(ctx), + EXTRA_ARG(n)); + else + cb.destroy(from_tal_hdr(ctx)); + } else + n->u.notifyfn(from_tal_hdr_or_null(ctx), type, + (void *)info); + } } +} - ret = allocfn(size); +static void *allocate(size_t size) +{ + void *ret = allocfn(size); if (!ret) call_error("allocation failed"); else @@ -212,29 +261,54 @@ static void *allocate(size_t size) return ret; } -static struct prop_hdr **find_property_ptr(const struct tal_hdr *t, - enum prop_type type) +/* Returns a pointer to the pointer: can cast (*ret) to a (struct prop_ptr *) */ +static char **find_property_ptr(struct tal_hdr *t, enum prop_type type) { - struct prop_hdr **p; + char **ptr; + struct prop_hdr *p; - for (p = (struct prop_hdr **)&t->prop; *p; p = &(*p)->next) { - if (is_literal(*p)) { - if (type == NAME) - return p; - break; - } - if ((*p)->type == type) - return p; - } - return NULL; + /* NAME is special, as it can be a literal: see find_name_property */ + assert(type != NAME); + for (ptr = &t->prop; *ptr; ptr = &p->next) { + if (!is_prop_hdr(*ptr)) + break; + p = (struct prop_hdr *)*ptr; + if (p->type == type) + return ptr; + } + return NULL; +} + +/* This is special: + * NULL - not found + * *literal: true - char **, pointer to literal pointer. + * *literal: false - struct prop_hdr **, pointer to header ptr. + */ +static char **find_name_property(struct tal_hdr *t, bool *literal) +{ + char **ptr; + struct prop_hdr *p; + + for (ptr = &t->prop; *ptr; ptr = &p->next) { + if (!is_prop_hdr(*ptr)) { + *literal = true; + return ptr; + } + p = (struct prop_hdr *)*ptr; + if (p->type == NAME) { + *literal = false; + return ptr; + } + } + return NULL; } -static void *find_property(const struct tal_hdr *parent, enum prop_type type) +static void *find_property(struct tal_hdr *parent, enum prop_type type) { - struct prop_hdr **p = find_property_ptr(parent, type); + char **ptr = find_property_ptr(parent, type); - if (p) - return *p; + if (ptr) + return (struct prop_hdr *)*ptr; return NULL; } @@ -244,40 +318,68 @@ static void init_property(struct prop_hdr *hdr, { hdr->type = type; hdr->next = parent->prop; - parent->prop = hdr; + parent->prop = (char *)hdr; } -static struct destructor *add_destructor_property(struct tal_hdr *t, - void (*destroy)(void *)) +static struct notifier *add_notifier_property(struct tal_hdr *t, + enum tal_notify_type types, + void (*fn)(void *, + enum tal_notify_type, + void *), + void *extra_arg) { - struct destructor *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, DESTRUCTOR); - prop->destroy = destroy; + init_property(&prop->hdr, t, NOTIFIER); + prop->types = types; + prop->u.notifyfn = fn; + if (types & NOTIFY_EXTRA_ARG) + EXTRA_ARG(prop) = extra_arg; } return prop; } -static bool del_destructor_property(struct tal_hdr *t, - void (*destroy)(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; + char **ptr; + struct prop_hdr *p; - for (p = (struct prop_hdr **)&t->prop; *p; p = &(*p)->next) { - struct destructor *d; + for (ptr = &t->prop; *ptr; ptr = &p->next) { + struct notifier *n; + enum tal_notify_type types; - if (is_literal(*p)) + p = is_prop_hdr(*ptr); + if (!p) break; - if ((*p)->type != DESTRUCTOR) + + if (p->type != NOTIFIER) continue; - d = (struct destructor *)*p; - if (d->destroy == destroy) { - *p = (*p)->next; - freefn(d); - return true; - } + n = (struct notifier *)p; + if (n->u.notifyfn != fn) + continue; + + types = n->types; + if ((types & NOTIFY_EXTRA_ARG) + && match_extra_arg + && extra_arg != EXTRA_ARG(n)) + continue; + + *ptr = p->next; + freefn(p); + 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) @@ -293,7 +395,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) { @@ -309,23 +411,21 @@ 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; } list_add(&children->children, &child->list); - child->parent_child = children; + child->parent_child = (intptr_t)children ^ TAL_PTR_OBFUSTICATOR; return true; } -static void del_tree(struct tal_hdr *t) +static void del_tree(struct tal_hdr *t, const tal_t *orig, int saved_errno) { - struct prop_hdr **prop, *p, *next; + struct prop_hdr *prop; + char *ptr, *next; + + assert(!taken(from_tal_hdr(t))); /* Already being destroyed? Don't loop. */ if (unlikely(get_destroying_bit(t->parent_child))) @@ -333,30 +433,25 @@ static void del_tree(struct tal_hdr *t) 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, saved_errno); /* Now free children and groups. */ - prop = find_property_ptr(t, CHILDREN); + prop = find_property(t, CHILDREN); if (prop) { struct tal_hdr *i; - struct children *c = (struct children *)*prop; + struct children *c = (struct children *)prop; while ((i = list_top(&c->children, struct tal_hdr, list))) { list_del(&i->list); - del_tree(i); + 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); + for (ptr = t->prop; ptr && (prop = is_prop_hdr(ptr)); ptr = next) { + next = prop->next; + freefn(ptr); } freefn(t); } @@ -371,22 +466,59 @@ void *tal_alloc_(const tal_t *ctx, size_t size, bool clear, const char *label) if (clear) memset(from_tal_hdr(child), 0, size); child->prop = (void *)label; + child->bytelen = size; + if (!add_child(parent, child)) { freefn(child); return NULL; } debug_tal(parent); + 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); + + /* Multiplication wrap */ + if (count && unlikely(*size * count / *size != count)) + goto overflow; + + *size *= count; + + /* Make sure we don't wrap adding header. */ + 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, + const char *label) +{ + if (!adjust_size(&size, count)) + return NULL; + + return tal_alloc_(ctx, size, clear, 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)); + if (unlikely(get_destroying_bit(t->parent_child))) + return NULL; + if (notifiers) + notify(ignore_destroying_bit(t->parent_child)->parent, + TAL_NOTIFY_DEL_CHILD, ctx, saved_errno); list_del(&t->list); - del_tree(t); + del_tree(t, ctx, saved_errno); errno = saved_errno; } return NULL; @@ -405,68 +537,151 @@ void *tal_steal_(const tal_t *new_parent, const tal_t *ctx) old_parent = ignore_destroying_bit(t->parent_child)->parent; if (unlikely(!add_child(newpar, t))) { - /* We can always add to old parent, becuase it has a + /* We can always add to old parent, because it has a * children property already. */ if (!add_child(old_parent, t)) abort(); return NULL; } debug_tal(newpar); + 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)) { - return add_destructor_property(debug_tal(to_tal_hdr(ctx)), destroy); + tal_t *t = debug_tal(to_tal_hdr(ctx)); + return add_notifier_property(t, TAL_NOTIFY_FREE|NOTIFY_IS_DESTRUCTOR, + (void *)destroy, NULL); } -bool tal_del_destructor_(tal_t *ctx, void (*destroy)(void *me)) +bool tal_add_destructor2_(const tal_t *ctx, void (*destroy)(void *me, void *arg), + void *arg) { - return del_destructor_property(debug_tal(to_tal_hdr(ctx)), destroy); + 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 *)) +{ + struct tal_hdr *t = debug_tal(to_tal_hdr_or_null(ctx)); + struct notifier *n; + + assert(types); + assert((types & ~(TAL_NOTIFY_FREE | TAL_NOTIFY_STEAL | TAL_NOTIFY_MOVE + | TAL_NOTIFY_RESIZE | TAL_NOTIFY_RENAME + | TAL_NOTIFY_ADD_CHILD | TAL_NOTIFY_DEL_CHILD + | TAL_NOTIFY_ADD_NOTIFIER + | TAL_NOTIFY_DEL_NOTIFIER)) == 0); + + /* Don't call notifier about itself: set types after! */ + n = add_notifier_property(t, 0, callback, NULL); + if (unlikely(!n)) + return false; + + 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_(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_or_null(ctx)); + enum tal_notify_type types; + + 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_(const tal_t *ctx, void (*destroy)(void *me)) +{ + 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) { struct tal_hdr *t = debug_tal(to_tal_hdr(ctx)); - struct prop_hdr **prop = find_property_ptr(t, NAME); + bool was_literal; + char **nptr; /* Get rid of any old name */ - if (prop) { - struct name *name = (struct name *)*prop; - if (is_literal(&name->hdr)) - *prop = NULL; - else { - *prop = name->hdr.next; - freefn(name); - } + nptr = find_name_property(t, &was_literal); + if (nptr) { + if (was_literal) + *nptr = NULL; + else { + struct name *oldname; + + oldname = (struct name *)*nptr; + *nptr = oldname->hdr.next; + freefn(oldname); + } } if (literal && name[0]) { - struct prop_hdr **p; + char **ptr; + struct prop_hdr *prop; /* Append literal. */ - for (p = &t->prop; *p && !is_literal(*p); p = &(*p)->next); - *p = (struct prop_hdr *)name; - return true; - } - if (!add_name_property(t, name)) + for (ptr = &t->prop; *ptr; ptr = &prop->next) { + prop = is_prop_hdr(*ptr); + if (!prop) + break; + } + *ptr = (char *)name; + } else if (!add_name_property(t, name)) return false; + debug_tal(t); + if (notifiers) + notify(t, TAL_NOTIFY_RENAME, name, 0); return true; } const char *tal_name(const tal_t *t) { - struct name *n; + char **nptr; + bool literal; - n = find_property(debug_tal(to_tal_hdr(t)), NAME); - if (!n) + nptr = find_name_property(debug_tal(to_tal_hdr(t)), &literal); + if (!nptr) return NULL; + if (literal) + return *nptr; - if (is_literal(&n->hdr)) - return (const char *)n; - return n->name; + return ((struct name *)(*nptr))->name; +} + +size_t tal_bytelen(const tal_t *ptr) +{ + /* NULL -> null_parent which has bytelen 0 */ + struct tal_hdr *t = debug_tal(to_tal_hdr_or_null(ptr)); + + return t->bytelen; } /* Start one past first child: make stopping natural in circ. list. */ @@ -491,31 +706,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; - - /* 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); + struct tal_hdr *next, *prevhdr = debug_tal(to_tal_hdr(prev)); + struct list_head *head; - 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) @@ -531,76 +731,106 @@ 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; 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)); + t = resizefn(old_t, sizeof(struct tal_hdr) + size); if (!t) { call_error("Reallocation failure"); return false; } - /* If it didn't move, we're done! */ - if (t == old_t) - return true; - update_bounds(t, size + sizeof(struct tal_hdr)); + /* Clear between old end and new end. */ + if (clear && size > t->bytelen) { + char *old_end = (char *)(t + 1) + t->bytelen; + memset(old_end, 0, size - t->bytelen); + } + + /* Update length. */ + t->bytelen = size; + update_bounds(t, sizeof(struct tal_hdr) + size); - /* Fix up linked list pointers. */ - if (list_entry(t->list.next, struct tal_hdr, list) != old_t) + /* If it didn't move, we're done! */ + if (t != old_t) { + /* Fix up linked list pointers. */ t->list.next->prev = t->list.prev->next = &t->list; - /* Fix up child property's parent pointer. */ - child = find_property(t, CHILDREN); - if (child) { - assert(child->parent == old_t); - child->parent = t; + /* Copy take() property. */ + if (taken(from_tal_hdr(old_t))) + take(from_tal_hdr(t)); + + /* Fix up child property's parent pointer. */ + child = find_property(t, CHILDREN); + if (child) { + assert(child->parent == old_t); + child->parent = t; + } + *ctxp = from_tal_hdr(debug_tal(t)); + if (notifiers) + notify(t, TAL_NOTIFY_MOVE, from_tal_hdr(old_t), 0); } - *ctxp = from_tal_hdr(debug_tal(t)); + 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); -} + 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; + old_len = debug_tal(to_tal_hdr(*ctxp))->bytelen; + + /* Check for additive overflow */ + if (old_len + count * size < old_len) { + call_error("dup size overflow"); + goto out; + } + + /* Don't point src inside thing we're expanding! */ + assert(src < *ctxp + || (char *)src >= (char *)(*ctxp) + old_len); - /* We have to let through NULL for take(). */ - if (likely(p)) { - len = strlen(p); - if (len > n) - len = n; - } else - len = n; + if (!tal_resize_(ctxp, size, old_len/size + count, false)) + goto out; - ret = tal_dup(ctx, char, p, len, 1); - if (ret) - ret[len] = '\0'; + 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, - const char *label) +void *tal_dup_(const tal_t *ctx, const void *p, size_t size, + size_t n, size_t extra, bool nullok, const char *label) { void *ret; + size_t nbytes = size; + + if (nullok && p == NULL) { + /* take(NULL) works. */ + (void)taken(p); + return NULL; + } + + if (!adjust_size(&nbytes, n)) { + if (taken(p)) + tal_free(p); + return NULL; + } - /* Beware overflow! */ - if (n + extra < n || n + extra + sizeof(struct tal_hdr) < n) { + /* Beware addition overflow! */ + if (n + extra < n) { call_error("dup size overflow"); if (taken(p)) tal_free(p); @@ -610,57 +840,22 @@ 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, label); + if (ret && p) + memcpy(ret, p, nbytes); return ret; } -char *tal_vasprintf(const tal_t *ctx, const char *fmt, va_list ap) +void *tal_dup_talarr_(const tal_t *ctx, const tal_t *src TAKES, const char *label) { - 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; + return tal_dup_(ctx, src, 1, tal_bytelen(src), 0, true, label); } void tal_set_backend(void *(*alloc_fn)(size_t size), @@ -682,39 +877,41 @@ void tal_set_backend(void *(*alloc_fn)(size_t size), static void dump_node(unsigned int indent, const struct tal_hdr *t) { unsigned int i; - const struct prop_hdr *p; + const struct prop_hdr *prop; + const char *ptr; for (i = 0; i < indent; i++) - printf(" "); - printf("%p", t); - for (p = t->prop; p; p = p->next) { + fprintf(stderr, " "); + fprintf(stderr, "%p len=%zu", t, t->bytelen); + for (ptr = t->prop; ptr; ptr = prop->next) { struct children *c; - struct destructor *d; struct name *n; - if (is_literal(p)) { - printf(" \"%s\"", (const char *)p); + struct notifier *no; + prop = is_prop_hdr(ptr); + if (!prop) { + fprintf(stderr, " \"%s\"", ptr); break; } - switch (p->type) { + switch (prop->type) { case CHILDREN: - c = (struct children *)p; - printf(" CHILDREN(%p):parent=%p,children={%p,%p}\n", - p, c->parent, + c = (struct children *)prop; + fprintf(stderr, " CHILDREN(%p):parent=%p,children={%p,%p}", + prop, 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); + n = (struct name *)prop; + fprintf(stderr, " NAME(%p):%s", prop, n->name); + break; + case NOTIFIER: + no = (struct notifier *)prop; + fprintf(stderr, " NOTIFIER(%p):fn=%p", prop, no->u.notifyfn); break; default: - printf(" **UNKNOWN(%p):%i**", p, p->type); + fprintf(stderr, " **UNKNOWN(%p):%i**", prop, prop->type); } } - printf("\n"); + fprintf(stderr, "\n"); } static void tal_dump_(unsigned int level, const struct tal_hdr *t) @@ -723,7 +920,7 @@ static void tal_dump_(unsigned int level, const struct tal_hdr *t) dump_node(level, t); - children = find_property(t, CHILDREN); + children = find_property((struct tal_hdr *)t, CHILDREN); if (children) { struct tal_hdr *i; @@ -754,7 +951,8 @@ static bool check_err(struct tal_hdr *t, const char *errorstr, static bool check_node(struct children *parent_child, struct tal_hdr *t, const char *errorstr) { - struct prop_hdr *p; + struct prop_hdr *prop; + char *p; struct name *name = NULL; struct children *children = NULL; @@ -764,32 +962,32 @@ static bool check_node(struct children *parent_child, if (ignore_destroying_bit(t->parent_child) != parent_child) return check_err(t, errorstr, "incorrect parent"); - for (p = t->prop; p; p = p->next) { - if (is_literal(p)) { + for (p = t->prop; p; p = prop->next) { + prop = is_prop_hdr(p); + if (!prop) { if (name) return check_err(t, errorstr, "has extra literal"); - name = (struct name *)p; break; } - if (!in_bounds(p)) + if (!in_bounds(prop)) return check_err(t, errorstr, "has bad property pointer"); - switch (p->type) { + switch (prop->type) { case CHILDREN: if (children) return check_err(t, errorstr, "has two child nodes"); - children = (struct children *)p; + children = (struct children *)prop; break; - case DESTRUCTOR: + case NOTIFIER: break; case NAME: if (name) return check_err(t, errorstr, "has two names"); - name = (struct name *)p; + name = (struct name *)prop; break; default: return check_err(t, errorstr, "has unknown property");