From f45c17450b967b0121b7f237308604e5efd5c5a3 Mon Sep 17 00:00:00 2001
From: Rusty Russell <rusty@rustcorp.com.au>
Date: Thu, 1 Jun 2023 13:46:21 +0930
Subject: [PATCH] ccan: update to latest ccan/opt

This adds:
1. ability to search for an option by name.
2. allowance to set our own bits when registering options.
3. show callbacks which can say "don't show", and variable length.

Signed-off-by: Rusty Russell <rusty@rustcorp.com.au>
---
 ccan/README                                |   2 +-
 ccan/ccan/opt/helpers.c                    | 145 +++++++++++---------
 ccan/ccan/opt/opt.c                        |  17 +--
 ccan/ccan/opt/opt.h                        |  92 ++++++++-----
 ccan/ccan/opt/parse.c                      |  92 +++++++++----
 ccan/ccan/opt/test/run-add_desc.c          |  23 +++-
 ccan/ccan/opt/test/run-correct-reporting.c |   6 +-
 ccan/ccan/opt/test/run-helpers.c           | 150 ++++++++++-----------
 ccan/ccan/opt/test/run-userbits.c          |  59 ++++++++
 ccan/ccan/opt/test/utils.c                 |   5 +-
 ccan/ccan/opt/test/utils.h                 |   2 +-
 ccan/ccan/opt/usage.c                      |  33 ++---
 ccan/ccan/tcon/tcon.h                      |   3 +-
 cli/lightning-cli.c                        |   7 +-
 common/configdir.c                         |   5 +-
 devtools/gossipwith.c                      |   9 +-
 devtools/onion.c                           |   4 +-
 lightningd/log.c                           |  12 +-
 lightningd/options.c                       |  44 +++---
 lightningd/options.h                       |   2 +-
 tests/test_misc.py                         |   2 +-
 21 files changed, 449 insertions(+), 265 deletions(-)
 create mode 100644 ccan/ccan/opt/test/run-userbits.c

diff --git a/ccan/README b/ccan/README
index 24ee7eb0c..7f367f1cf 100644
--- a/ccan/README
+++ b/ccan/README
@@ -1,3 +1,3 @@
 CCAN imported from http://ccodearchive.net.
 
-CCAN version: init-2565-g3942778b
+CCAN version: init-2573-g882a1ac0
diff --git a/ccan/ccan/opt/helpers.c b/ccan/ccan/opt/helpers.c
index 118e54360..df7ee6bb1 100644
--- a/ccan/ccan/opt/helpers.c
+++ b/ccan/ccan/opt/helpers.c
@@ -138,10 +138,11 @@ char *opt_set_floatval(const char *arg, float *f)
 	return NULL;
 }
 
-void opt_show_floatval(char buf[OPT_SHOW_LEN], const float *f)
+bool opt_show_floatval(char *buf, size_t len, const float *f)
 {
 	double d = *f;
-	opt_show_doubleval(buf, &d);
+	opt_show_doubleval(buf, len, &d);
+	return true;
 }
 
 char *opt_set_doubleval(const char *arg, double *d)
@@ -160,9 +161,10 @@ char *opt_set_doubleval(const char *arg, double *d)
 	return NULL;
 }
 
-void opt_show_doubleval(char buf[OPT_SHOW_LEN], const double *d)
+bool opt_show_doubleval(char *buf, size_t len, const double *d)
 {
-	snprintf(buf, OPT_SHOW_LEN, "%f", *d);
+	snprintf(buf, len, "%f", *d);
+	return true;
 }
 
 char *opt_inc_intval(int *i)
@@ -196,52 +198,60 @@ char *opt_usage_and_exit(const char *extra)
 	exit(0);
 }
 
-void opt_show_bool(char buf[OPT_SHOW_LEN], const bool *b)
+bool opt_show_bool(char *buf, size_t len, const bool *b)
 {
-	strncpy(buf, *b ? "true" : "false", OPT_SHOW_LEN);
+	strncpy(buf, *b ? "true" : "false", len);
+	return true;
 }
 
-void opt_show_invbool(char buf[OPT_SHOW_LEN], const bool *b)
+bool opt_show_invbool(char *buf, size_t len, const bool *b)
 {
-	strncpy(buf, *b ? "false" : "true", OPT_SHOW_LEN);
+	strncpy(buf, *b ? "false" : "true", len);
+	return true;
 }
 
