aljaz/lightning
1
0
Fork 0
mirror of https://github.com/aljazceru/lightning.git synced 2025-12-19 07:04:22 +01:00
Code Issues Packages Projects Releases Wiki Activity

ccan: update to include versions which pass -fsanitize=address and -fsanitize=undefined

Browse Source 
Most importantly, configurator used to use bitshifts on signed
integers which -fsanitize=undefined caught.

But also, tal played fast and loose with typing and aliases, which was
a signficant amount of rework.

Signed-off-by: Rusty Russell <rusty@rustcorp.com.au>
This commit is contained in:
Rusty Russell
2023-04-01 14:08:23 +10:30
parent 5ea1fade60
commit 801c678cb9
19 changed files with 174 additions and 107 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
ccan/README
View File

@@ -1,3 +1,3 @@
CCAN imported from http://ccodearchive.net. CCAN imported from http://ccodearchive.net.
CCAN version: init-2549-gba79e21b CCAN version: init-2565-g3942778b

8
ccan/ccan/bitops/test/run.c
View File

@@ -10,7 +10,7 @@ int main(void)
plan_tests(68 + 6 * (31 + 63)); plan_tests(68 + 6 * (31 + 63));
for (i = 0; i < 32; i++) for (i = 0; i < 32; i++)
ok1(bitops_ffs32(1 << i) == i+1); ok1(bitops_ffs32(1U << i) == i+1);
ok1(bitops_ffs32(0) == 0); ok1(bitops_ffs32(0) == 0);
for (i = 0; i < 64; i++) for (i = 0; i < 64; i++)
ok1(bitops_ffs64((uint64_t)1 << i) == i+1); ok1(bitops_ffs64((uint64_t)1 << i) == i+1);
@@ -25,19 +25,19 @@ int main(void)
ok1(bitops_ffs64(0) == 0); ok1(bitops_ffs64(0) == 0);
for (i = 0; i < 32; i++) for (i = 0; i < 32; i++)
ok1(bitops_clz32(1 << i) == 31 - i); ok1(bitops_clz32(1U << i) == 31 - i);
for (i = 0; i < 64; i++) for (i = 0; i < 64; i++)
ok1(bitops_clz64((uint64_t)1 << i) == 63 - i); ok1(bitops_clz64((uint64_t)1 << i) == 63 - i);
/* Lower bits don't effect results */ /* Lower bits don't effect results */
for (i = 0; i < 32; i++) for (i = 0; i < 32; i++)
ok1(bitops_clz32((1 << i) + (1 << i)-1) == 31 - i); ok1(bitops_clz32((1U << i) + (1U << i)-1) == 31 - i);
for (i = 0; i < 64; i++) for (i = 0; i < 64; i++)
ok1(bitops_clz64(((uint64_t)1 << i) + ((uint64_t)1 << i)-1) ok1(bitops_clz64(((uint64_t)1 << i) + ((uint64_t)1 << i)-1)
== 63 - i); == 63 - i);
for (i = 0; i < 32; i++) for (i = 0; i < 32; i++)
ok1(bitops_ctz32(1 << i) == i); ok1(bitops_ctz32(1U << i) == i);
for (i = 0; i < 64; i++) for (i = 0; i < 64; i++)
ok1(bitops_ctz64((uint64_t)1 << i) == i); ok1(bitops_ctz64((uint64_t)1 << i) == i);

1
ccan/ccan/crypto/hmac_sha256/hmac_sha256.c
View File