-void opt_show_charp(char buf[OPT_SHOW_LEN], char *const *p)
+bool opt_show_charp(char *buf, size_t len, char *const *p)
 {
-	if (*p){
-		size_t len = strlen(*p);
+	if (*p) {
+		size_t plen = strlen(*p);
+		if (len < 2)
+			return false;
 		buf[0] = '"';
-		if (len > OPT_SHOW_LEN - 2)
-			len = OPT_SHOW_LEN - 2;
-		strncpy(buf+1, *p, len);
-		buf[1+len] = '"';
-		if (len < OPT_SHOW_LEN - 2)
-			buf[2+len] = '\0';
-	}
-	else {
-		strncpy(buf, "(nil)", OPT_SHOW_LEN);
+		if (plen > len - 2)
+			plen = len - 2;
+		strncpy(buf+1, *p, plen);
+		buf[1+plen] = '"';
+		if (plen < len - 2)
+			buf[2+plen] = '\0';
+		return true;
+	} else {
+		return false;
 	}
 }
 
 /* Show an integer value, various forms. */
-void opt_show_intval(char buf[OPT_SHOW_LEN], const int *i)
+bool opt_show_intval(char *buf, size_t len, const int *i)
 {
-	snprintf(buf, OPT_SHOW_LEN, "%i", *i);
+	snprintf(buf, len, "%i", *i);
+	return true;
 }
 
-void opt_show_uintval(char buf[OPT_SHOW_LEN], const unsigned int *ui)
+bool opt_show_uintval(char *buf, size_t len, const unsigned int *ui)
 {
-	snprintf(buf, OPT_SHOW_LEN, "%u", *ui);
+	snprintf(buf, len, "%u", *ui);
+	return true;
 }
 
-void opt_show_longval(char buf[OPT_SHOW_LEN], const long *l)
+bool opt_show_longval(char *buf, size_t len, const long *l)
 {
-	snprintf(buf, OPT_SHOW_LEN, "%li", *l);
+	snprintf(buf, len, "%li", *l);
+	return true;
 }
 
-void opt_show_ulongval(char buf[OPT_SHOW_LEN], const unsigned long *ul)
+bool opt_show_ulongval(char *buf, size_t len, const unsigned long *ul)
 {
-	snprintf(buf, OPT_SHOW_LEN, "%lu", *ul);
+	snprintf(buf, len, "%lu", *ul);
+	return true;
 }
 
 /* a helper function that multiplies out an argument's kMGTPE suffix in the
@@ -447,14 +457,14 @@ char * opt_set_uintval_si(const char *arg, unsigned int *u)
   are separate but essentially identical functions for signed and unsigned
   values, so that unsigned values greater than LLONG_MAX get suffixes.
  */
-static void show_llong_with_suffix(char buf[OPT_SHOW_LEN], long long ll,
-				    const long long base)
+static void show_llong_with_suffix(char *buf, size_t len, long long ll,
+				   const long long base)
 {
 	const char *suffixes = "kMGTPE";
 	int i;
 	if (ll == 0){
 		/*zero is special because everything divides it (you'd get "0E")*/
-		snprintf(buf, OPT_SHOW_LEN, "0");
+		snprintf(buf, len, "0");
 		return;
 	}
 	for (i = 0; i < strlen(suffixes); i++){
@@ -464,19 +474,20 @@ static void show_llong_with_suffix(char buf[OPT_SHOW_LEN], long long ll,
 		ll = tmp;
 	}
 	if (i == 0)
-		snprintf(buf, OPT_SHOW_LEN, "%"PRId64, (int64_t)ll);
+		snprintf(buf, len, "%"PRId64, (int64_t)ll);
 	else
-		snprintf(buf, OPT_SHOW_LEN, "%"PRId64"%c", (int64_t)ll, suffixes[i - 1]);
+		snprintf(buf, len, "%"PRId64"%c", (int64_t)ll, suffixes[i - 1]);
 }
 
-static void show_ullong_with_suffix(char buf[OPT_SHOW_LEN], unsigned long long ull,
+static void show_ullong_with_suffix(char *buf, size_t len,
+				    unsigned long long ull,
 				    const unsigned base)
 {
 	const char *suffixes = "kMGTPE";
 	int i;
 	if (ull == 0){
 		/*zero is special because everything divides it (you'd get "0E")*/
-		snprintf(buf, OPT_SHOW_LEN, "0");
+		snprintf(buf, len, "0");
 		return;
 	}
 	for (i = 0; i < strlen(suffixes); i++){
@@ -486,72 +497,84 @@ static void show_ullong_with_suffix(char buf[OPT_SHOW_LEN], unsigned long long u
 		ull = tmp;
 	}
 	if (i == 0)
-		snprintf(buf, OPT_SHOW_LEN, "%"PRIu64, (uint64_t)ull);
+		snprintf(buf, len, "%"PRIu64, (uint64_t)ull);
 	else
-		snprintf(buf, OPT_SHOW_LEN, "%"PRIu64"%c", (uint64_t)ull, suffixes[i - 1]);
+		snprintf(buf, len, "%"PRIu64"%c", (uint64_t)ull, suffixes[i - 1]);
 }
 
 /* _bi, signed */
-void opt_show_intval_bi(char buf[OPT_SHOW_LEN], const int *x)
+bool opt_show_intval_bi(char *buf, size_t len, const int *x)
 {
-	show_llong_with_suffix(buf, *x, 1024);
+	show_llong_with_suffix(buf, len, *x, 1024);
+	return true;
 }
 
-void opt_show_longval_bi(char buf[OPT_SHOW_LEN], const long *x)
+bool opt_show_longval_bi(char *buf, size_t len, const long *x)
 {
-	show_llong_with_suffix(buf, *x, 1024);
+	show_llong_with_suffix(buf, len, *x, 1024);
+	return true;
 }
 
-void opt_show_longlongval_bi(char buf[OPT_SHOW_LEN], const long long *x)
+bool opt_show_longlongval_bi(char *buf, size_t len, const long long *x)
 {
-	show_llong_with_suffix(buf, *x, 1024);
+	show_llong_with_suffix(buf, len, *x, 1024);
+	return true;
 }
 
 /* _bi, unsigned */
-void opt_show_uintval_bi(char buf[OPT_SHOW_LEN], const unsigned int *x)
+bool opt_show_uintval_bi(char *buf, size_t len, const unsigned int *x)
 {
-	show_ullong_with_suffix(buf, (unsigned long long) *x, 1024);
+	show_ullong_with_suffix(buf, len, (unsigned long long) *x, 1024);
+	return true;
 }
 
-void opt_show_ulongval_bi(char buf[OPT_SHOW_LEN], const unsigned long *x)
+bool opt_show_ulongval_bi(char *buf, size_t len, const unsigned long *x)
 {
-	show_ullong_with_suffix(buf, (unsigned long long) *x, 1024);
+	show_ullong_with_suffix(buf, len, (unsigned long long) *x, 1024);
+	return true;
 }
 
-void opt_show_ulonglongval_bi(char buf[OPT_SHOW_LEN], const unsigned long long *x)
+bool opt_show_ulonglongval_bi(char *buf, size_t len, const unsigned long long *x)
 {
-	show_ullong_with_suffix(buf, (unsigned long long) *x, 1024);
+	show_ullong_with_suffix(buf, len, (unsigned long long) *x, 1024);
+	return true;
 }
 
 /* _si, signed */
-void opt_show_intval_si(char buf[OPT_SHOW_LEN], const int *x)
+bool opt_show_intval_si(char *buf, size_t len, const int *x)
 {
-	show_llong_with_suffix(buf, (long long) *x, 1000);
+	show_llong_with_suffix(buf, len, (long long) *x, 1000);
+	return true;
 }
 
-void opt_show_longval_si(char buf[OPT_SHOW_LEN], const long *x)
+bool opt_show_longval_si(char *buf, size_t len, const long *x)
 {
-	show_llong_with_suffix(buf, (long long) *x, 1000);
+	show_llong_with_suffix(buf, len, (long long) *x, 1000);
+	return true;
 }
 
-void opt_show_longlongval_si(char buf[OPT_SHOW_LEN], const long long *x)
+bool opt_show_longlongval_si(char *buf, size_t len, const long long *x)
 {
-	show_llong_with_suffix(buf, *x, 1000);
+	show_llong_with_suffix(buf, len, *x, 1000);
+	return true;
 }
 
 /* _si, unsigned */
-void opt_show_uintval_si(char buf[OPT_SHOW_LEN], const unsigned int *x)
+bool opt_show_uintval_si(char *buf, size_t len, const unsigned int *x)
 {
-	show_ullong_with_suffix(buf, (unsigned long long) *x, 1000);
+	show_ullong_with_suffix(buf, len, (unsigned long long) *x, 1000);
+	return true;
 }
 
-void opt_show_ulongval_si(char buf[OPT_SHOW_LEN], const unsigned long *x)
+bool opt_show_ulongval_si(char *buf, size_t len, const unsigned long *x)
 {
-	show_ullong_with_suffix(buf, (unsigned long long) *x, 1000);
+	show_ullong_with_suffix(buf, len, (unsigned long long) *x, 1000);
+	return true;
 }
 
-void opt_show_ulonglongval_si(char buf[OPT_SHOW_LEN], const unsigned long long *x)
+bool opt_show_ulonglongval_si(char *buf, size_t len, const unsigned long long *x)
 {
-	show_ullong_with_suffix(buf, (unsigned long long) *x, 1000);
+	show_ullong_with_suffix(buf, len, (unsigned long long) *x, 1000);
+	return true;
 }
 
diff --git a/ccan/ccan/opt/opt.c b/ccan/ccan/opt/opt.c
index d376a598d..9149374cb 100644
--- a/ccan/ccan/opt/opt.c
+++ b/ccan/ccan/opt/opt.c
@@ -34,7 +34,7 @@ static const char *next_name(const char *names, unsigned *len)
 static const char *first_opt(unsigned *i, unsigned *len)
 {
 	for (*i = 0; *i < opt_count; (*i)++) {
-		if (opt_table[*i].type == OPT_SUBTABLE)
+		if (opt_table[*i].type & OPT_SUBTABLE)
 			continue;
 		return first_name(opt_table[*i].names, len);
 	}
@@ -44,7 +44,7 @@ static const char *first_opt(unsigned *i, unsigned *len)
 static const char *next_opt(const char *p, unsigned *i, unsigned *len)
 {
 	for (; *i < opt_count; (*i)++) {
-		if (opt_table[*i].type == OPT_SUBTABLE)
+		if (opt_table[*i].type & OPT_SUBTABLE)
 			continue;
 		if (!p)
 			return first_name(opt_table[*i].names, len);
@@ -114,10 +114,11 @@ static void check_opt(const struct opt_table *entry)
 {
 	const char *p;
 	unsigned len;
+	enum opt_type type = entry->type & (OPT_USER_MIN-1);
 
-	if (entry->type != OPT_HASARG && entry->type != OPT_NOARG
-	    && entry->type != (OPT_EARLY|OPT_HASARG)
-	    && entry->type != (OPT_EARLY|OPT_NOARG))
+	if (type != OPT_HASARG && type != OPT_NOARG
+	    && type != (OPT_EARLY|OPT_HASARG)
+	    && type != (OPT_EARLY|OPT_NOARG))
 		failmsg("Option %s: unknown entry type %u",
 			entry->names, entry->type);
 
@@ -161,7 +162,7 @@ static void add_opt(const struct opt_table *entry)
 void _opt_register(const char *names, enum opt_type type,
 		   char *(*cb)(void *arg),
 		   char *(*cb_arg)(const char *optarg, void *arg),
-		   void (*show)(char buf[OPT_SHOW_LEN], const void *arg),
+		   bool (*show)(char *buf, size_t len, const void *arg),
 		   const void *arg, const char *desc)
 {
 	struct opt_table opt;
@@ -181,7 +182,7 @@ bool opt_unregister(const char *names)
 	int found = -1, i;
 
 	for (i = 0; i < opt_count; i++) {
-		if (opt_table[i].type == OPT_SUBTABLE)
+		if (opt_table[i].type & OPT_SUBTABLE)
 			continue;
 		if (strcmp(opt_table[i].names, names) == 0)
 			found = i;
@@ -203,7 +204,7 @@ void opt_register_table(const struct opt_table entry[], const char *desc)
 		add_opt(&heading);
 	}
 	for (i = 0; entry[i].type != OPT_END; i++) {
-		if (entry[i].type == OPT_SUBTABLE)
+		if (entry[i].type & OPT_SUBTABLE)
 			opt_register_table(subtable_of(&entry[i]),
 					   entry[i].desc);
 		else {
diff --git a/ccan/ccan/opt/opt.h b/ccan/ccan/opt/opt.h
index 6f4b9dda8..e0331be26 100644
--- a/ccan/ccan/opt/opt.h
+++ b/ccan/ccan/opt/opt.h
@@ -47,10 +47,11 @@ struct opt_table;
  * where "type" is the type of the @arg argument.  The first argument to the
  * @cb is the argument found on the commandline.
  *
- * Similarly, if @show is not NULL, it should be of type "void *show(char *,
- * const type *)".  It should write up to OPT_SHOW_LEN bytes into the first
- * argument; unless it uses the entire OPT_SHOW_LEN bytes it should
- * nul-terminate that buffer.
+ * Similarly, if @show is not NULL, it should be of type "bool show(char *,
+ * size_t len, const type *)".  If there is no default, it should return false,
+ * otherwise it should write up to len bytes into the first argument and
+ * return true; unless it uses the entire len bytes it should nul-terminate that
+ * buffer.
  *
  * Any number of equivalent short or long options can be listed in @names,
  * separated by '|'.  Short options are a single hyphen followed by a single
@@ -429,40 +430,38 @@ void opt_usage_exit_fail(const char *msg, ...) NORETURN;
  */
 extern const char opt_hidden[];
 
-/* Maximum length of arg to show in opt_usage */
-#define OPT_SHOW_LEN 80
-
 /* Standard helpers.  You can write your own: */
 /* Sets the @b to true. */
 char *opt_set_bool(bool *b);
 /* Sets @b based on arg: (yes/no/true/false). */
 char *opt_set_bool_arg(const char *arg, bool *b);
-void opt_show_bool(char buf[OPT_SHOW_LEN], const bool *b);
+bool opt_show_bool(char *buf, size_t len, const bool *b);
 /* The inverse */
 char *opt_set_invbool(bool *b);
-void opt_show_invbool(char buf[OPT_SHOW_LEN], const bool *b);
+bool opt_show_invbool(char *buf, size_t len, const bool *b);
 /* Sets @b based on !arg: (yes/no/true/false). */
 char *opt_set_invbool_arg(const char *arg, bool *b);
 
 /* Set a char *. */
 char *opt_set_charp(const char *arg, char **p);
-void opt_show_charp(char buf[OPT_SHOW_LEN], char *const *p);
+/* If *p is NULL, this returns false (i.e. doesn't show a default) */
+bool opt_show_charp(char *buf, size_t len, char *const *p);
 
 /* Set an integer value, various forms.  Sets to 1 on arg == NULL. */
 char *opt_set_intval(const char *arg, int *i);
-void opt_show_intval(char buf[OPT_SHOW_LEN], const int *i);
+bool opt_show_intval(char *buf, size_t len, const int *i);
 char *opt_set_uintval(const char *arg, unsigned int *ui);
-void opt_show_uintval(char buf[OPT_SHOW_LEN], const unsigned int *ui);
+bool opt_show_uintval(char *buf, size_t len, const unsigned int *ui);
 char *opt_set_longval(const char *arg, long *l);
-void opt_show_longval(char buf[OPT_SHOW_LEN], const long *l);
+bool opt_show_longval(char *buf, size_t len, const long *l);
 char *opt_set_ulongval(const char *arg, unsigned long *ul);
-void opt_show_ulongval(char buf[OPT_SHOW_LEN], const unsigned long *ul);
+bool opt_show_ulongval(char *buf, size_t len, const unsigned long *ul);
 
 /* Set an floating point value, various forms. */
 char *opt_set_floatval(const char *arg, float *f);
-void opt_show_floatval(char buf[OPT_SHOW_LEN], const float *f);
+bool opt_show_floatval(char *buf, size_t len, const float *f);
 char *opt_set_doubleval(const char *arg, double *d);
-void opt_show_doubleval(char buf[OPT_SHOW_LEN], const double *d);
+bool opt_show_doubleval(char *buf, size_t len, const double *d);
 
 /* the following setting functions accept k, M, G, T, P, or E suffixes, which
    multiplies the numeric value by the corresponding power of 1000 or 1024
@@ -482,19 +481,19 @@ char *opt_set_ulonglongval_bi(const char *arg, unsigned long long *ll);
 char *opt_set_ulonglongval_si(const char *arg, unsigned long long *ll);
 
 
-void opt_show_intval_bi(char buf[OPT_SHOW_LEN], const int *x);
-void opt_show_longval_bi(char buf[OPT_SHOW_LEN], const long *x);
-void opt_show_longlongval_bi(char buf[OPT_SHOW_LEN], const long long *x);
-void opt_show_uintval_bi(char buf[OPT_SHOW_LEN], const unsigned int *x);
-void opt_show_ulongval_bi(char buf[OPT_SHOW_LEN], const unsigned long *x);
-void opt_show_ulonglongval_bi(char buf[OPT_SHOW_LEN], const unsigned long long *x);
+bool opt_show_intval_bi(char *buf, size_t len, const int *x);
+bool opt_show_longval_bi(char *buf, size_t len, const long *x);
+bool opt_show_longlongval_bi(char *buf, size_t len, const long long *x);
+bool opt_show_uintval_bi(char *buf, size_t len, const unsigned int *x);
+bool opt_show_ulongval_bi(char *buf, size_t len, const unsigned long *x);
+bool opt_show_ulonglongval_bi(char *buf, size_t len, const unsigned long long *x);
 
-void opt_show_intval_si(char buf[OPT_SHOW_LEN], const int *x);
-void opt_show_longval_si(char buf[OPT_SHOW_LEN], const long *x);
-void opt_show_longlongval_si(char buf[OPT_SHOW_LEN], const long long *x);
-void opt_show_uintval_si(char buf[OPT_SHOW_LEN], const unsigned int *x);
-void opt_show_ulongval_si(char buf[OPT_SHOW_LEN], const unsigned long *x);
-void opt_show_ulonglongval_si(char buf[OPT_SHOW_LEN], const unsigned long long *x);
+bool opt_show_intval_si(char *buf, size_t len, const int *x);
+bool opt_show_longval_si(char *buf, size_t len, const long *x);
+bool opt_show_longlongval_si(char *buf, size_t len, const long long *x);
+bool opt_show_uintval_si(char *buf, size_t len, const unsigned int *x);
+bool opt_show_ulongval_si(char *buf, size_t len, const unsigned long *x);
+bool opt_show_ulonglongval_si(char *buf, size_t len, const unsigned long long *x);
 
 
 
@@ -509,6 +508,30 @@ char *opt_version_and_exit(const char *version);
 /* Display usage string to stdout, exit(0). */
 char *opt_usage_and_exit(const char *extra);
 
+/**
+ * opt_find_long: low-level access to the parser
+ * @arg: string of form 'arg' or 'arg=val'.
+ * @optarg: set to `val` of present in arg, otherwise NULL.  Can be NULL.
+ *
+ * Returns NULL if option is unknown.  Sets *@optarg to NULL if
+ * there's no '='.
+ */
+struct opt_table *opt_find_long(const char *arg, const char **optarg);
+
+/**
+ * opt_find_short: low-level access to the parser
+ * @arg: character representing short option
+ *
+ * Returns NULL if option is unknown.
+ */
+struct opt_table *opt_find_short(char arg);
+
+/* opt_type bits reserved for users to play with (ignored!).
+ * You can set bits in type e.g. (1<<OPT_USER_START) to (1<<OPT_USER_END)
+ * when calling _opt_register. */
+#define OPT_USER_START 8
+#define OPT_USER_END 15
+
 /* Below here are private declarations. */
 /* You can use this directly to build tables, but the macros will ensure
  * consistency and type safety. */
@@ -518,6 +541,11 @@ enum opt_type {
 	OPT_SUBTABLE = 4,	/* Actually, longopt points to a subtable... */
 	OPT_EARLY = 8,		/* Parse this from opt_early_parse() only. */
 	OPT_END = 16,		/* End of the table. */
+
+	/* Make sure no compiler will assume we never have large
+	 * values in the enum! */
+	OPT_USER_MIN = (1 << OPT_USER_START),
+	OPT_USER_MAX = (1 << OPT_USER_END),
 };
 
 struct opt_table {
@@ -525,7 +553,7 @@ struct opt_table {
 	enum opt_type type;
 	char *(*cb)(void *arg); /* OPT_NOARG */
 	char *(*cb_arg)(const char *optarg, void *arg); /* OPT_HASARG */
-	void (*show)(char buf[OPT_SHOW_LEN], const void *arg);
+	bool (*show)(char *buf, size_t len, const void *arg);
 	union {
 		const void *carg;
 		void *arg;
@@ -551,14 +579,14 @@ struct opt_table {
 			  char *(*)(const char *, const typeof(*(arg))*), \
 			  char *(*)(const char *, const void *),	\
 			  (cb)),					\
-	typesafe_cb_cast(void (*)(char buf[], const void *),		\
-			 void (*)(char buf[], const typeof(*(arg))*), (show))
+	typesafe_cb_cast(bool (*)(char *buf, size_t, const void *), \
+			 bool (*)(char *buf, size_t, const typeof(*(arg))*), (show))
 
 /* Non-typesafe register function. */
 void _opt_register(const char *names, enum opt_type type,
 		   char *(*cb)(void *arg),
 		   char *(*cb_arg)(const char *optarg, void *arg),
-		   void (*show)(char buf[OPT_SHOW_LEN], const void *arg),
+		   bool (*show)(char *buf, size_t len, const void *arg),
 		   const void *arg, const char *desc);
 
 /* We use this to get typechecking for OPT_SUBTABLE */
diff --git a/ccan/ccan/opt/parse.c b/ccan/ccan/opt/parse.c
index d227f7bca..b932bf333 100644
--- a/ccan/ccan/opt/parse.c
+++ b/ccan/ccan/opt/parse.c
@@ -14,7 +14,8 @@
 /tmp/opt-example: option requires an argument -- 's'
 */
 static int parse_err(void (*errlog)(const char *fmt, ...),
-		     const char *argv0, const char *arg, unsigned len,
+		     const char *argv0,
+		     const char *arg, unsigned len,
 		     const char *problem)
 {
 	errlog("%s: %.*s: %s", argv0, len, arg, problem);
@@ -28,13 +29,63 @@ static void consume_option(int *argc, char *argv[], unsigned optnum)
 	(*argc)--;
 }
 
+/* This sets the len and o to indicate how far it is into the
+ * opt_table's names field. */
+static struct opt_table *opt_find_long_extra(const char *arg,
+					     const char **optarg,
+					     unsigned int *len,
+					     const char **o)
+{
+	unsigned i;
+
+	*optarg = NULL;
+	for (*o = first_lopt(&i, len);
+	     *o;
+	     *o = next_lopt(*o, &i, len)) {
+		if (strncmp(arg, *o, *len) != 0)
+			continue;
+		if (arg[*len] == '=')
+			*optarg = arg + *len + 1;
+		else if (arg[*len] != '\0')
+			continue;
+		return &opt_table[i];
+
+	}
+	return NULL;
+}
+
+struct opt_table *opt_find_long(const char *arg, const char **optarg)
+{
+	unsigned len;
+	const char *o;
+
+	return opt_find_long_extra(arg, optarg ? optarg : &o, &len, &o);
+}
+
+static struct opt_table *opt_find_short_extra(char arg, const char **o)
+{
+	unsigned i;
+	for (*o = first_sopt(&i); *o; *o = next_sopt(*o, &i)) {
+		if (arg == **o)
+			return &opt_table[i];
+	}
+	return NULL;
+}
+
+struct opt_table *opt_find_short(char arg)
+{
+	const char *o;
+	return opt_find_short_extra(arg, &o);
+}
+
 /* Returns 1 if argument consumed, 0 if all done, -1 on error. */
 int parse_one(int *argc, char *argv[], enum opt_type is_early, unsigned *offset,
 	      void (*errlog)(const char *fmt, ...), bool unknown_ok)
 {
-	unsigned i, arg, len;
+	unsigned arg, len;
 	const char *o, *optarg = NULL;
 	char *problem = NULL;
+	struct opt_table *ot;
 
 	if (getenv("POSIXLY_CORRECT")) {
 		/* Don't find options after non-options. */
@@ -58,34 +109,22 @@ int parse_one(int *argc, char *argv[], enum opt_type is_early, unsigned *offset,
 	/* Long options start with -- */
 	if (argv[arg][1] == '-') {
 		assert(*offset == 0);
-		for (o = first_lopt(&i, &len); o; o = next_lopt(o, &i, &len)) {
-			if (strncmp(argv[arg] + 2, o, len) != 0)
-				continue;
-			if (argv[arg][2 + len] == '=')
-				optarg = argv[arg] + 2 + len + 1;
-			else if (argv[arg][2 + len] != '\0')
-				continue;
-			break;
-		}
-		if (!o) {
+
+		ot = opt_find_long_extra(argv[arg]+2, &optarg, &len, &o);
+		if (!ot) {
 			if (unknown_ok)
 				goto ok;
 			return parse_err(errlog, argv[0],
 					 argv[arg], strlen(argv[arg]),
 					 "unrecognized option");
 		}
+
 		/* For error messages, we include the leading '--' */
 		o -= 2;
 		len += 2;
 	} else {
-		/* offset allows us to handle -abc */
-		for (o = first_sopt(&i); o; o = next_sopt(o, &i)) {
-			if (argv[arg][*offset + 1] != *o)
-				continue;
-			(*offset)++;
-			break;
-		}
-		if (!o) {
+		ot = opt_find_short_extra(argv[arg][*offset + 1], &o);
+		if (!ot) {
 			if (unknown_ok) {
 				(*offset)++;
 				goto ok;
@@ -94,17 +133,19 @@ int parse_one(int *argc, char *argv[], enum opt_type is_early, unsigned *offset,
 					 argv[arg], strlen(argv[arg]),
 					 "unrecognized option");
 		}
+
+		(*offset)++;
 		/* For error messages, we include the leading '-' */
 		o--;
 		len = 2;
 	}
 
-	if ((opt_table[i].type & ~OPT_EARLY) == OPT_NOARG) {
+	if (ot->type & OPT_NOARG) {
 		if (optarg)
 			return parse_err(errlog, argv[0], o, len,
 					 "doesn't allow an argument");
-		if ((opt_table[i].type & OPT_EARLY) == is_early)
-			problem = opt_table[i].cb(opt_table[i].u.arg);
+		if ((ot->type & OPT_EARLY) == is_early)
+			problem = ot->cb(ot->u.arg);
 	} else {
 		if (!optarg) {
 			/* Swallow any short options as optarg, eg -afile */
@@ -117,9 +158,8 @@ int parse_one(int *argc, char *argv[], enum opt_type is_early, unsigned *offset,
 		if (!optarg)
 			return parse_err(errlog, argv[0], o, len,
 					 "requires an argument");
-		if ((opt_table[i].type & OPT_EARLY) == is_early)
-			problem = opt_table[i].cb_arg(optarg,
-						      opt_table[i].u.arg);
+		if ((ot->type & OPT_EARLY) == is_early)
+			problem = ot->cb_arg(optarg, ot->u.arg);
 	}
 
 	if (problem) {
diff --git a/ccan/ccan/opt/test/run-add_desc.c b/ccan/ccan/opt/test/run-add_desc.c
index b559c7f74..03e6986dd 100644
--- a/ccan/ccan/opt/test/run-add_desc.c
+++ b/ccan/ccan/opt/test/run-add_desc.c
@@ -4,15 +4,24 @@
 #include <ccan/opt/helpers.c>
 #include <ccan/opt/parse.c>
 
-static void show_10(char buf[OPT_SHOW_LEN], const void *arg UNNEEDED)
+static bool show_10(char *buf, size_t len, const void *arg UNNEEDED)
 {
 	memset(buf, 'X', 10);
 	buf[10] = '\0';
+	return true;
 }
 
-static void show_max(char buf[OPT_SHOW_LEN], const void *arg UNNEEDED)
+static bool show_10_false(char *buf, size_t len, const void *arg UNNEEDED)
+{
+	memset(buf, 'X', 10);
+	buf[10] = '\0';
+	return false;
+}
+
+static bool show_max(char *buf, size_t len, const void *arg UNNEEDED)
 {
 	memset(buf, 'X', OPT_SHOW_LEN);
+	return true;
 }
 
 /* Test add_desc helper. */
@@ -22,7 +31,7 @@ int main(void)
 	char *ret;
 	size_t len, max;
 
-	plan_tests(30);
+	plan_tests(32);
 
 	opt.show = NULL;
 	opt.names = "01234";
@@ -113,6 +122,14 @@ int main(void)
 		   "        (default: XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX...)\n") == 0);
 	free(ret); len = max = 0;
 
+	/* With show function which fails doesn't print. */
+	opt.show = show_10_false;
+	ret = add_desc(NULL, &len, &max, 7, 41, &opt);
+	ok1(len < max);
+	ret[len] = '\0';
+	ok1(strcmp(ret, "01234  0123456789 0\n") == 0);
+	free(ret); len = max = 0;
+
 	/* With added " <arg>".  Fits, just. */
 	opt.show = NULL;
 	opt.type = OPT_HASARG;
diff --git a/ccan/ccan/opt/test/run-correct-reporting.c b/ccan/ccan/opt/test/run-correct-reporting.c
index 8534f291a..0c4f6c869 100644
--- a/ccan/ccan/opt/test/run-correct-reporting.c
+++ b/ccan/ccan/opt/test/run-correct-reporting.c
@@ -10,7 +10,7 @@
 
 int main(int argc, char *argv[])
 {
-	plan_tests(12);
+	plan_tests(14);
 
 	/* --aaa without args. */
 	opt_register_arg("-a|--aaa", test_arg, NULL, "aaa", "");
@@ -42,6 +42,10 @@ int main(int argc, char *argv[])
 	free(err_output);
 	err_output = NULL;
 
+	opt_register_noarg("-d", test_noarg, NULL, "");
+	ok1(!parse_args(&argc, &argv, "-dc", NULL));
+	ok1(strstr(err_output, ": -c: requires an argument"));
+
 	/* parse_args allocates argv */
 	free(argv);
 	return exit_status();
diff --git a/ccan/ccan/opt/test/run-helpers.c b/ccan/ccan/opt/test/run-helpers.c
index 0a08a85f7..9aa41fe8d 100644
--- a/ccan/ccan/opt/test/run-helpers.c
+++ b/ccan/ccan/opt/test/run-helpers.c
@@ -476,26 +476,26 @@ int main(int argc, char *argv[])
 			char buf[OPT_SHOW_LEN+2] = { 0 };
 			buf[OPT_SHOW_LEN] = '!';
 			i = -77;
-			opt_show_intval_bi(buf, &i);
+			opt_show_intval_bi(buf, OPT_SHOW_LEN, &i);
 			ok1(strcmp(buf, "-77") == 0);
 			i = 0;
-			opt_show_intval_bi(buf, &i);
+			opt_show_intval_bi(buf, OPT_SHOW_LEN, &i);
 			ok1(strcmp(buf, "0") == 0);
 			ok1(buf[OPT_SHOW_LEN] == '!');
 			i = 77;
-			opt_show_intval_bi(buf, &i);
+			opt_show_intval_bi(buf, OPT_SHOW_LEN, &i);
 			ok1(strcmp(buf, "77") == 0);
 			ok1(buf[OPT_SHOW_LEN] == '!');
 			i = -1234 * k;
-			opt_show_intval_bi(buf, &i);
+			opt_show_intval_bi(buf, OPT_SHOW_LEN, &i);
 			ok1(strcmp(buf, "-1234k") == 0);
 			ok1(buf[OPT_SHOW_LEN] == '!');
 			i = 500 * M;
-			opt_show_intval_bi(buf, &i);
+			opt_show_intval_bi(buf, OPT_SHOW_LEN, &i);
 			ok1(strcmp(buf, "500M") == 0);
 			ok1(buf[OPT_SHOW_LEN] == '!');
 			i = 1024 * M;
-			opt_show_intval_bi(buf, &i);
+			opt_show_intval_bi(buf, OPT_SHOW_LEN, &i);
 			ok1(strcmp(buf, "1G") == 0);
 			ok1(buf[OPT_SHOW_LEN] == '!');
 		}
@@ -506,27 +506,27 @@ int main(int argc, char *argv[])
 			char buf[OPT_SHOW_LEN+2] = { 0 };
 			buf[OPT_SHOW_LEN] = '!';
 			i = -77;
-			opt_show_longval_bi(buf, &i);
+			opt_show_longval_bi(buf, OPT_SHOW_LEN, &i);
 			ok1(strcmp(buf, "-77") == 0);
 			ok1(buf[OPT_SHOW_LEN] == '!');
 			i = 77;
-			opt_show_longval_bi(buf, &i);
+			opt_show_longval_bi(buf, OPT_SHOW_LEN, &i);
 			ok1(strcmp(buf, "77") == 0);
 			ok1(buf[OPT_SHOW_LEN] == '!');
 			i = -1 * k;
-			opt_show_longval_bi(buf, &i);
+			opt_show_longval_bi(buf, OPT_SHOW_LEN, &i);
 			ok1(strcmp(buf, "-1k") == 0);
 			ok1(buf[OPT_SHOW_LEN] == '!');
 			i = 500 * M;
-			opt_show_longval_bi(buf, &i);
+			opt_show_longval_bi(buf, OPT_SHOW_LEN, &i);
 			ok1(strcmp(buf, "500M") == 0);
 			ok1(buf[OPT_SHOW_LEN] == '!');
 			i = 1024 * M;
-			opt_show_longval_bi(buf, &i);
+			opt_show_longval_bi(buf, OPT_SHOW_LEN, &i);
 			ok1(strcmp(buf, "1G") == 0);
 			ok1(buf[OPT_SHOW_LEN] == '!');
 			i = 0;
-			opt_show_longval_bi(buf, &i);
+			opt_show_longval_bi(buf, OPT_SHOW_LEN, &i);
 			ok1(strcmp(buf, "0") == 0);
 			ok1(buf[OPT_SHOW_LEN] == '!');
 		}
@@ -537,23 +537,23 @@ int main(int argc, char *argv[])
 			char buf[OPT_SHOW_LEN+2] = { 0 };
 			buf[OPT_SHOW_LEN] = '!';
 			i = -7777;
-			opt_show_longlongval_bi(buf, &i);
+			opt_show_longlongval_bi(buf, OPT_SHOW_LEN, &i);
 			ok1(strcmp(buf, "-7777") == 0);
 			ok1(buf[OPT_SHOW_LEN] == '!');
 			i = 7777;
-			opt_show_longlongval_bi(buf, &i);
+			opt_show_longlongval_bi(buf, OPT_SHOW_LEN, &i);
 			ok1(strcmp(buf, "7777") == 0);
 			ok1(buf[OPT_SHOW_LEN] == '!');
 			i = -10240000 * k;
-			opt_show_longlongval_bi(buf, &i);
+			opt_show_longlongval_bi(buf, OPT_SHOW_LEN, &i);
 			ok1(strcmp(buf, "-10000M") == 0);
 			ok1(buf[OPT_SHOW_LEN] == '!');
 			i = 5 * P;
-			opt_show_longlongval_bi(buf, &i);
+			opt_show_longlongval_bi(buf, OPT_SHOW_LEN, &i);
 			ok1(strcmp(buf, "5P") == 0);
 			ok1(buf[OPT_SHOW_LEN] == '!');
 			i = 1024 * P;
-			opt_show_longlongval_bi(buf, &i);
+			opt_show_longlongval_bi(buf, OPT_SHOW_LEN, &i);
 			ok1(strcmp(buf, "1E") == 0);
 			ok1(buf[OPT_SHOW_LEN] == '!');
 		}
@@ -564,19 +564,19 @@ int main(int argc, char *argv[])
 			char buf[OPT_SHOW_LEN+2] = { 0 };
 			buf[OPT_SHOW_LEN] = '!';
 			i = 77;
-			opt_show_uintval_bi(buf, &i);
+			opt_show_uintval_bi(buf, OPT_SHOW_LEN, &i);
 			ok1(strcmp(buf, "77") == 0);
 			ok1(buf[OPT_SHOW_LEN] == '!');
 			i = 1234 * k;
-			opt_show_uintval_bi(buf, &i);
+			opt_show_uintval_bi(buf, OPT_SHOW_LEN, &i);
 			ok1(strcmp(buf, "1234k") == 0);
 			ok1(buf[OPT_SHOW_LEN] == '!');
 			i = 500 * M;
-			opt_show_uintval_bi(buf, &i);
+			opt_show_uintval_bi(buf, OPT_SHOW_LEN, &i);
 			ok1(strcmp(buf, "500M") == 0);
 			ok1(buf[OPT_SHOW_LEN] == '!');
 			i = 1024 * M;
-			opt_show_uintval_bi(buf, &i);
+			opt_show_uintval_bi(buf, OPT_SHOW_LEN, &i);
 			ok1(strcmp(buf, "1G") == 0);
 			ok1(buf[OPT_SHOW_LEN] == '!');
 		}
@@ -587,23 +587,23 @@ int main(int argc, char *argv[])
 			char buf[OPT_SHOW_LEN+2] = { 0 };
 			buf[OPT_SHOW_LEN] = '!';
 			i = 77;
-			opt_show_ulongval_bi(buf, &i);
+			opt_show_ulongval_bi(buf, OPT_SHOW_LEN, &i);
 			ok1(strcmp(buf, "77") == 0);
 			ok1(buf[OPT_SHOW_LEN] == '!');
 			i = k;
-			opt_show_ulongval_bi(buf, &i);
+			opt_show_ulongval_bi(buf, OPT_SHOW_LEN, &i);
 			ok1(strcmp(buf, "1k") == 0);
 			ok1(buf[OPT_SHOW_LEN] == '!');
 			i = 500 * M;
-			opt_show_ulongval_bi(buf, &i);
+			opt_show_ulongval_bi(buf, OPT_SHOW_LEN, &i);
 			ok1(strcmp(buf, "500M") == 0);
 			ok1(buf[OPT_SHOW_LEN] == '!');
 			i = 1024 * M;
-			opt_show_ulongval_bi(buf, &i);
+			opt_show_ulongval_bi(buf, OPT_SHOW_LEN, &i);
 			ok1(strcmp(buf, "1G") == 0);
 			ok1(buf[OPT_SHOW_LEN] == '!');
 			i = 0;
-			opt_show_ulongval_bi(buf, &i);
+			opt_show_ulongval_bi(buf, OPT_SHOW_LEN, &i);
 			ok1(strcmp(buf, "0") == 0);
 			ok1(buf[OPT_SHOW_LEN] == '!');
 		}
@@ -614,19 +614,19 @@ int main(int argc, char *argv[])
 			char buf[OPT_SHOW_LEN+2] = { 0 };
 			buf[OPT_SHOW_LEN] = '!';
 			i = 7777;
-			opt_show_ulonglongval_bi(buf, (unsigned long long *)&i);
+			opt_show_ulonglongval_bi(buf, OPT_SHOW_LEN, (unsigned long long *)&i);
 			ok1(strcmp(buf, "7777") == 0);
 			ok1(buf[OPT_SHOW_LEN] == '!');
 			i = 10240000 * k;
-			opt_show_ulonglongval_bi(buf, (unsigned long long *)&i);
+			opt_show_ulonglongval_bi(buf, OPT_SHOW_LEN, (unsigned long long *)&i);
 			ok1(strcmp(buf, "10000M") == 0);
 			ok1(buf[OPT_SHOW_LEN] == '!');
 			i = 5 * P;
-			opt_show_ulonglongval_bi(buf, (unsigned long long *)&i);
+			opt_show_ulonglongval_bi(buf, OPT_SHOW_LEN, (unsigned long long *)&i);
 			ok1(strcmp(buf, "5P") == 0);
 			ok1(buf[OPT_SHOW_LEN] == '!');
 			i = 1024 * P;
-			opt_show_ulonglongval_bi(buf, (unsigned long long *)&i);
+			opt_show_ulonglongval_bi(buf, OPT_SHOW_LEN, (unsigned long long *)&i);
 			ok1(strcmp(buf, "1E") == 0);
 			ok1(buf[OPT_SHOW_LEN] == '!');
 		}
@@ -860,26 +860,26 @@ int main(int argc, char *argv[])
 			char buf[OPT_SHOW_LEN+2] = { 0 };
 			buf[OPT_SHOW_LEN] = '!';
 			i = -77;
-			opt_show_intval_si(buf, &i);
+			opt_show_intval_si(buf, OPT_SHOW_LEN, &i);
 			ok1(strcmp(buf, "-77") == 0);
 			i = 0;
-			opt_show_intval_si(buf, &i);
+			opt_show_intval_si(buf, OPT_SHOW_LEN, &i);
 			ok1(strcmp(buf, "0") == 0);
 			ok1(buf[OPT_SHOW_LEN] == '!');
 			i = 77;
-			opt_show_intval_si(buf, &i);
+			opt_show_intval_si(buf, OPT_SHOW_LEN, &i);
 			ok1(strcmp(buf, "77") == 0);
 			ok1(buf[OPT_SHOW_LEN] == '!');
 			i = -1234 * k;
-			opt_show_intval_si(buf, &i);
+			opt_show_intval_si(buf, OPT_SHOW_LEN, &i);
 			ok1(strcmp(buf, "-1234k") == 0);
 			ok1(buf[OPT_SHOW_LEN] == '!');
 			i = 500 * M;
-			opt_show_intval_si(buf, &i);
+			opt_show_intval_si(buf, OPT_SHOW_LEN, &i);
 			ok1(strcmp(buf, "500M") == 0);
 			ok1(buf[OPT_SHOW_LEN] == '!');
 			i = 1000 * M;
-			opt_show_intval_si(buf, &i);
+			opt_show_intval_si(buf, OPT_SHOW_LEN, &i);
 			ok1(strcmp(buf, "1G") == 0);
 			ok1(buf[OPT_SHOW_LEN] == '!');
 		}
@@ -890,27 +890,27 @@ int main(int argc, char *argv[])
 			char buf[OPT_SHOW_LEN+2] = { 0 };
 			buf[OPT_SHOW_LEN] = '!';
 			i = -77;
-			opt_show_longval_si(buf, &i);
+			opt_show_longval_si(buf, OPT_SHOW_LEN, &i);
 			ok1(strcmp(buf, "-77") == 0);
 			ok1(buf[OPT_SHOW_LEN] == '!');
 			i = 77;
-			opt_show_longval_si(buf, &i);
+			opt_show_longval_si(buf, OPT_SHOW_LEN, &i);
 			ok1(strcmp(buf, "77") == 0);
 			ok1(buf[OPT_SHOW_LEN] == '!');
 			i = -1 * k;
-			opt_show_longval_si(buf, &i);
+			opt_show_longval_si(buf, OPT_SHOW_LEN, &i);
 			ok1(strcmp(buf, "-1k") == 0);
 			ok1(buf[OPT_SHOW_LEN] == '!');
 			i = 500 * M;
-			opt_show_longval_si(buf, &i);
+			opt_show_longval_si(buf, OPT_SHOW_LEN, &i);
 			ok1(strcmp(buf, "500M") == 0);
 			ok1(buf[OPT_SHOW_LEN] == '!');
 			i = 1000 * M;
-			opt_show_longval_si(buf, &i);
+			opt_show_longval_si(buf, OPT_SHOW_LEN, &i);
 			ok1(strcmp(buf, "1G") == 0);
 			ok1(buf[OPT_SHOW_LEN] == '!');
 			i = 0;
-			opt_show_longval_si(buf, &i);
+			opt_show_longval_si(buf, OPT_SHOW_LEN, &i);
 			ok1(strcmp(buf, "0") == 0);
 			ok1(buf[OPT_SHOW_LEN] == '!');
 		}
@@ -921,23 +921,23 @@ int main(int argc, char *argv[])
 			char buf[OPT_SHOW_LEN+2] = { 0 };
 			buf[OPT_SHOW_LEN] = '!';
 			i = -7777;
-			opt_show_longlongval_si(buf, &i);
+			opt_show_longlongval_si(buf, OPT_SHOW_LEN, &i);
 			ok1(strcmp(buf, "-7777") == 0);
 			ok1(buf[OPT_SHOW_LEN] == '!');
 			i = 7777;
-			opt_show_longlongval_si(buf, &i);
+			opt_show_longlongval_si(buf, OPT_SHOW_LEN, &i);
 			ok1(strcmp(buf, "7777") == 0);
 			ok1(buf[OPT_SHOW_LEN] == '!');
 			i = -10240000 * k;
-			opt_show_longlongval_si(buf, &i);
+			opt_show_longlongval_si(buf, OPT_SHOW_LEN, &i);
 			ok1(strcmp(buf, "-10240M") == 0);
 			ok1(buf[OPT_SHOW_LEN] == '!');
 			i = 5 * P;
-			opt_show_longlongval_si(buf, &i);
+			opt_show_longlongval_si(buf, OPT_SHOW_LEN, &i);
 			ok1(strcmp(buf, "5P") == 0);
 			ok1(buf[OPT_SHOW_LEN] == '!');
 			i = 2000 * P;
-			opt_show_longlongval_si(buf, &i);
+			opt_show_longlongval_si(buf, OPT_SHOW_LEN, &i);
 			ok1(strcmp(buf, "2E") == 0);
 			ok1(buf[OPT_SHOW_LEN] == '!');
 		}
@@ -948,19 +948,19 @@ int main(int argc, char *argv[])
 			char buf[OPT_SHOW_LEN+2] = { 0 };
 			buf[OPT_SHOW_LEN] = '!';
 			i = 77;
-			opt_show_uintval_si(buf, &i);
+			opt_show_uintval_si(buf, OPT_SHOW_LEN, &i);
 			ok1(strcmp(buf, "77") == 0);
 			ok1(buf[OPT_SHOW_LEN] == '!');
 			i = 1234 * k;
-			opt_show_uintval_si(buf, &i);
+			opt_show_uintval_si(buf, OPT_SHOW_LEN, &i);
 			ok1(strcmp(buf, "1234k") == 0);
 			ok1(buf[OPT_SHOW_LEN] == '!');
 			i = 500 * M;
-			opt_show_uintval_si(buf, &i);
+			opt_show_uintval_si(buf, OPT_SHOW_LEN, &i);
 			ok1(strcmp(buf, "500M") == 0);
 			ok1(buf[OPT_SHOW_LEN] == '!');
 			i = 1000 * M;
-			opt_show_uintval_si(buf, &i);
+			opt_show_uintval_si(buf, OPT_SHOW_LEN, &i);
 			ok1(strcmp(buf, "1G") == 0);
 			ok1(buf[OPT_SHOW_LEN] == '!');
 		}
@@ -971,23 +971,23 @@ int main(int argc, char *argv[])
 			char buf[OPT_SHOW_LEN+2] = { 0 };
 			buf[OPT_SHOW_LEN] = '!';
 			i = 77;
-			opt_show_ulongval_si(buf, &i);
+			opt_show_ulongval_si(buf, OPT_SHOW_LEN, &i);
 			ok1(strcmp(buf, "77") == 0);
 			ok1(buf[OPT_SHOW_LEN] == '!');
 			i = k;
-			opt_show_ulongval_si(buf, &i);
+			opt_show_ulongval_si(buf, OPT_SHOW_LEN, &i);
 			ok1(strcmp(buf, "1k") == 0);
 			ok1(buf[OPT_SHOW_LEN] == '!');
 			i = 500 * M;
-			opt_show_ulongval_si(buf, &i);
+			opt_show_ulongval_si(buf, OPT_SHOW_LEN, &i);
 			ok1(strcmp(buf, "500M") == 0);
 			ok1(buf[OPT_SHOW_LEN] == '!');
 			i = 1024 * M;
-			opt_show_ulongval_si(buf, &i);
+			opt_show_ulongval_si(buf, OPT_SHOW_LEN, &i);
 			ok1(strcmp(buf, "1024M") == 0);
 			ok1(buf[OPT_SHOW_LEN] == '!');
 			i = 0;
-			opt_show_ulongval_si(buf, &i);
+			opt_show_ulongval_si(buf, OPT_SHOW_LEN, &i);
 			ok1(strcmp(buf, "0") == 0);
 			ok1(buf[OPT_SHOW_LEN] == '!');
 		}
@@ -998,19 +998,19 @@ int main(int argc, char *argv[])
 			char buf[OPT_SHOW_LEN+2] = { 0 };
 			buf[OPT_SHOW_LEN] = '!';
 			i = 7777;
-			opt_show_ulonglongval_si(buf, (unsigned long long *)&i);
+			opt_show_ulonglongval_si(buf, OPT_SHOW_LEN, (unsigned long long *)&i);
 			ok1(strcmp(buf, "7777") == 0);
 			ok1(buf[OPT_SHOW_LEN] == '!');
 			i = 10240000 * k;
-			opt_show_ulonglongval_si(buf, (unsigned long long *)&i);
+			opt_show_ulonglongval_si(buf, OPT_SHOW_LEN, (unsigned long long *)&i);
 			ok1(strcmp(buf, "10240M") == 0);
 			ok1(buf[OPT_SHOW_LEN] == '!');
 			i = 5 * P;
-			opt_show_ulonglongval_si(buf, (unsigned long long *)&i);
+			opt_show_ulonglongval_si(buf, OPT_SHOW_LEN, (unsigned long long *)&i);
 			ok1(strcmp(buf, "5P") == 0);
 			ok1(buf[OPT_SHOW_LEN] == '!');
 			i = 1000 * P;
-			opt_show_ulonglongval_si(buf, (unsigned long long *)&i);
+			opt_show_ulonglongval_si(buf, OPT_SHOW_LEN, (unsigned long long *)&i);
 			ok1(strcmp(buf, "1E") == 0);
 			ok1(buf[OPT_SHOW_LEN] == '!');
 		}
@@ -1090,12 +1090,12 @@ int main(int argc, char *argv[])
 		buf[OPT_SHOW_LEN] = '!';
 
 		b = true;
-		opt_show_bool(buf, &b);
+		opt_show_bool(buf, OPT_SHOW_LEN, &b);
 		ok1(strcmp(buf, "true") == 0);
 		ok1(buf[OPT_SHOW_LEN] == '!');
 
 		b = false;
-		opt_show_bool(buf, &b);
+		opt_show_bool(buf, OPT_SHOW_LEN, &b);
 		ok1(strcmp(buf, "false") == 0);
 		ok1(buf[OPT_SHOW_LEN] == '!');
 	}
@@ -1107,12 +1107,12 @@ int main(int argc, char *argv[])
 		buf[OPT_SHOW_LEN] = '!';
 
 		b = true;
-		opt_show_invbool(buf, &b);
+		opt_show_invbool(buf, OPT_SHOW_LEN, &b);
 		ok1(strcmp(buf, "false") == 0);
 		ok1(buf[OPT_SHOW_LEN] == '!');
 
 		b = false;
-		opt_show_invbool(buf, &b);
+		opt_show_invbool(buf, OPT_SHOW_LEN, &b);
 		ok1(strcmp(buf, "true") == 0);
 		ok1(buf[OPT_SHOW_LEN] == '!');
 	}
@@ -1126,14 +1126,14 @@ int main(int argc, char *argv[])
 		/* Short test. */
 		p = str;
 		strcpy(p, "short");
-		opt_show_charp(buf, &p);
+		opt_show_charp(buf, OPT_SHOW_LEN, &p);
 		ok1(strcmp(buf, "\"short\"") == 0);
 		ok1(buf[OPT_SHOW_LEN] == '!');
 
 		/* Truncate test. */
 		memset(p, 'x', OPT_SHOW_LEN*2);
 		p[OPT_SHOW_LEN*2-1] = '\0';
-		opt_show_charp(buf, &p);
+		opt_show_charp(buf, OPT_SHOW_LEN, &p);
 		ok1(buf[0] == '"');
 		ok1(buf[OPT_SHOW_LEN-1] == '"');
 		ok1(buf[OPT_SHOW_LEN] == '!');
@@ -1147,12 +1147,12 @@ int main(int argc, char *argv[])
 		buf[OPT_SHOW_LEN] = '!';
 
 		i = -77;
-		opt_show_intval(buf, &i);
+		opt_show_intval(buf, OPT_SHOW_LEN, &i);
 		ok1(strcmp(buf, "-77") == 0);
 		ok1(buf[OPT_SHOW_LEN] == '!');
 
 		i = 77;
-		opt_show_intval(buf, &i);
+		opt_show_intval(buf, OPT_SHOW_LEN, &i);
 		ok1(strcmp(buf, "77") == 0);
 		ok1(buf[OPT_SHOW_LEN] == '!');
 	}
@@ -1164,7 +1164,7 @@ int main(int argc, char *argv[])
 		buf[OPT_SHOW_LEN] = '!';
 
 		ui = 4294967295U;
-		opt_show_uintval(buf, &ui);
+		opt_show_uintval(buf, OPT_SHOW_LEN, &ui);
 		ok1(strcmp(buf, "4294967295") == 0);
 		ok1(buf[OPT_SHOW_LEN] == '!');
 	}
@@ -1176,7 +1176,7 @@ int main(int argc, char *argv[])
 		buf[OPT_SHOW_LEN] = '!';
 
 		l = 1234567890L;
-		opt_show_longval(buf, &l);
+		opt_show_longval(buf, OPT_SHOW_LEN, &l);
 		ok1(strcmp(buf, "1234567890") == 0);
 		ok1(buf[OPT_SHOW_LEN] == '!');
 	}
@@ -1188,7 +1188,7 @@ int main(int argc, char *argv[])
 		buf[OPT_SHOW_LEN] = '!';
 
 		ul = 4294967295UL;
-		opt_show_ulongval(buf, &ul);
+		opt_show_ulongval(buf, OPT_SHOW_LEN, &ul);
 		ok1(strcmp(buf, "4294967295") == 0);
 		ok1(buf[OPT_SHOW_LEN] == '!');
 	}
@@ -1200,12 +1200,12 @@ int main(int argc, char *argv[])
 		buf[OPT_SHOW_LEN] = '!';
 
 		f = -77.5;
-		opt_show_floatval(buf, &f);
+		opt_show_floatval(buf, OPT_SHOW_LEN, &f);
 		ok1(strcmp(buf, "-77.500000") == 0);
 		ok1(buf[OPT_SHOW_LEN] == '!');
 
 		f = 77.5;
-		opt_show_floatval(buf, &f);
+		opt_show_floatval(buf, OPT_SHOW_LEN, &f);
 		ok1(strcmp(buf, "77.500000") == 0);
 		ok1(buf[OPT_SHOW_LEN] == '!');
 	}
@@ -1217,12 +1217,12 @@ int main(int argc, char *argv[])
 		buf[OPT_SHOW_LEN] = '!';
 
 		d = -77;
-		opt_show_doubleval(buf, &d);
+		opt_show_doubleval(buf, OPT_SHOW_LEN, &d);
 		ok1(strcmp(buf, "-77.000000") == 0);
 		ok1(buf[OPT_SHOW_LEN] == '!');
 
 		d = 77;
-		opt_show_doubleval(buf, &d);
+		opt_show_doubleval(buf, OPT_SHOW_LEN, &d);
 		ok1(strcmp(buf, "77.000000") == 0);
 		ok1(buf[OPT_SHOW_LEN] == '!');
 	}
diff --git a/ccan/ccan/opt/test/run-userbits.c b/ccan/ccan/opt/test/run-userbits.c
new file mode 100644
index 000000000..7f102f08e
--- /dev/null
+++ b/ccan/ccan/opt/test/run-userbits.c
@@ -0,0 +1,59 @@
+#include <ccan/tap/tap.h>
+#include <stdlib.h>
+#include <ccan/opt/opt.c>
+#include <ccan/opt/usage.c>
+#include <ccan/opt/helpers.c>
+#include <ccan/opt/parse.c>
+#include "utils.h"
+
+int main(int argc, char *argv[])
+{
+	const char *myname = argv[0];
+
+	plan_tests(28);
+
+	opt_register_noarg("-a", test_noarg, NULL, "All");
+	opt_register_noarg("--aaa", test_noarg, NULL, "AAAAll");
+	opt_register_arg("-b|--bbb", test_arg, NULL, "bbb", "AAAAAAll");
+
+	ok1(strcmp(opt_table[0].names, "-a") == 0);
+	ok1(opt_table[0].type == OPT_NOARG);
+	ok1(strcmp(opt_table[1].names, "--aaa") == 0);
+	ok1(opt_table[1].type == OPT_NOARG);
+	ok1(strcmp(opt_table[2].names, "-b|--bbb") == 0);
+	ok1(opt_table[2].type == OPT_HASARG);
+
+	opt_table[0].type |= (1 << OPT_USER_START);
+	opt_table[1].type |= ((1 << OPT_USER_END)-1) - ((1 << OPT_USER_START)-1);
+	opt_table[2].type |= (1 << OPT_USER_END);
+
+	/* Should all work fine! */
+	ok1(parse_args(&argc, &argv, "-a", NULL));
+	ok1(argc == 1);
+	ok1(argv[0] == myname);
+	ok1(test_cb_called == 1);
+
+	ok1(parse_args(&argc, &argv, "--aaa", NULL));
+	ok1(argc == 1);
+	ok1(argv[0] == myname);
+	ok1(test_cb_called == 2);
+
+	/* This one needs an arg. */
+	ok1(parse_args(&argc, &argv, "-b", NULL) == false);
+	ok1(test_cb_called == 2);
+	ok1(parse_args(&argc, &argv, "-b", "bbb", NULL));
+	ok1(argc == 1);
+	ok1(argv[0] == myname);
+	ok1(argv[1] == NULL);
+	ok1(test_cb_called == 3);
+
+	ok1(parse_args(&argc, &argv, "--bbb", "bbb", NULL));
+	ok1(argc == 1);
+	ok1(argv[0] == myname);
+	ok1(argv[1] == NULL);
+	ok1(test_cb_called == 4);
+
+	/* parse_args allocates argv */
+	free(argv);
+	return exit_status();
+}
diff --git a/ccan/ccan/opt/test/utils.c b/ccan/ccan/opt/test/utils.c
index 2ff04884e..61199fb46 100644
--- a/ccan/ccan/opt/test/utils.c
+++ b/ccan/ccan/opt/test/utils.c
@@ -21,9 +21,10 @@ char *test_arg(const char *optarg, const char *arg)
 	return NULL;
 }
 
-void show_arg(char buf[OPT_SHOW_LEN], const char *arg)
+bool show_arg(char *buf, size_t len, const char *arg)
 {
-	strncpy(buf, arg, OPT_SHOW_LEN);
+	strncpy(buf, arg, len);
+	return true;
 }
 
 char *err_output = NULL;
diff --git a/ccan/ccan/opt/test/utils.h b/ccan/ccan/opt/test/utils.h
index 12cf0b753..3ada62d11 100644
--- a/ccan/ccan/opt/test/utils.h
+++ b/ccan/ccan/opt/test/utils.h
@@ -13,7 +13,7 @@ void reset_options(void);
 extern unsigned int test_cb_called;
 char *test_noarg(void *arg);
 char *test_arg(const char *optarg, const char *arg);
-void show_arg(char buf[OPT_SHOW_LEN], const char *arg);
+bool show_arg(char *buf, size_t len, const char *arg);
 
 extern struct opt_table short_table[];
 extern struct opt_table long_table[];
diff --git a/ccan/ccan/opt/usage.c b/ccan/ccan/opt/usage.c
index 8ee4ebd03..568e4661d 100644
--- a/ccan/ccan/opt/usage.c
+++ b/ccan/ccan/opt/usage.c
@@ -20,6 +20,9 @@ const char opt_hidden[1];
 #define MIN_DESC_WIDTH 40
 #define MIN_TOTAL_WIDTH 50
 