@@ -35,6 +35,7 @@ void hmac_sha256_init(struct hmac_sha256_ctx *ctx,
* (e.g., if K is of length 20 bytes and B=64, then K will be * (e.g., if K is of length 20 bytes and B=64, then K will be
* appended with 44 zero bytes 0x00) * appended with 44 zero bytes 0x00)
*/ */
if (ksize != 0)
memcpy(k_ipad, k, ksize); memcpy(k_ipad, k, ksize);
memset((char *)k_ipad + ksize, 0, HMAC_SHA256_BLOCKSIZE - ksize); memset((char *)k_ipad + ksize, 0, HMAC_SHA256_BLOCKSIZE - ksize);

3
ccan/ccan/htable/htable_type.h
View File

@@ -159,8 +159,7 @@
size_t seed, \ size_t seed, \
struct name##_iter *iter) \ struct name##_iter *iter) \
{ \ { \
/* Note &iter->i == NULL iff iter is NULL */ \ return htable_pick(&ht->raw, seed, iter ? &iter->i : NULL); \
return htable_pick(&ht->raw, seed, &iter->i); \
} \ } \
static inline UNNEEDED type *name##_first(const struct name *ht, \ static inline UNNEEDED type *name##_first(const struct name *ht, \
struct name##_iter *iter) \ struct name##_iter *iter) \

7
ccan/ccan/ilog/ilog.h
View File

@@ -120,7 +120,10 @@ int ilog64_nz(uint64_t _v) CONST_FUNCTION;
#endif #endif
#ifdef builtin_ilog32_nz #ifdef builtin_ilog32_nz
#define ilog32(_v) (builtin_ilog32_nz(_v)&-!!(_v)) /* This used to be builtin_ilog32_nz(_v)&-!!(_v), which means it zeroes out
* the undefined builtin_ilog32_nz(0) return. But clang UndefinedBehaviorSantizer
* complains, so do the branch: */
#define ilog32(_v) ((_v) ? builtin_ilog32_nz(_v) : 0)
#define ilog32_nz(_v) builtin_ilog32_nz(_v) #define ilog32_nz(_v) builtin_ilog32_nz(_v)
#else #else
#define ilog32_nz(_v) ilog32(_v) #define ilog32_nz(_v) ilog32(_v)
@@ -128,7 +131,7 @@ int ilog64_nz(uint64_t _v) CONST_FUNCTION;
#endif /* builtin_ilog32_nz */ #endif /* builtin_ilog32_nz */
#ifdef builtin_ilog64_nz #ifdef builtin_ilog64_nz
#define ilog64(_v) (builtin_ilog64_nz(_v)&-!!(_v)) #define ilog32(_v) ((_v) ? builtin_ilog32_nz(_v) : 0)
#define ilog64_nz(_v) builtin_ilog64_nz(_v) #define ilog64_nz(_v) builtin_ilog64_nz(_v)
#else #else
#define ilog64_nz(_v) ilog64(_v) #define ilog64_nz(_v) ilog64(_v)

10
ccan/ccan/io/fdpass/_info
View File

@@ -32,12 +32,20 @@
* read_more, buf); * read_more, buf);
* } * }
* *
* // Clean up allocation so -fsanitize=address doesn't see leak!
* static void free_buf(struct io_conn *c, struct buf *buf)
* {
* free(buf);
* }
*
* // Child has received fd, start reading loop. * // Child has received fd, start reading loop.
* static struct io_plan *got_infd(struct io_conn *conn, int *infd) * static struct io_plan *got_infd(struct io_conn *conn, int *infd)
* { * {
* struct buf *buf = calloc(1, sizeof(*buf)); * struct buf *buf = calloc(1, sizeof(*buf));
* struct io_conn *new_conn;
* *
* io_new_conn(NULL, *infd, read_more, buf); * new_conn = io_new_conn(NULL, *infd, read_more, buf);
* io_set_finish(new_conn, free_buf, buf);
* return io_close(conn); * return io_close(conn);
* } * }
* // Child is receiving the fd to read into. * // Child is receiving the fd to read into.

2
ccan/ccan/mem/mem.h
View File

@@ -104,7 +104,7 @@ void *memcchr(void const *data, int c, size_t data_len);
PURE_FUNCTION PURE_FUNCTION
static inline bool memeq(const void *a, size_t al, const void *b, size_t bl) static inline bool memeq(const void *a, size_t al, const void *b, size_t bl)
{ {
return al == bl && !memcmp(a, b, bl); return al == bl && (al == 0 || !memcmp(a, b, bl));
} }
/** /**

7
ccan/ccan/membuf/_info
View File

@@ -26,13 +26,16 @@
* *
* membuf_init(&charbuf, malloc(10), 10, membuf_realloc); * membuf_init(&charbuf, malloc(10), 10, membuf_realloc);
* *
* for (int i = 1; i < argc; i++) * for (int i = 1; i < argc; i++) {
* strcpy(membuf_add(&charbuf, strlen(argv[i])), argv[i]); * size_t len = strlen(argv[i]);
* memcpy(membuf_add(&charbuf, len), argv[i], len);
* }
* *
* // This is dumb, we could do all at once, but shows technique. * // This is dumb, we could do all at once, but shows technique.
* while (membuf_num_elems(&charbuf) > 0) * while (membuf_num_elems(&charbuf) > 0)
* printf("%c", *(char *)membuf_consume(&charbuf, 1)); * printf("%c", *(char *)membuf_consume(&charbuf, 1));
* printf("\n"); * printf("\n");
* free(membuf_cleanup(&charbuf));
* return 0; * return 0;
* } * }
*/ */