+/* Maximum length of arg to show in opt_usage */
+#define OPT_SHOW_LEN 80
+
 static unsigned int get_columns(void)
 {
 	int ws_col = 0;
@@ -148,20 +151,20 @@ static char *add_desc(char *base, size_t *len, size_t *max,
 	if (opt->show) {
 		char buf[OPT_SHOW_LEN + sizeof("...")];
 		strcpy(buf + OPT_SHOW_LEN, "...");
-		opt->show(buf, opt->u.arg);
+		if (opt->show(buf, OPT_SHOW_LEN, opt->u.arg)) {
+			/* If it doesn't fit on this line, indent. */
+			if (off + strlen(" (default: ") + strlen(buf) + strlen(")")
+			    > width) {
+				base = add_indent(base, len, max, indent);
+			} else {
+				/* Remove \n. */
+				(*len)--;
+			}
 
-		/* If it doesn't fit on this line, indent. */
-		if (off + strlen(" (default: ") + strlen(buf) + strlen(")")
-		    > width) {
-			base = add_indent(base, len, max, indent);
-		} else {
-			/* Remove \n. */
-			(*len)--;
+			base = add_str(base, len, max, " (default: ");
+			base = add_str(base, len, max, buf);
+			base = add_str(base, len, max, ")\n");
 		}
-
-		base = add_str(base, len, max, " (default: ");
-		base = add_str(base, len, max, buf);
-		base = add_str(base, len, max, ")\n");
 	}
 	return base;
 }
@@ -182,10 +185,10 @@ char *opt_usage(const char *argv0, const char *extra)
 		size_t l;
 		if (opt_table[i].desc == opt_hidden)
 			continue;
-		if (opt_table[i].type == OPT_SUBTABLE)
+		if (opt_table[i].type & OPT_SUBTABLE)
 			continue;
 		l = strlen(opt_table[i].names);
-		if (opt_table[i].type == OPT_HASARG
+		if ((opt_table[i].type & OPT_HASARG)
 		    && !strchr(opt_table[i].names, ' ')
 		    && !strchr(opt_table[i].names, '='))
 			l += strlen(" <arg>");
@@ -221,7 +224,7 @@ char *opt_usage(const char *argv0, const char *extra)
 	for (i = 0; i < opt_count; i++) {
 		if (opt_table[i].desc == opt_hidden)
 			continue;
-		if (opt_table[i].type == OPT_SUBTABLE) {
+		if (opt_table[i].type & OPT_SUBTABLE) {
 			ret = add_str(ret, &len, &max, opt_table[i].desc);
 			ret = add_str(ret, &len, &max, ":\n");
 			continue;
diff --git a/ccan/ccan/tcon/tcon.h b/ccan/ccan/tcon/tcon.h
index e0f84b383..df3aac88b 100644
--- a/ccan/ccan/tcon/tcon.h
+++ b/ccan/ccan/tcon/tcon.h
@@ -147,8 +147,7 @@
  * It evaluates to @x so you can chain it.
  */
 #define tcon_check_ptr(x, canary, expr)				\
-	(sizeof(&(x)->_tcon[0].canary == (expr)) ? (x) : (x))
-
+	(sizeof((expr) ? (expr) : &(x)->_tcon[0].canary) ? (x) : (x))
 
 /**
  * tcon_type - the type within a container (or void *)
diff --git a/cli/lightning-cli.c b/cli/lightning-cli.c
index dfc2ff00f..936af1e98 100644
--- a/cli/lightning-cli.c
+++ b/cli/lightning-cli.c
@@ -594,12 +594,13 @@ static char *opt_set_level(const char *arg, enum log_level *level)
 	return NULL;
 }
 
-static void opt_show_level(char buf[OPT_SHOW_LEN], const enum log_level *level)
+static bool opt_show_level(char *buf, size_t len, const enum log_level *level)
 {
 	if (*level == LOG_LEVEL_MAX + 1)
-		strncpy(buf, "none", OPT_SHOW_LEN-1);
+		strncpy(buf, "none", len);
 	else
-		strncpy(buf, log_level_name(*level), OPT_SHOW_LEN-1);
+		strncpy(buf, log_level_name(*level), len);
+	return true;
 }
 
 /* The standard opt_log_stderr_exit exits with status 1 */
diff --git a/common/configdir.c b/common/configdir.c
index c03abe18c..611fde313 100644
--- a/common/configdir.c
+++ b/common/configdir.c
@@ -191,9 +191,10 @@ static char *opt_set_specific_network(const char *network)
 	return opt_set_network(network, NULL);
 }
 
-static void opt_show_network(char buf[OPT_SHOW_LEN], const void *unused)
+static bool opt_show_network(char *buf, size_t len, const void *unused)
 {
-	snprintf(buf, OPT_SHOW_LEN, "%s", chainparams->network_name);
+	snprintf(buf, len, "%s", chainparams->network_name);
+	return true;
 }
 
 /* We track where we're getting options from, so we can detect misuse */
diff --git a/devtools/gossipwith.c b/devtools/gossipwith.c
index c525d2ead..21dec7c23 100644
--- a/devtools/gossipwith.c
+++ b/devtools/gossipwith.c
@@ -82,9 +82,10 @@ static char *opt_set_network(const char *arg, void *unused)
 	return NULL;
 }
 
-static void opt_show_network(char buf[OPT_SHOW_LEN], const void *unused)
+static bool opt_show_network(char *buf, size_t len, const void *unused)
 {
-	snprintf(buf, OPT_SHOW_LEN, "%s", chainparams->network_name);
+	snprintf(buf, len, "%s", chainparams->network_name);
+	return true;
 }
 
 void ecdh(const struct pubkey *point, struct secret *ss)
@@ -255,9 +256,9 @@ static char *opt_set_secret(const char *arg, struct secret *s)
 	return NULL;
 }
 
-static void opt_show_secret(char buf[OPT_SHOW_LEN], const struct secret *s)
+static bool opt_show_secret(char *buf, size_t len, const struct secret *s)
 {
-	hex_encode(s->data, sizeof(s->data), buf, OPT_SHOW_LEN);
+	return hex_encode(s->data, sizeof(s->data), buf, len);
 }
 
 static char *opt_set_features(const char *arg, u8 **features)
diff --git a/devtools/onion.c b/devtools/onion.c
index b08a6f25b..4f3e65147 100644
--- a/devtools/onion.c
+++ b/devtools/onion.c
@@ -175,9 +175,9 @@ static char *opt_set_ad(const char *arg, u8 **assocdata)
 	return NULL;
 }
 
-static void opt_show_ad(char buf[OPT_SHOW_LEN], u8 *const *assocdata)
+static bool opt_show_ad(char *buf, size_t len, u8 *const *assocdata)
 {
-	hex_encode(*assocdata, tal_bytelen(*assocdata), buf, OPT_SHOW_LEN);
+	return hex_encode(*assocdata, tal_bytelen(*assocdata), buf, len);
 }
 
 static char *opt_set_node_id(const char *arg, struct node_id *node_id)
diff --git a/lightningd/log.c b/lightningd/log.c
index 85b450a42..686b109a0 100644
--- a/lightningd/log.c
+++ b/lightningd/log.c
@@ -606,7 +606,7 @@ void json_add_opt_log_levels(struct json_stream *response, struct log *log)
 	}
 }
 
-static void show_log_level(char buf[OPT_SHOW_LEN], const struct log *log)
+static bool show_log_level(char *buf, size_t len, const struct log *log)
 {
 	enum log_level l;
 
@@ -614,8 +614,8 @@ static void show_log_level(char buf[OPT_SHOW_LEN], const struct log *log)
 		l = *log->lr->default_print_level;
 	else
 		l = DEFAULT_LOGLEVEL;
-	strncpy(buf, log_level_name(l), OPT_SHOW_LEN - 1);
-	buf[OPT_SHOW_LEN - 1] = '\0';
+	strncpy(buf, log_level_name(l), len);
+	return true;
 }
 
 static char *arg_log_prefix(const char *arg, struct log_book *log_book)
@@ -625,10 +625,10 @@ static char *arg_log_prefix(const char *arg, struct log_book *log_book)
 	return NULL;
 }
 
-static void show_log_prefix(char buf[OPT_SHOW_LEN], const struct log_book *log_book)
+static bool show_log_prefix(char *buf, size_t len, const struct log_book *log_book)
 {
-	strncpy(buf, log_book->prefix, OPT_SHOW_LEN - 1);
-	buf[OPT_SHOW_LEN - 1] = '\0';
+	strncpy(buf, log_book->prefix, len);
+	return true;
 }
 
 static int signalfds[2];