2
ccan/ccan/opt/test/run-set_alloc.c
View File

@@ -59,8 +59,8 @@ static void *reallocfn(void *ptr, size_t size)
static void freefn(void *ptr) static void freefn(void *ptr)
{ {
free_count++; free_count++;
free(ptr);
*find_ptr(ptr) = NULL; *find_ptr(ptr) = NULL;
free(ptr);
} }
int main(int argc, char *argv[]) int main(int argc, char *argv[])

1
ccan/ccan/opt/usage.c
View File

@@ -72,6 +72,7 @@ static size_t consume_words(const char *words, size_t maxlen, size_t *prefix,
} }
} }
if (oldlen != 0)
*start = (words[oldlen - 1] == '\n'); *start = (words[oldlen - 1] == '\n');
return oldlen; return oldlen;
} }

4
ccan/ccan/rbuf/rbuf.c
View File

@@ -74,7 +74,9 @@ char *rbuf_read_str(struct rbuf *rbuf, char term)
ssize_t r = 0; ssize_t r = 0;
size_t prev = 0; size_t prev = 0;
while (!(p = memchr(membuf_elems(&rbuf->m) + prev, /* memchr(NULL, ..., 0) is illegal. FML. */
while (membuf_num_elems(&rbuf->m) == prev
|| !(p = memchr(membuf_elems(&rbuf->m) + prev,
term, term,
membuf_num_elems(&rbuf->m) - prev))) { membuf_num_elems(&rbuf->m) - prev))) {
prev += r; prev += r;

197
ccan/ccan/tal/tal.c
View File

@@ -28,7 +28,8 @@ enum prop_type {
struct tal_hdr { struct tal_hdr {
struct list_node list; struct list_node list;
struct prop_hdr *prop; /* Use is_prop_hdr tell if this is a struct prop_hdr or string! */
char *prop;
/* XOR with TAL_PTR_OBFUSTICATOR */ /* XOR with TAL_PTR_OBFUSTICATOR */
intptr_t parent_child; intptr_t parent_child;
size_t bytelen; size_t bytelen;
@@ -36,7 +37,8 @@ struct tal_hdr {
struct prop_hdr { struct prop_hdr {
enum prop_type type; 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 { struct children {
@@ -72,7 +74,7 @@ static struct {
struct tal_hdr hdr; struct tal_hdr hdr;
struct children c; struct children c;
} null_parent = { { { &null_parent.hdr.list, &null_parent.hdr.list }, } null_parent = { { { &null_parent.hdr.list, &null_parent.hdr.list },
&null_parent.c.hdr, TAL_PTR_OBFUSTICATOR, 0 }, (char *)&null_parent.c.hdr, TAL_PTR_OBFUSTICATOR, 0 },
{ { CHILDREN, NULL }, { { CHILDREN, NULL },
&null_parent.hdr, &null_parent.hdr,
{ { &null_parent.c.children.n, { { &null_parent.c.children.n,
@@ -123,9 +125,11 @@ void tal_cleanup(void)
} }
/* We carefully start all real properties with a zero byte. */ /* 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 #ifndef NDEBUG
@@ -174,8 +178,11 @@ static struct tal_hdr *to_tal_hdr(const void *ctx)
check_bounds(ignore_destroying_bit(t->parent_child)); check_bounds(ignore_destroying_bit(t->parent_child));
check_bounds(t->list.next); check_bounds(t->list.next);
check_bounds(t->list.prev); check_bounds(t->list.prev);
if (t->prop && !is_literal(t->prop)) if (t->prop) {
check_bounds(t->prop); struct prop_hdr *p = is_prop_hdr(t->prop);
if (p)
check_bounds(p);
}
return t; return t;
} }
@@ -215,13 +222,12 @@ 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) int saved_errno)
{ {
const char *ptr;
const struct prop_hdr *p; const struct prop_hdr *p;
for (p = ctx->prop; p; p = p->next) { for (ptr = ctx->prop; ptr && (p = is_prop_hdr(ptr)) != NULL; ptr = p->next) {
struct notifier *n; struct notifier *n;
if (is_literal(p))
break;
if (p->type != NOTIFIER) if (p->type != NOTIFIER)
continue; continue;
n = (struct notifier *)p; n = (struct notifier *)p;
@@ -255,29 +261,54 @@ static void *allocate(size_t size)
return ret; return ret;
} }
static struct prop_hdr **find_property_ptr(const struct tal_hdr *t, /* Returns a pointer to the pointer: can cast (*ret) to a (struct prop_ptr *) */
enum prop_type type) 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) { /* NAME is special, as it can be a literal: see find_name_property */
if (is_literal(*p)) { assert(type != NAME);
if (type == NAME) for (ptr = &t->prop; *ptr; ptr = &p->next) {
return p; if (!is_prop_hdr(*ptr))
break; break;
} p = (struct prop_hdr *)*ptr;
if ((*p)->type == type) if (p->type == type)
return p; return ptr;
} }
return NULL; return NULL;
} }
static void *find_property(const struct tal_hdr *parent, enum prop_type type) /* 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)
{ {
struct prop_hdr **p = find_property_ptr(parent, type); char **ptr;
struct prop_hdr *p;
if (p) for (ptr = &t->prop; *ptr; ptr = &p->next) {
return *p; 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(struct tal_hdr *parent, enum prop_type type)
{
char **ptr = find_property_ptr(parent, type);
if (ptr)
return (struct prop_hdr *)*ptr;
return NULL; return NULL;
} }
@@ -287,7 +318,7 @@ static void init_property(struct prop_hdr *hdr,
{ {
hdr->type = type; hdr->type = type;
hdr->next = parent->prop; hdr->next = parent->prop;
parent->prop = hdr; parent->prop = (char *)hdr;
} }
static struct notifier *add_notifier_property(struct tal_hdr *t, static struct notifier *add_notifier_property(struct tal_hdr *t,
@@ -321,17 +352,20 @@ static enum tal_notify_type del_notifier_property(struct tal_hdr *t,
bool match_extra_arg, bool match_extra_arg,
void *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) { for (ptr = &t->prop; *ptr; ptr = &p->next) {
struct notifier *n; struct notifier *n;
enum tal_notify_type types; enum tal_notify_type types;
if (is_literal(*p)) p = is_prop_hdr(*ptr);
if (!p)
break; break;
if ((*p)->type != NOTIFIER)
if (p->type != NOTIFIER)
continue; continue;
n = (struct notifier *)*p; n = (struct notifier *)p;
if (n->u.notifyfn != fn) if (n->u.notifyfn != fn)
continue; continue;
@@ -341,8 +375,8 @@ static enum tal_notify_type del_notifier_property(struct tal_hdr *t,
&& extra_arg != EXTRA_ARG(n)) && extra_arg != EXTRA_ARG(n))
continue; continue;
*p = (*p)->next; *ptr = p->next;
freefn(n); freefn(p);
return types & ~(NOTIFY_IS_DESTRUCTOR|NOTIFY_EXTRA_ARG); return types & ~(NOTIFY_IS_DESTRUCTOR|NOTIFY_EXTRA_ARG);
} }
return 0; return 0;
@@ -388,7 +422,8 @@ static bool add_child(struct tal_hdr *parent, struct tal_hdr *child)
static void del_tree(struct tal_hdr *t, const tal_t *orig, int saved_errno) 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))); assert(!taken(from_tal_hdr(t)));
@@ -402,10 +437,10 @@ static void del_tree(struct tal_hdr *t, const tal_t *orig, int saved_errno)
notify(t, TAL_NOTIFY_FREE, (tal_t *)orig, saved_errno); notify(t, TAL_NOTIFY_FREE, (tal_t *)orig, saved_errno);
/* Now free children and groups. */ /* Now free children and groups. */
prop = find_property_ptr(t, CHILDREN); prop = find_property(t, CHILDREN);
if (prop) { if (prop) {
struct tal_hdr *i; 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))) { while ((i = list_top(&c->children, struct tal_hdr, list))) {
list_del(&i->list); list_del(&i->list);
@@ -414,9 +449,9 @@ static void del_tree(struct tal_hdr *t, const tal_t *orig, int saved_errno)
} }
/* Finally free our properties. */ /* Finally free our properties. */
for (p = t->prop; p && !is_literal(p); p = next) { for (ptr = t->prop; ptr && (prop = is_prop_hdr(ptr)); ptr = next) {
next = p->next; next = prop->next;
freefn(p); freefn(ptr);
} }
freefn(t); freefn(t);
} }
@@ -590,25 +625,34 @@ bool tal_del_destructor2_(const tal_t *ctx, void (*destroy)(void *me, void *arg)
bool tal_set_name_(tal_t *ctx, const char *name, bool literal) bool tal_set_name_(tal_t *ctx, const char *name, bool literal)
{ {
struct tal_hdr *t = debug_tal(to_tal_hdr(ctx)); 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 */ /* Get rid of any old name */
if (prop) { nptr = find_name_property(t, &was_literal);
struct name *oldname = (struct name *)*prop; if (nptr) {
if (is_literal(&oldname->hdr)) if (was_literal)
*prop = NULL; *nptr = NULL;
else { else {
*prop = oldname->hdr.next; struct name *oldname;
oldname = (struct name *)*nptr;
*nptr = oldname->hdr.next;
freefn(oldname); freefn(oldname);
} }
} }
if (literal && name[0]) { if (literal && name[0]) {
struct prop_hdr **p; char **ptr;
struct prop_hdr *prop;
/* Append literal. */ /* Append literal. */
for (p = &t->prop; *p && !is_literal(*p); p = &(*p)->next); for (ptr = &t->prop; *ptr; ptr = &prop->next) {
*p = (struct prop_hdr *)name; prop = is_prop_hdr(*ptr);
if (!prop)
break;
}
*ptr = (char *)name;
} else if (!add_name_property(t, name)) } else if (!add_name_property(t, name))
return false; return false;
@@ -620,15 +664,16 @@ bool tal_set_name_(tal_t *ctx, const char *name, bool literal)
const char *tal_name(const tal_t *t) 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); nptr = find_name_property(debug_tal(to_tal_hdr(t)), &literal);
if (!n) if (!nptr)
return NULL; return NULL;
if (literal)
return *nptr;
if (is_literal(&n->hdr)) return ((struct name *)(*nptr))->name;
return (const char *)n;
return n->name;
} }
size_t tal_bytelen(const tal_t *ptr) size_t tal_bytelen(const tal_t *ptr)
@@ -803,7 +848,7 @@ void *tal_dup_(const tal_t *ctx, const void *p, size_t size,
} }
ret = tal_alloc_arr_(ctx, size, n + extra, false, label); ret = tal_alloc_arr_(ctx, size, n + extra, false, label);
if (ret) if (ret && p)
memcpy(ret, p, nbytes); memcpy(ret, p, nbytes);
return ret; return ret;
} }
@@ -832,36 +877,38 @@ void tal_set_backend(void *(*alloc_fn)(size_t size),
static void dump_node(unsigned int indent, const struct tal_hdr *t) static void dump_node(unsigned int indent, const struct tal_hdr *t)
{ {
unsigned int i; unsigned int i;
const struct prop_hdr *p; const struct prop_hdr *prop;
const char *ptr;
for (i = 0; i < indent; i++) for (i = 0; i < indent; i++)
fprintf(stderr, " "); fprintf(stderr, " ");
fprintf(stderr, "%p len=%zu", t, t->bytelen); fprintf(stderr, "%p len=%zu", t, t->bytelen);
for (p = t->prop; p; p = p->next) { for (ptr = t->prop; ptr; ptr = prop->next) {
struct children *c; struct children *c;
struct name *n; struct name *n;
struct notifier *no; struct notifier *no;
if (is_literal(p)) { prop = is_prop_hdr(ptr);
fprintf(stderr, " \"%s\"", (const char *)p); if (!prop) {
fprintf(stderr, " \"%s\"", ptr);
break; break;
} }
switch (p->type) { switch (prop->type) {
case CHILDREN: case CHILDREN:
c = (struct children *)p; c = (struct children *)prop;
fprintf(stderr, " CHILDREN(%p):parent=%p,children={%p,%p}", fprintf(stderr, " CHILDREN(%p):parent=%p,children={%p,%p}",
p, c->parent, prop, c->parent,
c->children.n.prev, c->children.n.next); c->children.n.prev, c->children.n.next);
break; break;
case NAME: case NAME:
n = (struct name *)p; n = (struct name *)prop;
fprintf(stderr, " NAME(%p):%s", p, n->name); fprintf(stderr, " NAME(%p):%s", prop, n->name);
break; break;
case NOTIFIER: case NOTIFIER:
no = (struct notifier *)p; no = (struct notifier *)prop;
fprintf(stderr, " NOTIFIER(%p):fn=%p", p, no->u.notifyfn); fprintf(stderr, " NOTIFIER(%p):fn=%p", prop, no->u.notifyfn);
break; break;
default: default:
fprintf(stderr, " **UNKNOWN(%p):%i**", p, p->type); fprintf(stderr, " **UNKNOWN(%p):%i**", prop, prop->type);
} }
} }
fprintf(stderr, "\n"); fprintf(stderr, "\n");
@@ -873,7 +920,7 @@ static void tal_dump_(unsigned int level, const struct tal_hdr *t)
dump_node(level, t); dump_node(level, t);
children = find_property(t, CHILDREN); children = find_property((struct tal_hdr *)t, CHILDREN);
if (children) { if (children) {
struct tal_hdr *i; struct tal_hdr *i;
@@ -904,7 +951,8 @@ static bool check_err(struct tal_hdr *t, const char *errorstr,
static bool check_node(struct children *parent_child, static bool check_node(struct children *parent_child,
struct tal_hdr *t, const char *errorstr) struct tal_hdr *t, const char *errorstr)
{ {
struct prop_hdr *p; struct prop_hdr *prop;
char *p;
struct name *name = NULL; struct name *name = NULL;
struct children *children = NULL; struct children *children = NULL;
@@ -914,23 +962,24 @@ static bool check_node(struct children *parent_child,
if (ignore_destroying_bit(t->parent_child) != parent_child) if (ignore_destroying_bit(t->parent_child) != parent_child)
return check_err(t, errorstr, "incorrect parent"); return check_err(t, errorstr, "incorrect parent");
for (p = t->prop; p; p = p->next) { for (p = t->prop; p; p = prop->next) {
if (is_literal(p)) { prop = is_prop_hdr(p);
if (!prop) {
if (name) if (name)
return check_err(t, errorstr, return check_err(t, errorstr,
"has extra literal"); "has extra literal");
break; break;
} }
if (!in_bounds(p)) if (!in_bounds(prop))
return check_err(t, errorstr, return check_err(t, errorstr,
"has bad property pointer"); "has bad property pointer");
switch (p->type) { switch (prop->type) {
case CHILDREN: case CHILDREN:
if (children) if (children)
return check_err(t, errorstr, return check_err(t, errorstr,
"has two child nodes"); "has two child nodes");
children = (struct children *)p; children = (struct children *)prop;
break; break;
case NOTIFIER: case NOTIFIER:
break; break;
@@ -938,7 +987,7 @@ static bool check_node(struct children *parent_child,
if (name) if (name)
return check_err(t, errorstr, return check_err(t, errorstr,
"has two names"); "has two names");
name = (struct name *)p; name = (struct name *)prop;
break; break;
default: default:
return check_err(t, errorstr, "has unknown property"); return check_err(t, errorstr, "has unknown property");

4
ccan/ccan/tal/test/run-notifier.c
View File

@@ -13,8 +13,8 @@ static void *my_realloc(void *old, size_t size)
void *new = realloc(old, size); void *new = realloc(old, size);
if (new == old) { if (new == old) {
void *p = malloc(size); void *p = malloc(size);
memcpy(p, old, size); memcpy(p, new, size);
free(old); free(new);
new = p; new = p;
} }
return new; return new;

3
ccan/ccan/tcon/tcon.h
View File

@@ -147,7 +147,8 @@
* It evaluates to @x so you can chain it. * It evaluates to @x so you can chain it.
*/ */
#define tcon_check_ptr(x, canary, expr) \ #define tcon_check_ptr(x, canary, expr) \
(sizeof((expr) ? (expr) : &(x)->_tcon[0].canary) ? (x) : (x)) (sizeof(&(x)->_tcon[0].canary == (expr)) ? (x) : (x))
/** /**
* tcon_type - the type within a container (or void *) * tcon_type - the type within a container (or void *)

2
ccan/ccan/tcon/test/compile_fail-container1.c
View File

@@ -25,7 +25,7 @@ struct info_tcon {
int main(void) int main(void)
{ {
struct info_tcon info; struct info_tcon info;
struct outer ovar; struct outer ovar = { 0, { 0 } };
#ifdef FAIL #ifdef FAIL
#if !HAVE_TYPEOF #if !HAVE_TYPEOF
#error We cannot detect type problems without HAVE_TYPEOF #error We cannot detect type problems without HAVE_TYPEOF

2
ccan/ccan/tcon/test/compile_fail-container1w.c
View File

@@ -21,7 +21,7 @@ int main(void)
{ {
TCON_WRAP(struct info_base, TCON_WRAP(struct info_base,
TCON_CONTAINER(concan, struct outer, inner)) info; TCON_CONTAINER(concan, struct outer, inner)) info;
struct outer ovar; struct outer ovar = { 0, { 0 } };
#ifdef FAIL #ifdef FAIL
#if !HAVE_TYPEOF #if !HAVE_TYPEOF
#error We cannot detect type problems without HAVE_TYPEOF #error We cannot detect type problems without HAVE_TYPEOF

2
ccan/ccan/tcon/test/compile_fail-container3.c
View File

@@ -25,7 +25,7 @@ struct info_tcon {
int main(void) int main(void)
{ {
struct info_tcon info; struct info_tcon info;
struct outer ovar; struct outer ovar = { 0, { 0 } };
#ifdef FAIL #ifdef FAIL
#if !HAVE_TYPEOF #if !HAVE_TYPEOF
#error We cannot detect type problems without HAVE_TYPEOF #error We cannot detect type problems without HAVE_TYPEOF

2
ccan/ccan/tcon/test/compile_fail-container3w.c
View File

@@ -21,7 +21,7 @@ int main(void)
{ {
TCON_WRAP(struct info_base, TCON_WRAP(struct info_base,
TCON_CONTAINER(concan, struct outer, inner)) info; TCON_CONTAINER(concan, struct outer, inner)) info;
struct outer ovar; struct outer ovar = { 0, { 0 } };
#ifdef FAIL #ifdef FAIL
#if !HAVE_TYPEOF #if !HAVE_TYPEOF
#error We cannot detect type problems without HAVE_TYPEOF #error We cannot detect type problems without HAVE_TYPEOF

2
ccan/tools/configurator/configurator.c
View File

@@ -197,7 +197,7 @@ static const struct test base_tests[] = {
"return __builtin_clzll(1) == (sizeof(long long)*8 - 1) ? 0 : 1;" }, "return __builtin_clzll(1) == (sizeof(long long)*8 - 1) ? 0 : 1;" },
{ "HAVE_BUILTIN_CTZ", "__builtin_ctz support", { "HAVE_BUILTIN_CTZ", "__builtin_ctz support",
"INSIDE_MAIN", NULL, NULL, "INSIDE_MAIN", NULL, NULL,
"return __builtin_ctz(1 << (sizeof(int)*8 - 1)) == (sizeof(int)*8 - 1) ? 0 : 1;" }, "return __builtin_ctz(1U << (sizeof(int)*8 - 1)) == (sizeof(int)*8 - 1) ? 0 : 1;" },
{ "HAVE_BUILTIN_CTZL", "__builtin_ctzl support", { "HAVE_BUILTIN_CTZL", "__builtin_ctzl support",
"INSIDE_MAIN", NULL, NULL, "INSIDE_MAIN", NULL, NULL,
"return __builtin_ctzl(1UL << (sizeof(long)*8 - 1)) == (sizeof(long)*8 - 1) ? 0 : 1;" }, "return __builtin_ctzl(1UL << (sizeof(long)*8 - 1)) == (sizeof(long)*8 - 1) ? 0 : 1;" },