diff --git a/lightningd/options.c b/lightningd/options.c
index 49c60759d..e3e383d66 100644
--- a/lightningd/options.c
+++ b/lightningd/options.c
@@ -118,19 +118,20 @@ char *opt_set_autobool_arg(const char *arg, enum opt_autobool *b)
 	return opt_invalid_argument(arg);
 }
 
-void opt_show_autobool(char buf[OPT_SHOW_LEN], const enum opt_autobool *b)
+bool opt_show_autobool(char *buf, size_t len, const enum opt_autobool *b)
 {
 	switch (*b) {
 	case OPT_AUTOBOOL_TRUE:
-		strncpy(buf, "true", OPT_SHOW_LEN);
-		break;
+		strncpy(buf, "true", len);
+		return true;
 	case OPT_AUTOBOOL_FALSE:
-		strncpy(buf, "false", OPT_SHOW_LEN);
-		break;
+		strncpy(buf, "false", len);
+		return true;
 	case OPT_AUTOBOOL_AUTO:
-	default:
-		strncpy(buf, "auto", OPT_SHOW_LEN);
+		strncpy(buf, "auto", len);
+		return true;
 	}
+	abort();
 }
 
 static char *opt_set_mode(const char *arg, mode_t *m)
@@ -440,23 +441,27 @@ static char *opt_subdaemon(const char *arg, struct lightningd *ld)
 	return NULL;
 }
 
-static void opt_show_u64(char buf[OPT_SHOW_LEN], const u64 *u)
+static bool opt_show_u64(char *buf, size_t len, const u64 *u)
 {
-	snprintf(buf, OPT_SHOW_LEN, "%"PRIu64, *u);
+	snprintf(buf, len, "%"PRIu64, *u);
+	return true;
 }
-static void opt_show_u32(char buf[OPT_SHOW_LEN], const u32 *u)
+static bool opt_show_u32(char *buf, size_t len, const u32 *u)
 {
-	snprintf(buf, OPT_SHOW_LEN, "%"PRIu32, *u);
+	snprintf(buf, len, "%"PRIu32, *u);
+	return true;
 }
 
-static void opt_show_s32(char buf[OPT_SHOW_LEN], const s32 *u)
+static bool opt_show_s32(char *buf, size_t len, const s32 *u)
 {
-	snprintf(buf, OPT_SHOW_LEN, "%"PRIi32, *u);
+	snprintf(buf, len, "%"PRIi32, *u);
+	return true;
 }
 
-static void opt_show_mode(char buf[OPT_SHOW_LEN], const mode_t *m)
+static bool opt_show_mode(char *buf, size_t len, const mode_t *m)
 {
-	snprintf(buf, OPT_SHOW_LEN, "\"%04o\"", (int) *m);
+	snprintf(buf, len, "\"%04o\"", (int) *m);
+	return true;
 }
 
 static char *opt_set_rgb(const char *arg, struct lightningd *ld)
@@ -1665,7 +1670,7 @@ static void add_config(struct lightningd *ld,
 {
 	char *name0 = tal_strndup(tmpctx, name, len);
 	char *answer = NULL;
-	char buf[OPT_SHOW_LEN + sizeof("...")];
+	char buf[4096 + sizeof("...")];
 
 #if DEVELOPER
 	if (strstarts(name0, "dev-")) {
@@ -1742,11 +1747,12 @@ static void add_config(struct lightningd *ld,
 		if (opt->desc == opt_hidden) {
 			/* Ignore hidden options (deprecated) */
 		} else if (opt->show == (void *)opt_show_charp) {
-			/* Don't truncate! */
+			/* Don't truncate or quote! */
 			answer = tal_strdup(tmpctx, *(char **)opt->u.carg);
 		} else if (opt->show) {
-			opt->show(buf, opt->u.carg);
-			strcpy(buf + OPT_SHOW_LEN - 1, "...");
+			strcpy(buf + sizeof(buf) - sizeof("..."), "...");
+			if (!opt->show(buf, sizeof(buf) - sizeof("..."), opt->u.carg))
+				buf[0] = '\0';
 
 			if (streq(buf, "true") || streq(buf, "false")
 			    || (!streq(buf, "") && strspn(buf, "0123456789.") == strlen(buf))) {
diff --git a/lightningd/options.h b/lightningd/options.h
index 55054f994..72bc039d9 100644
--- a/lightningd/options.h
+++ b/lightningd/options.h
@@ -20,6 +20,6 @@ enum opt_autobool {
 	OPT_AUTOBOOL_AUTO = 2,
 };
 char *opt_set_autobool_arg(const char *arg, enum opt_autobool *b);
-void opt_show_autobool(char buf[OPT_SHOW_LEN], const enum opt_autobool *b);
+bool opt_show_autobool(char *buf, size_t len, const enum opt_autobool *b);
 
 #endif /* LIGHTNING_LIGHTNINGD_OPTIONS_H */
diff --git a/tests/test_misc.py b/tests/test_misc.py
index 176408aa6..7a502d294 100644
--- a/tests/test_misc.py
+++ b/tests/test_misc.py
@@ -733,7 +733,7 @@ def test_listconfigs(node_factory, bitcoind, chainparams):
         assert configs['allow-deprecated-apis'] == deprecated
         assert configs['network'] == chainparams['name']
         assert configs['ignore-fee-limits'] is False
-        assert configs['log-prefix'] == 'lightning1-xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx...'
+        assert configs['log-prefix'] == 'lightning1-xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx'
 
         # These are aliases, but we don't print the (unofficial!) wumbo.
         assert 'wumbo' not in configs