diff --git a/.gitignore b/.gitignore
index ae7cc6e97414..99b24e4c6dc1 100644
--- a/.gitignore
+++ b/.gitignore
@@ -18,6 +18,7 @@ tools/check-bolt
 coverage
 ccan/config.h
 __pycache__
+config.vars
 
 # Ignore some generated binaries
 lightningd/test/run-channel
@@ -46,3 +47,4 @@ test/test_protocol
 test/test_sphinx
 tests/.pytest.restart
 gossip_store
+
diff --git a/.travis.yml b/.travis.yml
index 0cb8b19258aa..fa5756c67ace 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -7,27 +7,28 @@ notifications:
 
 env:
   - ARCH=32 SOURCE_CHECK_ONLY=true
-  - NO_VALGRIND=1 ARCH=32 DEVELOPER=1 COMPILER=gcc TEST_GROUP=1 TEST_GROUP_COUNT=2 SOURCE_CHECK_ONLY=false
-  - NO_VALGRIND=1 ARCH=32 DEVELOPER=1 COMPILER=gcc TEST_GROUP=2 TEST_GROUP_COUNT=2 SOURCE_CHECK_ONLY=false
-  - NO_VALGRIND=1 ARCH=64 DEVELOPER=1 COMPILER=gcc SOURCE_CHECK_ONLY=false
-  - NO_VALGRIND=1 ARCH=64 DEVELOPER=0 COMPILER=gcc NO_COMPAT=1 SOURCE_CHECK_ONLY=false
-  - NO_VALGRIND=0 ARCH=64 DEVELOPER=0 COMPILER=gcc TEST_GROUP=1 TEST_GROUP_COUNT=3 SOURCE_CHECK_ONLY=false
-  - NO_VALGRIND=0 ARCH=64 DEVELOPER=0 COMPILER=gcc TEST_GROUP=2 TEST_GROUP_COUNT=3 SOURCE_CHECK_ONLY=false
-  - NO_VALGRIND=0 ARCH=64 DEVELOPER=0 COMPILER=gcc TEST_GROUP=3 TEST_GROUP_COUNT=3 SOURCE_CHECK_ONLY=false
-  - NO_VALGRIND=1 ARCH=64 DEVELOPER=1 COMPILER=clang SOURCE_CHECK_ONLY=false
-  - NO_VALGRIND=0 ARCH=64 DEVELOPER=1 COMPILER=gcc TEST_GROUP=1 TEST_GROUP_COUNT=6 SOURCE_CHECK_ONLY=false
-  - NO_VALGRIND=0 ARCH=64 DEVELOPER=1 COMPILER=gcc TEST_GROUP=2 TEST_GROUP_COUNT=6 SOURCE_CHECK_ONLY=false
-  - NO_VALGRIND=0 ARCH=64 DEVELOPER=1 COMPILER=gcc TEST_GROUP=3 TEST_GROUP_COUNT=6 SOURCE_CHECK_ONLY=false
-  - NO_VALGRIND=0 ARCH=64 DEVELOPER=1 COMPILER=gcc TEST_GROUP=4 TEST_GROUP_COUNT=6 SOURCE_CHECK_ONLY=false
-  - NO_VALGRIND=0 ARCH=64 DEVELOPER=1 COMPILER=gcc TEST_GROUP=5 TEST_GROUP_COUNT=6 SOURCE_CHECK_ONLY=false
-  - NO_VALGRIND=0 ARCH=64 DEVELOPER=1 COMPILER=gcc TEST_GROUP=6 TEST_GROUP_COUNT=6 SOURCE_CHECK_ONLY=false
+  - VALGRIND=0 ARCH=32 DEVELOPER=1 COMPILER=gcc TEST_GROUP=1 TEST_GROUP_COUNT=2 SOURCE_CHECK_ONLY=false
+  - VALGRIND=0 ARCH=32 DEVELOPER=1 COMPILER=gcc TEST_GROUP=2 TEST_GROUP_COUNT=2 SOURCE_CHECK_ONLY=false
+  - VALGRIND=0 ARCH=64 DEVELOPER=1 COMPILER=gcc SOURCE_CHECK_ONLY=false
+  - VALGRIND=0 ARCH=64 DEVELOPER=0 COMPILER=gcc NO_COMPAT=1 SOURCE_CHECK_ONLY=false
+  - VALGRIND=1 ARCH=64 DEVELOPER=0 COMPILER=gcc TEST_GROUP=1 TEST_GROUP_COUNT=3 SOURCE_CHECK_ONLY=false
+  - VALGRIND=1 ARCH=64 DEVELOPER=0 COMPILER=gcc TEST_GROUP=2 TEST_GROUP_COUNT=3 SOURCE_CHECK_ONLY=false
+  - VALGRIND=1 ARCH=64 DEVELOPER=0 COMPILER=gcc TEST_GROUP=3 TEST_GROUP_COUNT=3 SOURCE_CHECK_ONLY=false
+  - VALGRIND=0 ARCH=64 DEVELOPER=1 COMPILER=clang SOURCE_CHECK_ONLY=false
+  - VALGRIND=1 ARCH=64 DEVELOPER=1 COMPILER=gcc TEST_GROUP=1 TEST_GROUP_COUNT=6 SOURCE_CHECK_ONLY=false
+  - VALGRIND=1 ARCH=64 DEVELOPER=1 COMPILER=gcc TEST_GROUP=2 TEST_GROUP_COUNT=6 SOURCE_CHECK_ONLY=false
+  - VALGRIND=1 ARCH=64 DEVELOPER=1 COMPILER=gcc TEST_GROUP=3 TEST_GROUP_COUNT=6 SOURCE_CHECK_ONLY=false
+  - VALGRIND=1 ARCH=64 DEVELOPER=1 COMPILER=gcc TEST_GROUP=4 TEST_GROUP_COUNT=6 SOURCE_CHECK_ONLY=false
+  - VALGRIND=1 ARCH=64 DEVELOPER=1 COMPILER=gcc TEST_GROUP=5 TEST_GROUP_COUNT=6 SOURCE_CHECK_ONLY=false
+  - VALGRIND=1 ARCH=64 DEVELOPER=1 COMPILER=gcc TEST_GROUP=6 TEST_GROUP_COUNT=6 SOURCE_CHECK_ONLY=false
 
 # Trusty (aka 14.04) is way way too old, so run in docker...
 script:
   - docker pull cdecker/lightning-ci:${ARCH}bit | tee
   - env | grep -E '^[A-Z_]+\=' | tee /tmp/envlist
-  - $SOURCE_CHECK_ONLY || docker run --rm=true --env-file=/tmp/envlist -v "${TRAVIS_BUILD_DIR}":/build -t cdecker/lightning-ci:${ARCH}bit make -j3 CC=${COMPILER} DEVELOPER=${DEVELOPER}
-  - $SOURCE_CHECK_ONLY || docker run --rm=true --env-file=/tmp/envlist -v "${TRAVIS_BUILD_DIR}":/build -t cdecker/lightning-ci:${ARCH}bit make CC=${COMPILER} check DEVELOPER=${DEVELOPER}
+  - docker run --rm=true --env-file=/tmp/envlist -v "${TRAVIS_BUILD_DIR}":/build -t cdecker/lightning-ci:${ARCH}bit ./configure
+  - $SOURCE_CHECK_ONLY || docker run --rm=true --env-file=/tmp/envlist -v "${TRAVIS_BUILD_DIR}":/build -t cdecker/lightning-ci:${ARCH}bit make -j3 
+  - $SOURCE_CHECK_ONLY || docker run --rm=true --env-file=/tmp/envlist -v "${TRAVIS_BUILD_DIR}":/build -t cdecker/lightning-ci:${ARCH}bit make check
 #  - (! $SOURCE_CHECK_ONLY) || git clone https://github.com/lightningnetwork/lightning-rfc.git
 #  - (! $SOURCE_CHECK_ONLY) || docker run --rm=true -v "${TRAVIS_BUILD_DIR}":/build -t cdecker/lightning-ci:${ARCH}bit make check-source BOLTDIR=lightning-rfc
   - (! $SOURCE_CHECK_ONLY) || docker run --rm=true -v "${TRAVIS_BUILD_DIR}":/build -t cdecker/lightning-ci:${ARCH}bit make clean
diff --git a/Makefile b/Makefile
index eaea8fe58b65..502a03c58de3 100644
--- a/Makefile
+++ b/Makefile
@@ -9,17 +9,13 @@ CCANDIR := ccan
 BOLTDIR := ../lightning-rfc/
 BOLTVERSION := 4f91f0bb2a9c176dda019f9c0618c10f9fa0acfd
 
-# If you don't have (working) valgrind.
-#NO_VALGRIND := 1
+-include config.vars
 
-ifneq ($(NO_VALGRIND),1)
-VALGRIND=valgrind -q --error-exitcode=7
-VALGRIND_TEST_ARGS = --track-origins=yes --leak-check=full --show-reachable=yes --errors-for-leak-kinds=all
+ifneq ($(VALGRIND),0)
+VG=valgrind -q --error-exitcode=7
+VG_TEST_ARGS = --track-origins=yes --leak-check=full --show-reachable=yes --errors-for-leak-kinds=all
 endif
 
-# By default, we are not in DEVELOPER mode, use DEVELOPER=1 on cmdline to override.
-DEVELOPER := 0
-
 ifeq ($(DEVELOPER),1)
 DEV_CFLAGS=-DDEVELOPER=1 -DCCAN_TAL_DEBUG=1 -DCCAN_TAKE_DEBUG=1
 else
@@ -175,10 +171,14 @@ CFLAGS = $(CPPFLAGS) $(CWARNFLAGS) $(CDEBUGFLAGS) -I $(CCANDIR) $(EXTERNAL_INCLU
 CONFIGURATOR_CC := $(CC)
 
 LDFLAGS = $(PIE_LDFLAGS)
-LDLIBS = -L/usr/local/lib -lm -lgmp -lsqlite3 $(COVFLAGS)
+LDLIBS = -L/usr/local/lib -lm -lgmp -lsqlite3 -lz $(COVFLAGS)
 
 default: all-programs all-test-programs
 
+config.vars ccan/config.h: configure
+	@if [ ! -f config.vars ]; then echo 'The 1990s are calling: use ./configure!' >&2; exit 1; fi
+	./configure --reconfigure
+
 include external/Makefile
 include bitcoin/Makefile
 include common/Makefile
@@ -215,7 +215,7 @@ ifndef PYTEST
 	@echo "py.test is required to run the integration tests, please install using 'pip3 install -r tests/requirements.txt'"
 	exit 1
 else
-	PYTHONPATH=contrib/pylightning:$$PYTHONPATH TEST_DEBUG=1 DEVELOPER=$(DEVELOPER) NO_VALGRIND=$(NO_VALGRIND) $(PYTEST) tests/ $(PYTEST_OPTS)
+	PYTHONPATH=contrib/pylightning:$$PYTHONPATH TEST_DEBUG=1 DEVELOPER=$(DEVELOPER) VALGRIND=$(VALGRIND) $(PYTEST) tests/ $(PYTEST_OPTS)
 endif
 
 # Keep includes in alpha order.
@@ -303,9 +303,6 @@ ALL_PROGRAMS += ccan/ccan/cdump/tools/cdump-enumstr
 # Can't add to ALL_OBJS, as that makes a circular dep.
 ccan/ccan/cdump/tools/cdump-enumstr.o: $(CCAN_HEADERS) Makefile
 
-ccan/config.h: ccan/tools/configurator/configurator Makefile
-	if $< --configurator-cc="$(CONFIGURATOR_CC)" $(CC) $(CFLAGS) > $@.new; then mv $@.new $@; else rm $@.new; exit 1; fi
-
 gen_version.h: FORCE
 	@(echo "#define VERSION \"`git describe --always --dirty=-modded`\"" && echo "#define BUILD_FEATURES \"$(FEATURES)\"") > $@.new
 	@if cmp $@.new $@ >/dev/null 2>&2; then rm -f $@.new; else mv $@.new $@; echo Version updated; fi
@@ -336,7 +333,7 @@ update-ccan:
 	mv ccan ccan.old
 	DIR=$$(pwd)/ccan; cd ../ccan && ./tools/create-ccan-tree -a $$DIR `cd $$DIR.old/ccan && find * -name _info | sed s,/_info,, | sort` $(CCAN_NEW)
 	mkdir -p ccan/tools/configurator
-	cp ../ccan/tools/configurator/configurator.c ccan/tools/configurator/
+	cp ../ccan/tools/configurator/configurator.c ../ccan/doc/configurator.1 ccan/tools/configurator/
 	$(MAKE) ccan/config.h
 	grep -v '^CCAN version:' ccan.old/README > ccan/README
 	echo CCAN version: `git -C ../ccan describe` >> ccan/README
@@ -357,7 +354,7 @@ clean: wire-clean
 	$(RM) $(CCAN_OBJS) $(CDUMP_OBJS) $(ALL_OBJS)
 	$(RM) $(ALL_PROGRAMS) $(ALL_PROGRAMS:=.o)
 	$(RM) $(ALL_TEST_PROGRAMS) $(ALL_TEST_PROGRAMS:=.o)
-	$(RM) ccan/config.h gen_*.h ccan/tools/configurator/configurator
+	$(RM) ccan/config.h gen_*.h config.vars ccan/tools/configurator/configurator
 	$(RM) ccan/ccan/cdump/tools/cdump-enumstr.o
 	$(RM) check-bolt tools/check-bolt tools/*.o
 	find . -name '*gcda' -delete
@@ -367,7 +364,7 @@ update-mocks/%: %
 	@tools/update-mocks.sh "$*"
 
 unittest/%: %
-	$(VALGRIND) $(VALGRIND_TEST_ARGS) $* > /dev/null
+	$(VG) $(VG_TEST_ARGS) $* > /dev/null
 
 # Installation directories
 prefix = /usr/local
diff --git a/README.md b/README.md
index 19513768c5fe..6f8066d23d13 100644
--- a/README.md
+++ b/README.md
@@ -58,7 +58,7 @@ For the impatient here's the gist of it for Ubuntu and Debian:
     sudo apt-get update
     sudo apt-get install -y \
       autoconf automake build-essential git libtool libgmp-dev \
-      libsqlite3-dev python python3 net-tools
+      libsqlite3-dev python python3 net-tools zlib1g-dev
     git clone https://github.com/ElementsProject/lightning.git
     cd lightning
     make
diff --git a/ccan/README b/ccan/README
index 69db7ae6452f..effdcf745209 100644
--- a/ccan/README
+++ b/ccan/README
@@ -1,3 +1,3 @@
 CCAN imported from http://ccodearchive.net.
 
-CCAN version: init-2423-g696c9b68
+CCAN version: init-2432-gd830ca0e
diff --git a/ccan/tools/configurator/configurator.1 b/ccan/tools/configurator/configurator.1
new file mode 100644
index 000000000000..aaa92c527f9e
--- /dev/null
+++ b/ccan/tools/configurator/configurator.1
@@ -0,0 +1,216 @@
+'\" t
+.\"     Title: configurator
+.\"    Author: [see the "AUTHOR" section]
+.\" Generator: DocBook XSL Stylesheets v1.79.1 <http://docbook.sf.net/>
+.\"      Date: 03/01/2018
+.\"    Manual: \ \&
+.\"    Source: \ \&
+.\"  Language: English
+.\"
+.TH "CONFIGURATOR" "1" "03/01/2018" "\ \&" "\ \&"
+.\" -----------------------------------------------------------------
+.\" * Define some portability stuff
+.\" -----------------------------------------------------------------
+.\" ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+.\" http://bugs.debian.org/507673
+.\" http://lists.gnu.org/archive/html/groff/2009-02/msg00013.html
+.\" ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+.ie \n(.g .ds Aq \(aq
+.el       .ds Aq '
+.\" -----------------------------------------------------------------
+.\" * set default formatting
+.\" -----------------------------------------------------------------
+.\" disable hyphenation
+.nh
+.\" disable justification (adjust text to left margin only)
+.ad l
+.\" -----------------------------------------------------------------
+.\" * MAIN CONTENT STARTS HERE *
+.\" -----------------------------------------------------------------
+.SH "NAME"
+configurator \- Generate a simple config\&.h or variable file
+.SH "SYNOPSIS"
+.sp
+\fBconfigurator\fR [\fIOPTIONS\fR] [\fICC\fR] [\fICFLAGS\fR\&...]
+.SH "DESCRIPTION"
+.sp
+\fBconfigurator\fR is a standalone C program which evaluates the C environment using code snippets\&.
+.sp
+The C compiler (and flags) can be provided on the command\-line, otherwise built\-in defaults are used\&.
+.sp
+It has a builtin set of tests, to which more can be added\&. By default it produces a C header file to standard output, but it can also produce a file containing simple "key=value" lines suitable for parsing by \fBsh\fR or \fBmake\fR\&.
+.SH "OPTIONS"
+.PP
+\fB\-v\fR
+.RS 4
+Print out every test result; specified twice, print out each test too\&.
+.RE
+.PP
+\fB\-vv\fR
+.RS 4
+Shortcut for two
+\fB\-v\fR
+options\&.
+.RE
+.PP
+\fB\-\-var\-file=<file>\fR
+.RS 4
+Output results in format
+\fI<key>=<value>\fR
+to
+\fI<file>\fR, or stdout if
+\fI<file>\fR
+is
+\fI\-\fR\&. Default is not to output this\&.
+.RE
+.PP
+\fB\-\-header\-file=<file>\fR
+.RS 4
+Output C\-style header to
+\fI<file>\fR
+instead out stdout\&.
+.RE
+.PP
+\fB\-\-autotools\-style\fR
+.RS 4
+Produce output to stdout like autotools\*(Aq configure script\&. This usually means you want to use
+\fB\-\-header\-file\fR
+so that doesn\(cqt mix with stdout\&.
+.RE
+.PP
+\fB\-O<outflag>\fR
+.RS 4
+Override option to set compiler output file\&.
+.RE
+.PP
+\fB\-\-configurator\-cc=<command>\fR
+.RS 4
+This gives the real compiler command to use for tests, instead of the first commandline argument or the default\&.
+.RE
+.PP
+\fB\-\-extra\-tests\fR
+.RS 4
+Read additional tests from stdin, see
+\fIEXTRA TESTS\fR
+below\&.
+.RE
+.SH "OUTPUT"
+.sp
+The header output is \fI#ifndef/#define\fR idempotent\-wrapped using \fICCAN_CONFIG_H\fR, and defines \fI_GNU_SOURCE\fR\&. It also defines \fICCAN_COMPILER\fR, \fICCAN_CFLAGS\fR and \fICCAN_OUTPUT_EXE_CFLAG\fR as either the built\-in definitions or those provided on the command line\&. The remainder is \fI#define\fR of the test names followed by a \fI0\fR or \fI1\fR: note that this means you should use \fI#if\fR not \fI#ifdef\fR to test features in your C programs!
+.sp
+The var\-file output is simply the test names followed by \fI=1\fR or \fI=0\fR\&.
+.SH "EXTRA TESTS"
+.sp
+Extra tests must be formatted as \fI<key>=<value>\fR pairs, with leading whitespace and \fI#\fR lines ignored\&.
+.sp
+The first three lines are always the same:
+.PP
+\fBvar=<varname>\fR
+.RS 4
+Define the variable set by the test, e\&.g\&.
+\fIvar=HAVE_FOO\fR\&.
+.RE
+.PP
+\fBdesc=<description>\fR
+.RS 4
+The description printed out with
+\fB\-\-autotools\-style\fR, e\&.g\&.
+\fIfoo support\fR\&.
+.RE
+.PP
+\fBstyle=<style>\fR
+.RS 4
+The set of strings defining how to treat the code snippet\&. It must include one of
+\fIOUTSIDE_MAIN\fR,
+\fIDEFINES_FUNC\fR,
+\fIINSIDE_MAIN\fR
+or
+\fIDEFINES_EVERYTHING\fR
+which control the boilerplate to surround the file, and may include
+\fIEXECUTE\fR
+or both
+\fIEXECUTE\fR
+and
+\fIMAY_NOT_COMPILE\fR\&. e\&.g\&.
+\fIINSIDE_MAIN|EXECUTE\fR\&.
+.RE
+.sp
+The following styles are defined:
+.PP
+\fBOUTSIDE_MAIN\fR
+.RS 4
+means we put a simple boilerplate main below it\&.
+.RE
+.PP
+\fBDEFINES_FUNC\fR
+.RS 4
+put a simple boilerplate main below it, which references
+\fIfunc\fR
+(to avoid any unused warnings)\&.
+.RE
+.PP
+\fBINSIDE_MAIN\fR
+.RS 4
+put this inside main()\&. This also means it must exit with status 0 if it compiles, unless
+\fBEXECUTE\fR
+is added\&.
+.RE
+.PP
+\fBDEFINES_EVERYTHING\fR
+.RS 4
+don\(cqt add any boilerplate at all\&.
+.RE
+.PP
+\fBEXECUTE\fR
+.RS 4
+this is an execution test; it must compile, but may not exit with status 0 when run\&.
+.RE
+.PP
+\fBMAY_NOT_COMPILE\fR
+.RS 4
+Only useful with EXECUTE: don\(cqt get upset if it doesn\(cqt compile\&.
+.RE
+.sp
+The following lines are optional, and may follow in any order:
+.PP
+\fBdepends=<varnames>\fR
+.RS 4
+A space\-separates set of vars which must pass to even try to pass this one\&. If the var begins with
+\fI!\fR
+then the dependency must fail to try this one\&. e\&.g\&.
+\fIdepends=HAVE_UCONTEXT !HAVE_VALGRIND_MEMCHECK_H\fR\&.
+.RE
+.PP
+\fBlink=<linkargs>\fR
+.RS 4
+Extra arguments for linking with this test, e\&.g\&.
+\fIlink=\-lrt\fR\&.
+.RE
+.PP
+\fBflags=<cflags>\fR
+.RS 4
+Extra flags for compiling with this test, e\&.g\&.
+\fIflags=\-fopenmp\fR\&.
+.RE
+.PP
+\fBoverrides=<varname>\fR
+.RS 4
+Tests to force passing if this one passes\&. e\&.g\&.
+\fIoverrides=HAVE_SOME_FOO\fR\&.
+.RE
+.sp
+The final line is the code to test, itself, either as a single \fIcode=<oneline>\fR or as multiple lines starting with \fIcode=\fR and ending with \fI/*END*/\fR on a line by itself\&. e\&.g\&. \fIcode=return 0;\fR\&.
+.SH "EXIT STATUS"
+.sp
+It will exit with non\-zero status if it has a problem\&. \fB1\fR means bad commandline options\&. \fB2\fR means some operational problem creating and running tests\&. \fB3\fR means a bad test\&. \fB4\fR means failure to parse an extra test\&.
+.SH "AUTHOR"
+.sp
+Rusty Russell wrote \fBconfigurator\fR\&.
+.SH "RESOURCES"
+.sp
+Main web site: http://ccodearchive\&.net/
+.sp
+Wiki: https://github\&.com/rustyrussell/ccan/wiki/
+.SH "COPYING"
+.sp
+This program is under the MIT\-style BSD license; see code for details\&.
diff --git a/ccan/tools/configurator/configurator.c b/ccan/tools/configurator/configurator.c
index 2e5b09c2b984..239e91c962b9 100644
--- a/ccan/tools/configurator/configurator.c
+++ b/ccan/tools/configurator/configurator.c
@@ -26,12 +26,18 @@
  */
 #define _POSIX_C_SOURCE 200809L                /* For pclose, popen, strdup */
 
+#define EXIT_BAD_USAGE		  1
+#define EXIT_TROUBLE_RUNNING	  2
+#define EXIT_BAD_TEST		  3
+#define EXIT_BAD_INPUT		  4
+
 #include <errno.h>
 #include <stdio.h>
 #include <stdarg.h>
 #include <stdbool.h>
 #include <stdlib.h>
 #include <string.h>
+#include <unistd.h>
 
 #ifdef _MSC_VER
 #define popen _popen
@@ -65,19 +71,31 @@
 
 static const char *progname = "";
 static int verbose;
-
-enum test_style {
-	OUTSIDE_MAIN		= 0x1,
-	DEFINES_FUNC		= 0x2,
-	INSIDE_MAIN		= 0x4,
-	DEFINES_EVERYTHING	= 0x8,
-	MAY_NOT_COMPILE		= 0x10,
-	EXECUTE			= 0x8000
-};
+static bool like_a_libtool = false;
 
 struct test {
 	const char *name;
-	enum test_style style;
+	const char *desc;
+	/*
+	 * Template style flags (pick one):
+	 * OUTSIDE_MAIN:
+	 * - put a simple boilerplate main below it.
+	 * DEFINES_FUNC:
+	 * - defines a static function called func; adds ref to avoid warnings
+	 * INSIDE_MAIN:
+	 * - put this inside main().
+	 * DEFINES_EVERYTHING:
+	 * - don't add any boilerplate at all.
+	 *
+	 * Execution flags:
+	 * EXECUTE:
+	 * - a runtime test; must compile, exit 0 means flag is set.
+	 * MAY_NOT_COMPILE:
+	 * - Only useful with EXECUTE: don't get upset if it doesn't compile.
+	 * <nothing>:
+	 * - a compile test, if it compiles must run and exit 0.
+	 */
+	const char *style;
 	const char *depends;
 	const char *link;
 	const char *fragment;
@@ -87,15 +105,21 @@ struct test {
 	bool answer;
 };
 
-static struct test tests[] = {
-	{ "HAVE_32BIT_OFF_T", DEFINES_EVERYTHING|EXECUTE|MAY_NOT_COMPILE, NULL, NULL,
+/* Terminated by a NULL name */
+static struct test *tests;
+
+static const struct test base_tests[] = {
+	{ "HAVE_32BIT_OFF_T", "off_t is 32 bits",
+	  "DEFINES_EVERYTHING|EXECUTE|MAY_NOT_COMPILE", NULL, NULL,
 	  "#include <sys/types.h>\n"
 	  "int main(void) {\n"
 	  "	return sizeof(off_t) == 4 ? 0 : 1;\n"
 	  "}\n" },
-	{ "HAVE_ALIGNOF", INSIDE_MAIN, NULL, NULL,
+	{ "HAVE_ALIGNOF", "__alignof__ support",
+	  "INSIDE_MAIN", NULL, NULL,
 	  "return __alignof__(double) > 0 ? 0 : 1;" },
-	{ "HAVE_ASPRINTF", DEFINES_FUNC, NULL, NULL,
+	{ "HAVE_ASPRINTF", "asprintf() declaration",
+	  "DEFINES_FUNC", NULL, NULL,
 	  "#ifndef _GNU_SOURCE\n"
 	  "#define _GNU_SOURCE\n"
 	  "#endif\n"
@@ -106,85 +130,114 @@ static struct test tests[] = {
 	  "		p = NULL;\n"
 	  "	return p;\n"
 	  "}" },
-	{ "HAVE_ATTRIBUTE_COLD", DEFINES_FUNC, NULL, NULL,
+	{ "HAVE_ATTRIBUTE_COLD", "__attribute__((cold)) support",
+	  "DEFINES_FUNC", NULL, NULL,
 	  "static int __attribute__((cold)) func(int x) { return x; }" },
-	{ "HAVE_ATTRIBUTE_CONST", DEFINES_FUNC, NULL, NULL,
+	{ "HAVE_ATTRIBUTE_CONST", "__attribute__((const)) support",
+	  "DEFINES_FUNC", NULL, NULL,
 	  "static int __attribute__((const)) func(int x) { return x; }" },
-	{ "HAVE_ATTRIBUTE_PURE", DEFINES_FUNC, NULL, NULL,
+	{ "HAVE_ATTRIBUTE_PURE", "__attribute__((pure)) support",
+	  "DEFINES_FUNC", NULL, NULL,
 	  "static int __attribute__((pure)) func(int x) { return x; }" },
-	{ "HAVE_ATTRIBUTE_MAY_ALIAS", OUTSIDE_MAIN, NULL, NULL,
+	{ "HAVE_ATTRIBUTE_MAY_ALIAS", "__attribute__((may_alias)) support",
+	  "OUTSIDE_MAIN", NULL, NULL,
 	  "typedef short __attribute__((__may_alias__)) short_a;" },
-	{ "HAVE_ATTRIBUTE_NORETURN", DEFINES_FUNC, NULL, NULL,
+	{ "HAVE_ATTRIBUTE_NORETURN", "__attribute__((noreturn)) support",
+	  "DEFINES_FUNC", NULL, NULL,
 	  "#include <stdlib.h>\n"
 	  "static void __attribute__((noreturn)) func(int x) { exit(x); }" },
-	{ "HAVE_ATTRIBUTE_PRINTF", DEFINES_FUNC, NULL, NULL,
+	{ "HAVE_ATTRIBUTE_PRINTF", "__attribute__ format printf support",
+	  "DEFINES_FUNC", NULL, NULL,
 	  "static void __attribute__((format(__printf__, 1, 2))) func(const char *fmt, ...) { (void)fmt; }" },
-	{ "HAVE_ATTRIBUTE_UNUSED", OUTSIDE_MAIN, NULL, NULL,
+	{ "HAVE_ATTRIBUTE_UNUSED", "__attribute__((unused)) support",
+	  "OUTSIDE_MAIN", NULL, NULL,
 	  "static int __attribute__((unused)) func(int x) { return x; }" },
-	{ "HAVE_ATTRIBUTE_USED", OUTSIDE_MAIN, NULL, NULL,
+	{ "HAVE_ATTRIBUTE_USED", "__attribute__((used)) support",
+	  "OUTSIDE_MAIN", NULL, NULL,
 	  "static int __attribute__((used)) func(int x) { return x; }" },
-	{ "HAVE_BACKTRACE", DEFINES_FUNC, NULL, NULL,
+	{ "HAVE_BACKTRACE", "backtrace() in <execinfo.h>",
+	  "DEFINES_FUNC", NULL, NULL,
 	  "#include <execinfo.h>\n"
 	  "static int func(int x) {"
 	  "	void *bt[10];\n"
 	  "	return backtrace(bt, 10) < x;\n"
 	  "}" },
-	{ "HAVE_BIG_ENDIAN", INSIDE_MAIN|EXECUTE, NULL, NULL,
+	{ "HAVE_BIG_ENDIAN", "big endian",
+	  "INSIDE_MAIN|EXECUTE", NULL, NULL,
 	  "union { int i; char c[sizeof(int)]; } u;\n"
 	  "u.i = 0x01020304;\n"
 	  "return u.c[0] == 0x01 && u.c[1] == 0x02 && u.c[2] == 0x03 && u.c[3] == 0x04 ? 0 : 1;" },
-	{ "HAVE_BSWAP_64", DEFINES_FUNC, "HAVE_BYTESWAP_H", NULL,
+	{ "HAVE_BSWAP_64", "bswap64 in byteswap.h",
+	  "DEFINES_FUNC", "HAVE_BYTESWAP_H", NULL,
 	  "#include <byteswap.h>\n"
 	  "static int func(int x) { return bswap_64(x); }" },
-	{ "HAVE_BUILTIN_CHOOSE_EXPR", INSIDE_MAIN, NULL, NULL,
+	{ "HAVE_BUILTIN_CHOOSE_EXPR", "__builtin_choose_expr support",
+	  "INSIDE_MAIN", NULL, NULL,
 	  "return __builtin_choose_expr(1, 0, \"garbage\");" },
-	{ "HAVE_BUILTIN_CLZ", INSIDE_MAIN, NULL, NULL,
+	{ "HAVE_BUILTIN_CLZ", "__builtin_clz support",
+	  "INSIDE_MAIN", NULL, NULL,
 	  "return __builtin_clz(1) == (sizeof(int)*8 - 1) ? 0 : 1;" },
-	{ "HAVE_BUILTIN_CLZL", INSIDE_MAIN, NULL, NULL,
+	{ "HAVE_BUILTIN_CLZL", "__builtin_clzl support",
+	  "INSIDE_MAIN", NULL, NULL,
 	  "return __builtin_clzl(1) == (sizeof(long)*8 - 1) ? 0 : 1;" },
-	{ "HAVE_BUILTIN_CLZLL", INSIDE_MAIN, NULL, NULL,
+	{ "HAVE_BUILTIN_CLZLL", "__builtin_clzll support",
+	  "INSIDE_MAIN", NULL, NULL,
 	  "return __builtin_clzll(1) == (sizeof(long long)*8 - 1) ? 0 : 1;" },
-	{ "HAVE_BUILTIN_CTZ", INSIDE_MAIN, NULL, NULL,
+	{ "HAVE_BUILTIN_CTZ", "__builtin_ctz support",
+	  "INSIDE_MAIN", NULL, NULL,
 	  "return __builtin_ctz(1 << (sizeof(int)*8 - 1)) == (sizeof(int)*8 - 1) ? 0 : 1;" },
-	{ "HAVE_BUILTIN_CTZL", INSIDE_MAIN, NULL, NULL,
+	{ "HAVE_BUILTIN_CTZL", "__builtin_ctzl support",
+	  "INSIDE_MAIN", NULL, NULL,
 	  "return __builtin_ctzl(1UL << (sizeof(long)*8 - 1)) == (sizeof(long)*8 - 1) ? 0 : 1;" },
-	{ "HAVE_BUILTIN_CTZLL", INSIDE_MAIN, NULL, NULL,
+	{ "HAVE_BUILTIN_CTZLL", "__builtin_ctzll support",
+	  "INSIDE_MAIN", NULL, NULL,
 	  "return __builtin_ctzll(1ULL << (sizeof(long long)*8 - 1)) == (sizeof(long long)*8 - 1) ? 0 : 1;" },
-	{ "HAVE_BUILTIN_CONSTANT_P", INSIDE_MAIN, NULL, NULL,
+	{ "HAVE_BUILTIN_CONSTANT_P", "__builtin_constant_p support",
+	  "INSIDE_MAIN", NULL, NULL,
 	  "return __builtin_constant_p(1) ? 0 : 1;" },
-	{ "HAVE_BUILTIN_EXPECT", INSIDE_MAIN, NULL, NULL,
+	{ "HAVE_BUILTIN_EXPECT", "__builtin_expect support",
+	  "INSIDE_MAIN", NULL, NULL,
 	  "return __builtin_expect(argc == 1, 1) ? 0 : 1;" },
-	{ "HAVE_BUILTIN_FFS", INSIDE_MAIN, NULL, NULL,
+	{ "HAVE_BUILTIN_FFS", "__builtin_ffs support",
+	  "INSIDE_MAIN", NULL, NULL,
 	  "return __builtin_ffs(0) == 0 ? 0 : 1;" },
-	{ "HAVE_BUILTIN_FFSL", INSIDE_MAIN, NULL, NULL,
+	{ "HAVE_BUILTIN_FFSL", "__builtin_ffsl support",
+	  "INSIDE_MAIN", NULL, NULL,
 	  "return __builtin_ffsl(0L) == 0 ? 0 : 1;" },
-	{ "HAVE_BUILTIN_FFSLL", INSIDE_MAIN, NULL, NULL,
+	{ "HAVE_BUILTIN_FFSLL", "__builtin_ffsll support",
+	  "INSIDE_MAIN", NULL, NULL,
 	  "return __builtin_ffsll(0LL) == 0 ? 0 : 1;" },
-	{ "HAVE_BUILTIN_POPCOUNT", INSIDE_MAIN, NULL, NULL,
+	{ "HAVE_BUILTIN_POPCOUNT", "__builtin_popcount support",
+	  "INSIDE_MAIN", NULL, NULL,
 	  "return __builtin_popcount(255) == 8 ? 0 : 1;" },
-	{ "HAVE_BUILTIN_POPCOUNTL", INSIDE_MAIN, NULL, NULL,
+	{ "HAVE_BUILTIN_POPCOUNTL",  "__builtin_popcountl support",
+	  "INSIDE_MAIN", NULL, NULL,
 	  "return __builtin_popcountl(255L) == 8 ? 0 : 1;" },
-	{ "HAVE_BUILTIN_POPCOUNTLL", INSIDE_MAIN, NULL, NULL,
+	{ "HAVE_BUILTIN_POPCOUNTLL", "__builtin_popcountll support",
+	  "INSIDE_MAIN", NULL, NULL,
 	  "return __builtin_popcountll(255LL) == 8 ? 0 : 1;" },
-	{ "HAVE_BUILTIN_TYPES_COMPATIBLE_P", INSIDE_MAIN, NULL, NULL,
+	{ "HAVE_BUILTIN_TYPES_COMPATIBLE_P", "__builtin_types_compatible_p support",
+	  "INSIDE_MAIN", NULL, NULL,
 	  "return __builtin_types_compatible_p(char *, int) ? 1 : 0;" },
-	{ "HAVE_ICCARM_INTRINSICS", DEFINES_FUNC, NULL, NULL,
+	{ "HAVE_ICCARM_INTRINSICS", "<intrinsics.h>",
+	  "DEFINES_FUNC", NULL, NULL,
 	  "#include <intrinsics.h>\n"
 	  "int func(int v) {\n"
 	  "	return __CLZ(__RBIT(v));\n"
 	  "}" },
-	{ "HAVE_BYTESWAP_H", OUTSIDE_MAIN, NULL, NULL,
+	{ "HAVE_BYTESWAP_H", "<byteswap.h>",
+	  "OUTSIDE_MAIN", NULL, NULL,
 	  "#include <byteswap.h>\n" },
-	{ "HAVE_CLOCK_GETTIME",
-	  DEFINES_FUNC, "HAVE_STRUCT_TIMESPEC", NULL,
+	{ "HAVE_CLOCK_GETTIME", "clock_gettime() declaration",
+	  "DEFINES_FUNC", "HAVE_STRUCT_TIMESPEC", NULL,
 	  "#include <time.h>\n"
 	  "static struct timespec func(void) {\n"
 	  "	struct timespec ts;\n"
 	  "	clock_gettime(CLOCK_REALTIME, &ts);\n"
 	  "	return ts;\n"
 	  "}\n" },
-	{ "HAVE_CLOCK_GETTIME_IN_LIBRT",
-	  DEFINES_FUNC,
+	{ "HAVE_CLOCK_GETTIME_IN_LIBRT", "clock_gettime() in librt",
+	  "DEFINES_FUNC",
 	  "HAVE_STRUCT_TIMESPEC !HAVE_CLOCK_GETTIME",
 	  "-lrt",
 	  "#include <time.h>\n"
@@ -195,10 +248,12 @@ static struct test tests[] = {
 	  "}\n",
 	  /* This means HAVE_CLOCK_GETTIME, too */
 	  "HAVE_CLOCK_GETTIME" },
-	{ "HAVE_COMPOUND_LITERALS", INSIDE_MAIN, NULL, NULL,
+	{ "HAVE_COMPOUND_LITERALS", "compound literal support",
+	  "INSIDE_MAIN", NULL, NULL,
 	  "int *foo = (int[]) { 1, 2, 3, 4 };\n"
 	  "return foo[0] ? 0 : 1;" },
-	{ "HAVE_FCHDIR", DEFINES_EVERYTHING|EXECUTE|MAY_NOT_COMPILE, NULL, NULL,
+	{ "HAVE_FCHDIR", "fchdir support",
+	  "DEFINES_EVERYTHING|EXECUTE|MAY_NOT_COMPILE", NULL, NULL,
 	  "#include <sys/types.h>\n"
 	  "#include <sys/stat.h>\n"
 	  "#include <fcntl.h>\n"
@@ -207,7 +262,8 @@ static struct test tests[] = {
 	  "	int fd = open(\"..\", O_RDONLY);\n"
 	  "	return fchdir(fd) == 0 ? 0 : 1;\n"
 	  "}\n" },
-	{ "HAVE_ERR_H", DEFINES_FUNC, NULL, NULL,
+	{ "HAVE_ERR_H", "<err.h>",
+	  "DEFINES_FUNC", NULL, NULL,
 	  "#include <err.h>\n"
 	  "static void func(int arg) {\n"
 	  "	if (arg == 0)\n"
@@ -219,33 +275,40 @@ static struct test tests[] = {
 	  "	if (arg == 4)\n"
 	  "		warnx(\"warn %u\", arg);\n"
 	  "}\n" },
-	{ "HAVE_FILE_OFFSET_BITS", DEFINES_EVERYTHING|EXECUTE|MAY_NOT_COMPILE,
+	{ "HAVE_FILE_OFFSET_BITS", "_FILE_OFFSET_BITS to get 64-bit offsets",
+	  "DEFINES_EVERYTHING|EXECUTE|MAY_NOT_COMPILE",
 	  "HAVE_32BIT_OFF_T", NULL,
 	  "#define _FILE_OFFSET_BITS 64\n"
 	  "#include <sys/types.h>\n"
 	  "int main(void) {\n"
 	  "	return sizeof(off_t) == 8 ? 0 : 1;\n"
 	  "}\n" },
-	{ "HAVE_FOR_LOOP_DECLARATION", INSIDE_MAIN, NULL, NULL,
+	{ "HAVE_FOR_LOOP_DECLARATION", "for loop declaration support",
+	  "INSIDE_MAIN", NULL, NULL,
 	  "int ret = 1;\n"
 	  "for (int i = 0; i < argc; i++) { ret = 0; };\n"
 	  "return ret;" },
-	{ "HAVE_FLEXIBLE_ARRAY_MEMBER", OUTSIDE_MAIN, NULL, NULL,
+	{ "HAVE_FLEXIBLE_ARRAY_MEMBER", "flexible array member support",
+	  "OUTSIDE_MAIN", NULL, NULL,
 	  "struct foo { unsigned int x; int arr[]; };" },
-	{ "HAVE_GETPAGESIZE", DEFINES_FUNC, NULL, NULL,
+	{ "HAVE_GETPAGESIZE", "getpagesize() in <unistd.h>",
+	  "DEFINES_FUNC", NULL, NULL,
 	  "#include <unistd.h>\n"
 	  "static int func(void) { return getpagesize(); }" },
-	{ "HAVE_ISBLANK", DEFINES_FUNC, NULL, NULL,
+	{ "HAVE_ISBLANK", "isblank() in <ctype.h>",
+	  "DEFINES_FUNC", NULL, NULL,
 	  "#ifndef _GNU_SOURCE\n"
 	  "#define _GNU_SOURCE\n"
 	  "#endif\n"
 	  "#include <ctype.h>\n"
 	  "static int func(void) { return isblank(' '); }" },
-	{ "HAVE_LITTLE_ENDIAN", INSIDE_MAIN|EXECUTE, NULL, NULL,
+	{ "HAVE_LITTLE_ENDIAN", "little endian",
+	  "INSIDE_MAIN|EXECUTE", NULL, NULL,
 	  "union { int i; char c[sizeof(int)]; } u;\n"
 	  "u.i = 0x01020304;\n"
 	  "return u.c[0] == 0x04 && u.c[1] == 0x03 && u.c[2] == 0x02 && u.c[3] == 0x01 ? 0 : 1;" },
-	{ "HAVE_MEMMEM", DEFINES_FUNC, NULL, NULL,
+	{ "HAVE_MEMMEM", "memmem in <string.h>",
+	  "DEFINES_FUNC", NULL, NULL,
 	  "#ifndef _GNU_SOURCE\n"
 	  "#define _GNU_SOURCE\n"
 	  "#endif\n"
@@ -253,7 +316,8 @@ static struct test tests[] = {
 	  "static void *func(void *h, size_t hl, void *n, size_t nl) {\n"
 	  "return memmem(h, hl, n, nl);"
 	  "}\n", },
-	{ "HAVE_MEMRCHR", DEFINES_FUNC, NULL, NULL,
+	{ "HAVE_MEMRCHR", "memrchr in <string.h>",
+	  "DEFINES_FUNC", NULL, NULL,
 	  "#ifndef _GNU_SOURCE\n"
 	  "#define _GNU_SOURCE\n"
 	  "#endif\n"
@@ -261,20 +325,22 @@ static struct test tests[] = {
 	  "static void *func(void *s, int c, size_t n) {\n"
 	  "return memrchr(s, c, n);"
 	  "}\n", },
-	{ "HAVE_MMAP", DEFINES_FUNC, NULL, NULL,
+	{ "HAVE_MMAP", "mmap() declaration",
+	  "DEFINES_FUNC", NULL, NULL,
 	  "#include <sys/mman.h>\n"
 	  "static void *func(int fd) {\n"
 	  "	return mmap(0, 65536, PROT_READ, MAP_SHARED, fd, 0);\n"
 	  "}" },
-	{ "HAVE_PROC_SELF_MAPS", DEFINES_EVERYTHING|EXECUTE|MAY_NOT_COMPILE, NULL, NULL,
+	{ "HAVE_PROC_SELF_MAPS", "/proc/self/maps exists",
+	  "DEFINES_EVERYTHING|EXECUTE|MAY_NOT_COMPILE", NULL, NULL,
 	  "#include <sys/types.h>\n"
 	  "#include <sys/stat.h>\n"
 	  "#include <fcntl.h>\n"
 	  "int main(void) {\n"
 	  "	return open(\"/proc/self/maps\", O_RDONLY) != -1 ? 0 : 1;\n"
 	  "}\n" },
-	{ "HAVE_QSORT_R_PRIVATE_LAST",
-	  DEFINES_EVERYTHING|EXECUTE|MAY_NOT_COMPILE, NULL, NULL,
+	{ "HAVE_QSORT_R_PRIVATE_LAST", "qsort_r cmp takes trailing arg",
+	  "DEFINES_EVERYTHING|EXECUTE|MAY_NOT_COMPILE", NULL, NULL,
 	  "#ifndef _GNU_SOURCE\n"
 	  "#define _GNU_SOURCE\n"
 	  "#endif\n"
@@ -288,21 +354,22 @@ static struct test tests[] = {
 	  " qsort_r(array, 3, sizeof(int), cmp, &called);\n"
 	  " return called && array[0] == 2 && array[1] == 5 && array[2] == 9 ? 0 : 1;\n"
 	  "}\n" },
-	{ "HAVE_STRUCT_TIMESPEC",
-	  DEFINES_FUNC, NULL, NULL,
+	{ "HAVE_STRUCT_TIMESPEC", "struct timespec declaration",
+	  "DEFINES_FUNC", NULL, NULL,
 	  "#include <time.h>\n"
 	  "static void func(void) {\n"
 	  "	struct timespec ts;\n"
 	  "	ts.tv_sec = ts.tv_nsec = 1;\n"
 	  "}\n" },
-	{ "HAVE_SECTION_START_STOP",
-	  DEFINES_FUNC, NULL, NULL,
+	{ "HAVE_SECTION_START_STOP", "__attribute__((section)) and __start/__stop",
+	  "DEFINES_FUNC", NULL, NULL,
 	  "static void *__attribute__((__section__(\"mysec\"))) p = &p;\n"
 	  "static int func(void) {\n"
 	  "	extern void *__start_mysec[], *__stop_mysec[];\n"
 	  "	return __stop_mysec - __start_mysec;\n"
 	  "}\n" },
-	{ "HAVE_STACK_GROWS_UPWARDS", DEFINES_EVERYTHING|EXECUTE, NULL, NULL,
+	{ "HAVE_STACK_GROWS_UPWARDS", "stack grows upwards",
+	  "DEFINES_EVERYTHING|EXECUTE", NULL, NULL,
 	  "#include <stddef.h>\n"
 	  "static ptrdiff_t nest(const void *base, unsigned int i)\n"
 	  "{\n"
@@ -314,17 +381,23 @@ static struct test tests[] = {
 	  "	(void)argv;\n"
 	  "	return (nest(&argc, argc) > 0) ? 0 : 1;\n"
 	  "}\n" },
-	{ "HAVE_STATEMENT_EXPR", INSIDE_MAIN, NULL, NULL,
+	{ "HAVE_STATEMENT_EXPR", "statement expression support",
+	  "INSIDE_MAIN", NULL, NULL,
 	  "return ({ int x = argc; x == argc ? 0 : 1; });" },
-	{ "HAVE_SYS_FILIO_H", OUTSIDE_MAIN, NULL, NULL, /* Solaris needs this for FIONREAD */
+	{ "HAVE_SYS_FILIO_H", "<sys/filio.h>",
+	  "OUTSIDE_MAIN", NULL, NULL, /* Solaris needs this for FIONREAD */
 	  "#include <sys/filio.h>\n" },
-	{ "HAVE_SYS_TERMIOS_H", OUTSIDE_MAIN, NULL, NULL,
+	{ "HAVE_SYS_TERMIOS_H", "<sys/termios.h>",
+	  "OUTSIDE_MAIN", NULL, NULL,
 	  "#include <sys/termios.h>\n" },
-	{ "HAVE_SYS_UNISTD_H", OUTSIDE_MAIN, NULL, NULL,
+	{ "HAVE_SYS_UNISTD_H", "<sys/unistd.h>",
+	  "OUTSIDE_MAIN", NULL, NULL,
 	  "#include <sys/unistd.h>\n" },
-	{ "HAVE_TYPEOF", INSIDE_MAIN, NULL, NULL,
+	{ "HAVE_TYPEOF", "__typeof__ support",
+	  "INSIDE_MAIN", NULL, NULL,
 	  "__typeof__(argc) i; i = argc; return i == argc ? 0 : 1;" },
-	{ "HAVE_UNALIGNED_ACCESS", DEFINES_EVERYTHING|EXECUTE, NULL, NULL,
+	{ "HAVE_UNALIGNED_ACCESS", "unaligned access to int",
+	  "DEFINES_EVERYTHING|EXECUTE", NULL, NULL,
 	  "#include <string.h>\n"
 	  "int main(int argc, char *argv[]) {\n"
 	  "	(void)argc;\n"
@@ -333,28 +406,33 @@ static struct test tests[] = {
 	  "	int *x = (int *)pad, *y = (int *)(pad + 1);\n"
 	  "	return *x == *y;\n"
 	  "}\n" },
-	{ "HAVE_UTIME", DEFINES_FUNC, NULL, NULL,
+	{ "HAVE_UTIME", "utime() declaration",
+	  "DEFINES_FUNC", NULL, NULL,
 	  "#include <sys/types.h>\n"
 	  "#include <utime.h>\n"
 	  "static int func(const char *filename) {\n"
 	  "	struct utimbuf times = { 0 };\n"
 	  "	return utime(filename, &times);\n"
 	  "}" },
-	{ "HAVE_WARN_UNUSED_RESULT", DEFINES_FUNC, NULL, NULL,
+	{ "HAVE_WARN_UNUSED_RESULT", "__attribute__((warn_unused_result))",
+	  "DEFINES_FUNC", NULL, NULL,
 	  "#include <sys/types.h>\n"
 	  "#include <utime.h>\n"
 	  "static __attribute__((warn_unused_result)) int func(int i) {\n"
 	  "	return i + 1;\n"
 	  "}" },
-	{ "HAVE_OPENMP", INSIDE_MAIN, NULL, NULL,
+	{ "HAVE_OPENMP", "#pragma omp and -fopenmp support",
+	  "INSIDE_MAIN", NULL, NULL,
 	  "int i;\n"
 	  "#pragma omp parallel for\n"
 	  "for(i = 0; i < 0; i++) {};\n"
 	  "return 0;\n",
 	  "-Werror -fopenmp" },
-	{ "HAVE_VALGRIND_MEMCHECK_H", OUTSIDE_MAIN, NULL, NULL,
+	{ "HAVE_VALGRIND_MEMCHECK_H", "<valgrind/memcheck.h>",
+	  "OUTSIDE_MAIN", NULL, NULL,
 	  "#include <valgrind/memcheck.h>\n" },
-	{ "HAVE_UCONTEXT", DEFINES_EVERYTHING|EXECUTE|MAY_NOT_COMPILE,
+	{ "HAVE_UCONTEXT", "working <ucontext.h",
+	  "DEFINES_EVERYTHING|EXECUTE|MAY_NOT_COMPILE",
 	  NULL, NULL,
 	  "#include <ucontext.h>\n"
 	  "static int x = 0;\n"
@@ -375,7 +453,8 @@ static struct test tests[] = {
 	  "	return (x == 3) ? 0 : 1;\n"
 	  "}\n"
 	},
-	{ "HAVE_POINTER_SAFE_MAKECONTEXT", DEFINES_EVERYTHING|EXECUTE|MAY_NOT_COMPILE,
+	{ "HAVE_POINTER_SAFE_MAKECONTEXT", "passing pointers via makecontext()",
+	  "DEFINES_EVERYTHING|EXECUTE|MAY_NOT_COMPILE",
 	  "HAVE_UCONTEXT", NULL,
 	  "#include <stddef.h>\n"
 	  "#include <ucontext.h>\n"
@@ -427,6 +506,20 @@ static void c12r_errx(int eval, const char *fmt, ...)
 	exit(eval);
 }
 
+static void start_test(const char *what, const char *why)
+{
+	if (like_a_libtool) {
+		printf("%s%s... ", what, why);
+		fflush(stdout);
+	}
+}
+
+static void end_test(bool result)
+{
+	if (like_a_libtool)
+		printf("%s\n", result ? "yes" : "no");
+}
+
 static size_t fcopy(FILE *fsrc, FILE *fdst)
 {
 	char buffer[BUFSIZ];
@@ -456,7 +549,7 @@ static char *grab_stream(FILE *file)
 	}
 	size += ret;
 	if (ferror(file))
-		c12r_err(1, "reading from command");
+		c12r_err(EXIT_TROUBLE_RUNNING, "reading from command");
 	buffer[size] = '\0';
 	return buffer;
 }
@@ -476,7 +569,7 @@ static char *run(const char *cmd, int *exitstatus)
 
 	cmdout = popen(cmdredir, "r");
 	if (!cmdout)
-		c12r_err(1, "popen \"%s\"", cmdredir);
+		c12r_err(EXIT_TROUBLE_RUNNING, "popen \"%s\"", cmdredir);
 
 	free(cmdredir);
 
@@ -513,10 +606,11 @@ static struct test *find_test(const char *name)
 {
 	unsigned int i;
 
-	for (i = 0; i < sizeof(tests)/sizeof(tests[0]); i++) {
+	for (i = 0; tests[i].name; i++) {
 		if (strcmp(tests[i].name, name) == 0)
 			return &tests[i];
 	}
+	c12r_errx(EXIT_BAD_TEST, "Unknown test %s", name);
 	abort();
 }
 
@@ -572,35 +666,30 @@ static bool run_test(const char *cmd, struct test *test)
 
 	outf = fopen(INPUT_FILE, verbose > 1 ? "w+" : "w");
 	if (!outf)
-		c12r_err(1, "creating %s", INPUT_FILE);
+		c12r_err(EXIT_TROUBLE_RUNNING, "creating %s", INPUT_FILE);
 
 	fprintf(outf, "%s", PRE_BOILERPLATE);
-	switch (test->style & ~(EXECUTE|MAY_NOT_COMPILE)) {
-	case INSIDE_MAIN:
+
+	if (strstr(test->style, "INSIDE_MAIN")) {
 		fprintf(outf, "%s", MAIN_START_BOILERPLATE);
 		fprintf(outf, "%s", test->fragment);
 		fprintf(outf, "%s", MAIN_END_BOILERPLATE);
-		break;
-	case OUTSIDE_MAIN:
+	} else if (strstr(test->style, "OUTSIDE_MAIN")) {
 		fprintf(outf, "%s", test->fragment);
 		fprintf(outf, "%s", MAIN_START_BOILERPLATE);
 		fprintf(outf, "%s", MAIN_BODY_BOILERPLATE);
 		fprintf(outf, "%s", MAIN_END_BOILERPLATE);
-		break;
-	case DEFINES_FUNC:
+	} else if (strstr(test->style, "DEFINES_FUNC")) {
 		fprintf(outf, "%s", test->fragment);
 		fprintf(outf, "%s", MAIN_START_BOILERPLATE);
 		fprintf(outf, "%s", USE_FUNC_BOILERPLATE);
 		fprintf(outf, "%s", MAIN_BODY_BOILERPLATE);
 		fprintf(outf, "%s", MAIN_END_BOILERPLATE);
-		break;
-	case DEFINES_EVERYTHING:
+	} else if (strstr(test->style, "DEFINES_EVERYTHING")) {
 		fprintf(outf, "%s", test->fragment);
-		break;
-	default:
-		abort();
-
-	}
+	} else
+		c12r_errx(EXIT_BAD_TEST, "Unknown style for test %s: %s",
+			  test->name, test->style);
 
 	if (verbose > 1) {
 		fseek(outf, 0, SEEK_SET);
@@ -629,6 +718,7 @@ static bool run_test(const char *cmd, struct test *test)
 			printf("Extra link line: %s", newcmd);
 	}
 
+	start_test("checking for ", test->desc);
 	output = run(newcmd, &status);
 
 	free(newcmd);
@@ -638,8 +728,10 @@ static bool run_test(const char *cmd, struct test *test)
 			printf("Compile %s for %s, status %i: %s\n",
 			       status ? "fail" : "warning",
 			       test->name, status, output);
-		if ((test->style & EXECUTE) && !(test->style & MAY_NOT_COMPILE))
-			c12r_errx(1, "Test for %s did not compile:\n%s",
+		if (strstr(test->style, "EXECUTE")
+		    && !strstr(test->style, "MAY_NOT_COMPILE"))
+			c12r_errx(EXIT_BAD_TEST,
+				  "Test for %s did not compile:\n%s",
 				  test->name, output);
 		test->answer = false;
 		free(output);
@@ -647,10 +739,12 @@ static bool run_test(const char *cmd, struct test *test)
 		/* Compile succeeded. */
 		free(output);
 		/* We run INSIDE_MAIN tests for sanity checking. */
-		if ((test->style & EXECUTE) || (test->style & INSIDE_MAIN)) {
+		if (strstr(test->style, "EXECUTE")
+		    || strstr(test->style, "INSIDE_MAIN")) {
 			output = run("." DIR_SEP OUTPUT_FILE, &status);
-			if (!(test->style & EXECUTE) && status != 0)
-				c12r_errx(1, "Test for %s failed with %i:\n%s",
+			if (!strstr(test->style, "EXECUTE") && status != 0)
+				c12r_errx(EXIT_BAD_TEST,
+					  "Test for %s failed with %i:\n%s",
 					  test->name, status, output);
 			if (verbose && status)
 				printf("%s exited %i\n", test->name, status);
@@ -659,6 +753,7 @@ static bool run_test(const char *cmd, struct test *test)
 		test->answer = (status == 0);
 	}
 	test->done = true;
+	end_test(test->answer);
 
 	if (test->answer && test->overrides) {
 		struct test *override = find_test(test->overrides);
@@ -668,6 +763,126 @@ static bool run_test(const char *cmd, struct test *test)
 	return test->answer;
 }
 
+static char *any_field(char **fieldname)
+{
+	char buf[1000];
+	for (;;) {
+		char *p, *eq;
+
+		if (!fgets(buf, sizeof(buf), stdin))
+			return NULL;
+
+		p = buf;
+		/* Ignore whitespace, lines starting with # */
+		while (*p == ' ' || *p == '\t')
+			p++;
+		if (*p == '#' || *p == '\n')
+			continue;
+
+		eq = strchr(p, '=');
+		if (!eq)
+			c12r_errx(EXIT_BAD_INPUT, "no = in line: %s", p);
+		*eq = '\0';
+		*fieldname = strdup(p);
+		p = eq + 1;
+		if (strlen(p) && p[strlen(p)-1] == '\n')
+			p[strlen(p)-1] = '\0';
+		return strdup(p);
+	}
+}
+
+static char *read_field(const char *name, bool compulsory)
+{
+	char *fieldname, *value;
+
+	value = any_field(&fieldname);
+	if (!value) {
+		if (!compulsory)
+			return NULL;
+		c12r_errx(EXIT_BAD_INPUT, "Could not read field %s", name);
+	}
+	if (strcmp(fieldname, name) != 0)
+		c12r_errx(EXIT_BAD_INPUT,
+			  "Expected field %s not %s", name, fieldname);
+	return value;
+}
+
+/* Test descriptions from stdin:
+ * Lines starting with # or whitespace-only are ignored.
+ *
+ * First three non-ignored lines must be:
+ *  var=<varname>
+ *  desc=<description-for-autotools-style>
+ *  style=OUTSIDE_MAIN DEFINES_FUNC INSIDE_MAIN DEFINES_EVERYTHING EXECUTE MAY_NOT_COMPILE
+ *
+ * Followed by optional lines:
+ *  depends=<space-separated-testnames, ! to invert>
+ *  link=<extra args for link line>
+ *  flags=<extra args for compile line>
+ *  overrides=<testname-to-force>
+ *
+ * Finally a code line, either:
+ *  code=<oneline> OR
+ *  code=
+ *  <lines of code>
+ *  <end-comment>
+ *
+ * And <end-comment> looks like this next comment: */
+/*END*/
+static bool read_test(struct test *test)
+{
+	char *field, *value;
+	char buf[1000];
+
+	memset(test, 0, sizeof(*test));
+	test->name = read_field("var", false);
+	if (!test->name)
+		return false;
+	test->desc = read_field("desc", true);
+	test->style = read_field("style", true);
+	/* Read any optional fields. */
+	while ((value = any_field(&field)) != NULL) {
+		if (strcmp(field, "depends") == 0)
+			test->depends = value;
+		else if (strcmp(field, "link") == 0)
+			test->link = value;
+		else if (strcmp(field, "flags") == 0)
+			test->flags = value;
+		else if (strcmp(field, "overrides") == 0)
+			test->overrides = value;
+		else if (strcmp(field, "code") == 0)
+			break;
+		else
+			c12r_errx(EXIT_BAD_INPUT, "Unknown field %s in %s",
+				  field, test->name);
+	}
+	if (!value)
+		c12r_errx(EXIT_BAD_INPUT, "Missing code in %s", test->name);
+
+	if (strlen(value) == 0) {
+		/* Multiline program, read to END comment */
+		while (fgets(buf, sizeof(buf), stdin) != 0) {
+			size_t n;
+			if (strncmp(buf, "/*END*/", 7) == 0)
+				break;
+			n = strlen(value);
+			value = realloc(value, n + strlen(buf) + 1);
+			strcpy(value + n, buf);
+			n += strlen(buf);
+		}
+	}
+	test->fragment = value;
+	return true;
+}
+
+static void read_tests(size_t num_tests)
+{
+	while (read_test(tests + num_tests)) {
+		num_tests++;
+		tests = realloc(tests, num_tests * sizeof(tests[0]));
+	}
+}
+
 int main(int argc, const char *argv[])
 {
 	char *cmd;
@@ -677,13 +892,17 @@ int main(int argc, const char *argv[])
 	const char *outflag = DEFAULT_OUTPUT_EXE_FLAG;
 	const char *configurator_cc = NULL;
 	const char *orig_cc;
+	const char *varfile = NULL;
+	const char *headerfile = NULL;
+	bool extra_tests = false;
+	FILE *outf;
 
 	if (argc > 0)
 		progname = argv[0];
 
 	while (argc > 1) {
 		if (strcmp(argv[1], "--help") == 0) {
-			printf("Usage: configurator [-v] [-O<outflag>] [--configurator-cc=<compiler-for-tests>] [<compiler> <flags>...]\n"
+			printf("Usage: configurator [-v] [--var-file=<filename>] [-O<outflag>] [--configurator-cc=<compiler-for-tests>] [--autotools-style] [--extra-tests] [<compiler> <flags>...]\n"
 			       "  <compiler> <flags> will have \"<outflag> <outfile> <infile.c>\" appended\n"
 			       "Default: %s %s %s\n",
 			       DEFAULT_COMPILER, DEFAULT_FLAGS,
@@ -698,7 +917,7 @@ int main(int argc, const char *argv[])
 				fprintf(stderr,
 					"%s: option requires an argument -- O\n",
 					argv[0]);
-				exit(1);
+				exit(EXIT_BAD_USAGE);
 			}
 		} else if (strcmp(argv[1], "-v") == 0) {
 			argc--;
@@ -712,6 +931,26 @@ int main(int argc, const char *argv[])
 			configurator_cc = argv[1] + 18;
 			argc--;
 			argv++;
+		} else if (strncmp(argv[1], "--var-file=", 11) == 0) {
+			varfile = argv[1] + 11;
+			argc--;
+			argv++;
+		} else if (strcmp(argv[1], "--autotools-style") == 0) {
+			like_a_libtool = true;
+			argc--;
+			argv++;
+		} else if (strncmp(argv[1], "--header-file=", 14) == 0) {
+			headerfile = argv[1] + 14;
+			argc--;
+			argv++;
+		} else if (strcmp(argv[1], "--extra-tests") == 0) {
+			extra_tests = true;
+			argc--;
+			argv++;
+		} else if (strcmp(argv[1], "--") == 0) {
+			break;
+		} else if (argv[1][0] == '-') {
+			c12r_errx(EXIT_BAD_USAGE, "Unknown option %s", argv[1]);
 		} else {
 			break;
 		}
@@ -720,33 +959,84 @@ int main(int argc, const char *argv[])
 	if (argc == 1)
 		argv = default_args;
 
+	/* Copy with NULL entry at end */
+	tests = calloc(sizeof(base_tests)/sizeof(base_tests[0]) + 1,
+		       sizeof(base_tests[0]));
+	memcpy(tests, base_tests, sizeof(base_tests));
+
+	if (extra_tests)
+		read_tests(sizeof(base_tests)/sizeof(base_tests[0]));
+
 	orig_cc = argv[1];
 	if (configurator_cc)
 		argv[1] = configurator_cc;
 
 	cmd = connect_args(argv, outflag, OUTPUT_FILE " " INPUT_FILE);
-	for (i = 0; i < sizeof(tests)/sizeof(tests[0]); i++)
+	if (like_a_libtool) {
+		start_test("Making autoconf users comfortable", "");
+		sleep(1);
+		end_test(1);
+	}
+	for (i = 0; tests[i].name; i++)
 		run_test(cmd, &tests[i]);
 	free(cmd);
 
 	remove(OUTPUT_FILE);
 	remove(INPUT_FILE);
 
-	printf("/* Generated by CCAN configurator */\n"
+	if (varfile) {
+		FILE *vars;
+
+		if (strcmp(varfile, "-") == 0)
+			vars = stdout;
+		else {
+			start_test("Writing variables to ", varfile);
+			vars = fopen(varfile, "a");
+			if (!vars)
+				c12r_err(EXIT_TROUBLE_RUNNING,
+					 "Could not open %s", varfile);
+		}
+		for (i = 0; tests[i].name; i++)
+			fprintf(vars, "%s=%u\n", tests[i].name, tests[i].answer);
+		if (vars != stdout) {
+			if (fclose(vars) != 0)
+				c12r_err(EXIT_TROUBLE_RUNNING,
+					 "Closing %s", varfile);
+			end_test(1);
+		}
+	}
+
+	if (headerfile) {
+		start_test("Writing header to ", headerfile);
+		outf = fopen(headerfile, "w");
+		if (!outf)
+			c12r_err(EXIT_TROUBLE_RUNNING,
+				 "Could not open %s", headerfile);
+	} else
+		outf = stdout;
+
+	fprintf(outf, "/* Generated by CCAN configurator */\n"
 	       "#ifndef CCAN_CONFIG_H\n"
 	       "#define CCAN_CONFIG_H\n");
-	printf("#ifndef _GNU_SOURCE\n");
-	printf("#define _GNU_SOURCE /* Always use GNU extensions. */\n");
-	printf("#endif\n");
-	printf("#define CCAN_COMPILER \"%s\"\n", orig_cc);
+	fprintf(outf, "#ifndef _GNU_SOURCE\n");
+	fprintf(outf, "#define _GNU_SOURCE /* Always use GNU extensions. */\n");
+	fprintf(outf, "#endif\n");
+	fprintf(outf, "#define CCAN_COMPILER \"%s\"\n", orig_cc);
 	cmd = connect_args(argv + 1, "", "");
-	printf("#define CCAN_CFLAGS \"%s\"\n", cmd);
+	fprintf(outf, "#define CCAN_CFLAGS \"%s\"\n", cmd);
 	free(cmd);
-	printf("#define CCAN_OUTPUT_EXE_CFLAG \"%s\"\n\n", outflag);
+	fprintf(outf, "#define CCAN_OUTPUT_EXE_CFLAG \"%s\"\n\n", outflag);
 	/* This one implies "#include <ccan/..." works, eg. for tdb2.h */
-	printf("#define HAVE_CCAN 1\n");
-	for (i = 0; i < sizeof(tests)/sizeof(tests[0]); i++)
-		printf("#define %s %u\n", tests[i].name, tests[i].answer);
-	printf("#endif /* CCAN_CONFIG_H */\n");
+	fprintf(outf, "#define HAVE_CCAN 1\n");
+	for (i = 0; tests[i].name; i++)
+		fprintf(outf, "#define %s %u\n", tests[i].name, tests[i].answer);
+	fprintf(outf, "#endif /* CCAN_CONFIG_H */\n");
+
+	if (headerfile) {
+		if (fclose(outf) != 0)
+			c12r_err(EXIT_TROUBLE_RUNNING, "Closing %s", headerfile);
+		end_test(1);
+	}
+
 	return 0;
 }
diff --git a/channeld/channel.c b/channeld/channel.c
index b5632d9bfe26..74b360e9a4ba 100644
--- a/channeld/channel.c
+++ b/channeld/channel.c
@@ -1591,6 +1591,11 @@ static void peer_in(struct peer *peer, const u8 *msg)
 	case WIRE_CHANNEL_ANNOUNCEMENT:
 	case WIRE_CHANNEL_UPDATE:
 	case WIRE_NODE_ANNOUNCEMENT:
+	case WIRE_QUERY_SHORT_CHANNEL_IDS:
+	case WIRE_QUERY_CHANNEL_RANGE:
+	case WIRE_REPLY_CHANNEL_RANGE:
+	case WIRE_GOSSIP_TIMESTAMP_FILTER:
+	case WIRE_REPLY_SHORT_CHANNEL_IDS_END:
 	case WIRE_PING:
 	case WIRE_ERROR:
 		abort();
diff --git a/common/features.c b/common/features.c
index 81b42eabc138..3a2c3806b1b5 100644
--- a/common/features.c
+++ b/common/features.c
@@ -4,7 +4,8 @@
 #include <wire/peer_wire.h>
 
 static const u32 local_features[] = {
-	LOCAL_INITIAL_ROUTING_SYNC
+	LOCAL_INITIAL_ROUTING_SYNC,
+	LOCAL_GOSSIP_QUERIES
 };
 
 static const u32 global_features[] = {
diff --git a/common/features.h b/common/features.h
index 82a9fbdd3d1b..2723939006fe 100644
--- a/common/features.h
+++ b/common/features.h
@@ -25,9 +25,11 @@ bool feature_offered(const u8 *features, size_t f);
  * | 0/1  | `option-data-loss-protect`       |...
  * | 3    | `initial_routing_sync`           |...
  * | 4/5  | `option_upfront_shutdown_script` |...
+ * | 6/7  | `gossip_queries`                 |...
  */
 #define LOCAL_DATA_LOSS_PROTECT			0
 #define LOCAL_INITIAL_ROUTING_SYNC		2
 #define LOCAL_UPFRONT_SHUTDOWN_SCRIPT		4
+#define LOCAL_GOSSIP_QUERIES			6
 
 #endif /* LIGHTNING_COMMON_FEATURES_H */
diff --git a/configure b/configure
new file mode 100755
index 000000000000..6e3ca43898fa
--- /dev/null
+++ b/configure
@@ -0,0 +1,112 @@
+#! /bin/sh
+# Simple configure script for c-lightning.
+
+set -e
+
+# Default values, loaded from environment or canned.
+PREFIX=${PREFIX:-/usr/local}
+CC=${CC:-cc}
+CWARNFLAGS=${CWARNFLAGS:--Werror -Wall -Wundef -Wmissing-prototypes -Wmissing-declarations -Wstrict-prototypes -Wold-style-definition}
+CDEBUGFLAGS=${CDEBUGFLAGS:--std=gnu11 -g -fstack-protector}
+DEVELOPER=${DEVELOPER:-0}
+COMPAT=${COMPAT:-1}
+CONFIGURATOR_CC=${CONFIGURATOR_CC:-$CC}
+
+CONFIGURATOR=ccan/tools/configurator/configurator
+CONFIG_VAR_FILE=config.vars
+CONFIG_HEADER=ccan/config.h
+
+usage_with_default()
+{
+    if [ $# = 4 ]; then
+	if [ $2 ]; then
+	    DEF=$4
+	else
+	    DEF=$3
+	fi
+    else
+	DEF=$2
+    fi
+    echo "  $1 (default $DEF)"
+}
+
+usage()
+{
+    echo "Usage: ./configure [--reconfigure] [setting=value] [options]"
+    echo "If --reconfigure is specified, $CONFIG_VAR_FILE will set defaults if it exists."
+    echo "Default settings:"
+    usage_with_default "CC" "$CC"
+    usage_with_default "CWARNFLAGS" "$CWARNFLAGS"
+    usage_with_default "CDEBUGFLAGS" "$CDEBUGFLAGS"
+    usage_with_default "CONFIGURATOR_CC" "$CONFIGURATOR_CC"
+    echo "    To override compile line for configurator itself"
+
+    echo "Options include:"
+    usage_with_default "--prefix=" "$PREFIX"
+    echo "    Prefix for make install"
+    usage_with_default "--enable/disable-developer" "$DEVELOPER" "enable" "disable"
+    echo "    Developer mode, good for testing"
+    usage_with_default "--enable/disable-compat" "$COMPAT" "enable" "disable"
+    echo "    Compatibility mode, good to disable to see if your software breaks"
+    usage_with_default "--enable/disable-valgrind" "(autodetect)"
+    echo "    Valgrind binary to use for tests"
+    exit 1
+}
+
+add_var()
+{
+    echo "Setting $1... $2"
+    echo "$1=$2" >> $CONFIG_VAR_FILE
+    [ -z "$3" ] || echo "#define $1 $2" >> "$3"
+}
+
+for opt in "$@"; do
+    case "$opt" in
+	--reconfigure)
+	    # Escape spaces for things like CWARNFLAGS.
+	    sed 's/=\(.*\)$/="\1"/' $CONFIG_VAR_FILE > $CONFIG_VAR_FILE.$$
+	    . ./$CONFIG_VAR_FILE.$$
+	    ;;
+	CC=*) CC="${opt#CC=}";;
+	CONFIGURATOR_CC=*) CONFIGURATOR_CC="${opt#CONFIGURATOR_CC=}";;
+	CWARNFLAGS=*) CWARNFLAGS="${opt#CWARNFLAGS=}";;
+	CDEBUGFLAGS=*) CDEBUGFLAGS="${opt#CDEBUGFLAGS=}";;
+	--prefix=*) PREFIX="${opt#--prefix=}";;
+	--enable-developer) DEVELOPER=1;;
+	--disable-developer) DEVELOPER=0;;
+	--enable-compat) COMPAT=1;;
+	--disable-compat) COMPAT=0;;
+	--enable-valgrind) VALGRIND=1;;
+	--disable-valgrind) VALGRIND=0;;
+	--help|-h) usage;;
+	*)
+	    echo "Unknown option '$opt'" >&2
+	    usage
+	    ;;
+    esac
+done
+
+echo -n "Compiling $CONFIGURATOR..."
+$CC $CWARNFLAGS $CDEBUGFLAGS -o $CONFIGURATOR $CONFIGURATOR.c
+echo "done"
+
+if [ -z "$VALGRIND" ]; then
+    if valgrind -q --error-exitcode=7 --track-origins=yes --leak-check=full --show-reachable=yes --errors-for-leak-kinds=all $CONFIGURATOR --help >/dev/null 2>&1; then
+	VALGRIND=1
+    else
+	VALGRIND=0
+    fi
+fi
+
+rm -f $CONFIG_VAR_FILE.$$
+$CONFIGURATOR --autotools-style --var-file=$CONFIG_VAR_FILE.$$ --header-file=$CONFIG_HEADER --configurator-cc="$CONFIGURATOR_CC" "$CC" $CWARNFLAGS $CDEBUGFLAGS
+mv $CONFIG_VAR_FILE.$$ $CONFIG_VAR_FILE
+
+add_var PREFIX "$PREFIX"
+add_var CC "$CC"
+add_var CONFIGURATOR_CC "$CONFIGURATOR_CC"
+add_var CWARNFLAGS "$CWARNFLAGS"
+add_var CDEBUGFLAGS "$CDEBUGFLAGS"
+add_var VALGRIND "$VALGRIND"
+add_var DEVELOPER "$DEVELOPER" $CONFIG_HEADER
+add_var COMPAT "$COMPAT" $CONFIG_HEADER
diff --git a/contrib/Dockerfile.builder b/contrib/Dockerfile.builder
index ba1f901a9f49..f3821e6e7d32 100644
--- a/contrib/Dockerfile.builder
+++ b/contrib/Dockerfile.builder
@@ -32,7 +32,8 @@ RUN apt-get -qq update && \
 	python3-setuptools \
 	python-pkg-resources \
 	shellcheck \
-	wget && \
+	wget \
+	zlib1g-dev && \
 	rm -rf /var/lib/apt/lists/*
 
 ENV LANGUAGE=en_US.UTF-8
diff --git a/contrib/Dockerfile.builder.fedora b/contrib/Dockerfile.builder.fedora
index 91ab2c71ccf4..517e4da345e4 100644
--- a/contrib/Dockerfile.builder.fedora
+++ b/contrib/Dockerfile.builder.fedora
@@ -17,7 +17,8 @@ RUN dnf update -y && \
 		python3-setuptools \
 		net-tools \
 		valgrind \
-		wget && \
+		wget \
+		zlib-devel && \
 	dnf clean all
 
 RUN wget https://bitcoin.org/bin/bitcoin-core-$BITCOIN_VERSION/bitcoin-$BITCOIN_VERSION-x86_64-linux-gnu.tar.gz -O bitcoin.tar.gz && \
diff --git a/contrib/Dockerfile.builder.i386 b/contrib/Dockerfile.builder.i386
index b425b47b8eee..c1421c113440 100644
--- a/contrib/Dockerfile.builder.i386
+++ b/contrib/Dockerfile.builder.i386
@@ -32,7 +32,8 @@ RUN apt-get -qq update && \
 	python3-setuptools \
 	python-pkg-resources \
 	shellcheck \
-	wget && \
+	wget \
+	zlib1g-dev && \
 	rm -rf /var/lib/apt/lists/*
 
 ENV LANGUAGE=en_US.UTF-8
diff --git a/contrib/pylightning/lightning/lightning.py b/contrib/pylightning/lightning/lightning.py
index f8d87b7edd57..049bc6944192 100644
--- a/contrib/pylightning/lightning/lightning.py
+++ b/contrib/pylightning/lightning/lightning.py
@@ -249,6 +249,16 @@ def dev_crash(self):
         """
         return self.call("dev-crash")
 
+    def dev_query_scids(self, id, scids):
+        """
+        Ask peer for a particular set of scids
+        """
+        payload = {
+            "id": id,
+            "scids": scids
+        }
+        return self.call("dev-query-scids", payload)
+
     def getinfo(self):
         """
         Show information about this node
diff --git a/devtools/Makefile b/devtools/Makefile
index 5241d4014ee3..ee94335c64fc 100644
--- a/devtools/Makefile
+++ b/devtools/Makefile
@@ -1,6 +1,6 @@
 DEVTOOLS_SRC := devtools/gen_print_wire.c devtools/print_wire.c
 DEVTOOLS_OBJS := $(DEVTOOLS_SRC:.c=.o)
-DEVTOOLS_TOOL_SRC := devtools/bolt11-cli.c devtools/decodemsg.c
+DEVTOOLS_TOOL_SRC := devtools/bolt11-cli.c devtools/decodemsg.c devtools/onion.c
 DEVTOOLS_TOOL_OBJS := $(DEVTOOLS_TOOL_SRC:.c=.o)
 
 DEVTOOLS_COMMON_OBJS :=				\
diff --git a/doc/HACKING.md b/doc/HACKING.md
index 76f0a4cdb7cc..2206a3c5a84c 100644
--- a/doc/HACKING.md
+++ b/doc/HACKING.md
@@ -176,10 +176,9 @@ valgrind installed, and build with DEVELOPER=1.
   link (which will conveniently crash if they're called).
 
 * blackbox tests - run by `make check` or directly as
-  `PYTHONPATH=contrib/pylightning DEVELOPER=1 python3
-  tests/test_lightningd.py -f`.
-  You can run these much faster by putting `NO_VALGRIND=1` after
-  DEVELOPER=1, or after `make check`, which has the added bonus of doing
+  `PYTHONPATH=contrib/pylightning python3 tests/test_lightningd.py -f`.
+  You can run these much faster by putting `VALGRIND=0` after `make check`,
+  which has the added bonus of doing
   memory leak detection.  You can also append `LightningDTests.TESTNAME`
   to run a single test.
 
diff --git a/doc/INSTALL.md b/doc/INSTALL.md
index 4cf18f95a6dc..1a426bd73e7b 100644
--- a/doc/INSTALL.md
+++ b/doc/INSTALL.md
@@ -15,6 +15,7 @@ Library Requirements
 You will need several development libraries:
 * libsqlite3: for database support.
 * libgmp: for secp256k1
+* zlib: for compression routines.
 
 For actually doing development and running the tests, you will also need:
 * pip3: to install python-bitcoinlib
@@ -34,7 +35,7 @@ Get dependencies:
     sudo apt-get update
     sudo apt-get install -y \
       autoconf automake build-essential git libtool libgmp-dev \
-      libsqlite3-dev python python3 net-tools
+      libsqlite3-dev python python3 net-tools zlib1g-dev
 
 If you don't have Bitcoin installed locally you'll need to install that
 as well:
diff --git a/external/Makefile b/external/Makefile
index 48bca5479f58..71b9d81ef73c 100644
--- a/external/Makefile
+++ b/external/Makefile
@@ -1,3 +1,10 @@
+SUBMODULES =					\
+	external/libsodium			\
+	external/libwally-core			\
+	external/jsmn				\
+	external/libbase58			\
+	external/libbacktrace
+
 LIBSODIUM_HEADERS := external/libsodium/src/libsodium/include/sodium.h
 LIBWALLY_HEADERS := external/libwally-core/include/wally_bip32.h		\
 			external/libwally-core/include/wally_core.h	\
@@ -21,20 +28,19 @@ EXTERNAL_INCLUDE_FLAGS :=					\
 
 EXTERNAL_LDLIBS := -Lexternal $(patsubst lib%.a,-l%,$(notdir $(EXTERNAL_LIBS)))
 
-# Might exist, but need updating.  Nuke and rebuild.
-submodcheck-%: FORCE
-	if git submodule status external/$* | grep -q '^[-+]'; then rm -rf external/$*; git submodule update --init external/$*; fi
+submodcheck: FORCE
+	@tools/refresh-submodules.sh $(SUBMODULES)
 
 # We build libsodium, since Ubuntu xenial has one too old.
 external/libsodium.a: external/libsodium/src/libsodium/libsodium.la
 	$(MAKE) -C external/libsodium DESTDIR=$$(pwd)/external install-exec
 
-external/libsodium/src/libsodium/include/sodium.h: submodcheck-libsodium
+external/libsodium/src/libsodium/include/sodium.h: submodcheck
 
 external/libsodium/src/libsodium/libsodium.la: external/libsodium/src/libsodium/include/sodium.h
 	cd external/libsodium && ./autogen.sh && ./configure CC="$(CC)" --enable-static=yes --host="$(MAKE_HOST)" --build="$(BUILD)" --enable-shared=no --enable-tests=no --prefix=/ --libdir=/ && $(MAKE)
 
-$(LIBWALLY_HEADERS) $(LIBSECP_HEADERS): submodcheck-libwally-core
+$(LIBWALLY_HEADERS) $(LIBSECP_HEADERS): submodcheck
 
 # libsecp included in libwally.
 # Wildcards here are magic.  See http://stackoverflow.com/questions/2973445/gnu-makefile-rule-generating-a-few-targets-from-a-single-source-file
@@ -44,7 +50,7 @@ external/libsecp256k1.% external/libwallycore.%: external/libwally-core/src/secp
 external/libwally-core/src/libwallycore.% external/libwally-core/src/secp256k1/libsecp256k1.%: $(LIBWALLY_HEADERS) $(LIBSECP_HEADERS)
 	cd external/libwally-core && ./tools/autogen.sh && ./configure CC="$(CC)" --enable-static=yes --host="$(MAKE_HOST)" --build="$(BUILD)" --enable-module-recovery --enable-shared=no --prefix=/ --libdir=/ && $(MAKE)
 
-external/jsmn/jsmn.h: submodcheck-jsmn
+external/jsmn/jsmn.h: submodcheck
 
 # If we tell Make that the above builds both, it runs it twice in
 # parallel.  So we lie :(
@@ -61,7 +67,7 @@ LIBBASE58_SRC := external/libbase58/base58.c
 
 $(LIBBASE58_SRC): $(LIBBASE58_HEADERS)
 
-$(LIBBASE58_HEADERS): submodcheck-libbase58
+$(LIBBASE58_HEADERS): submodcheck
 
 # Can't be inside submodule, as that makes git think it's dirty.
 external/base58.o: $(LIBBASE58_SRC) Makefile
@@ -70,7 +76,7 @@ external/base58.o: $(LIBBASE58_SRC) Makefile
 external/libbase58.a: external/base58.o
 	$(AR) rc $@ $<
 
-external/libbacktrace/backtrace.h: submodcheck-libbacktrace
+external/libbacktrace/backtrace.h: submodcheck
 
 # Need separate build dir: changes inside submodule make git think it's dirty.
 external/libbacktrace.a: external/libbacktrace/backtrace.h
diff --git a/external/libbacktrace b/external/libbacktrace
index 14d377e9be7c..078f841be602 160000
--- a/external/libbacktrace
+++ b/external/libbacktrace
@@ -1 +1 @@
-Subproject commit 14d377e9be7c89511c472d728e1b88b4e96f1946
+Subproject commit 078f841be6029a59eb49d645e3720422df1dc9f2
diff --git a/gossipd/broadcast.c b/gossipd/broadcast.c
index 92b083e99bb2..9695ee87a89a 100644
--- a/gossipd/broadcast.c
+++ b/gossipd/broadcast.c
@@ -5,6 +5,9 @@ struct queued_message {
 	/* Broadcast index. */
 	u64 index;
 
+	/* Timestamp, for filtering. */
+	u32 timestamp;
+
 	/* Serialized payload */
 	const u8 *payload;
 };
@@ -27,28 +30,37 @@ static void destroy_queued_message(struct queued_message *msg,
 static struct queued_message *new_queued_message(const tal_t *ctx,
 						 struct broadcast_state *bstate,
 						 const u8 *payload,
+						 u32 timestamp,
 						 u64 index)
 {
 	struct queued_message *msg = tal(ctx, struct queued_message);
+	assert(payload);
 	msg->payload = payload;
 	msg->index = index;
+	msg->timestamp = timestamp;
 	uintmap_add(&bstate->broadcasts, index, msg);
 	tal_add_destructor2(msg, destroy_queued_message, bstate);
 	return msg;
 }
 
-void insert_broadcast(struct broadcast_state *bstate, const u8 *payload)
+void insert_broadcast(struct broadcast_state *bstate,
+		      const u8 *payload, u32 timestamp)
 {
 	/* Free payload, free index. */
-	new_queued_message(payload, bstate, payload, bstate->next_index++);
+	new_queued_message(payload, bstate, payload, timestamp,
+			   bstate->next_index++);
 }
 
-const u8 *next_broadcast(struct broadcast_state *bstate, u64 *last_index)
+const u8 *next_broadcast(struct broadcast_state *bstate,
+			 u32 timestamp_min, u32 timestamp_max,
+			 u64 *last_index)
 {
 	struct queued_message *m;
 
-	m = uintmap_after(&bstate->broadcasts, last_index);
-	if (m)
-		return m->payload;
+	while ((m = uintmap_after(&bstate->broadcasts, last_index)) != NULL) {
+		if (m->timestamp >= timestamp_min
+		    && m->timestamp <= timestamp_max)
+			return m->payload;
+	}
 	return NULL;
 }
diff --git a/gossipd/broadcast.h b/gossipd/broadcast.h
index b88f8bb97a3f..6de0fec38e6d 100644
--- a/gossipd/broadcast.h
+++ b/gossipd/broadcast.h
@@ -17,9 +17,13 @@ struct broadcast_state {
 struct broadcast_state *new_broadcast_state(tal_t *ctx);
 
 /* Append a queued message for broadcast.  Freeing the msg will remove it. */
-void insert_broadcast(struct broadcast_state *bstate, const u8 *msg);
+void insert_broadcast(struct broadcast_state *bstate, const u8 *msg,
+		      u32 timestamp);
 
-/* Return the broadcast with index >= *last_index, and update *last_index.
+/* Return the broadcast with index >= *last_index, timestamp >= min and <= max
+ * and update *last_index.
  * There's no broadcast with index 0. */
-const u8 *next_broadcast(struct broadcast_state *bstate, u64 *last_index);
+const u8 *next_broadcast(struct broadcast_state *bstate,
+			 u32 timestamp_min, u32 timestamp_max,
+			 u64 *last_index);
 #endif /* LIGHTNING_GOSSIPD_BROADCAST_H */
diff --git a/gossipd/gossip.c b/gossipd/gossip.c
index df4f694922ea..75e7cff24629 100644
--- a/gossipd/gossip.c
+++ b/gossipd/gossip.c
@@ -1,3 +1,4 @@
+#include <ccan/asort/asort.h>
 #include <ccan/build_assert/build_assert.h>
 #include <ccan/cast/cast.h>
 #include <ccan/container_of/container_of.h>
@@ -55,6 +56,7 @@
 #include <wire/gen_peer_wire.h>
 #include <wire/wire_io.h>
 #include <wire/wire_sync.h>
+#include <zlib.h>
 
 #define GOSSIP_MAX_REACH_ATTEMPTS 10
 
@@ -63,6 +65,18 @@
 #define INITIAL_WAIT_SECONDS	1
 #define MAX_WAIT_SECONDS	300
 
+/* BOLT #7:
+ *
+ * Encoding types:
+ * * `0`: uncompressed array of `short_channel_id` types, in ascending order.
+ * * `1`: array of `short_channel_id` types, in ascending order, compressed with
+ *        zlib<sup>[1](#reference-1)</sup>
+ */
+enum scid_encode_types {
+	SHORTIDS_UNCOMPRESSED = 0,
+	SHORTIDS_ZLIB = 1
+};
+
 /* We put everything in this struct (redundantly) to pass it to timer cb */
 struct important_peerid {
 	struct daemon *daemon;
@@ -100,6 +114,10 @@ HTABLE_DEFINE_TYPE(struct important_peerid,
 		   important_peerid_eq,
 		   important_peerid_map);
 
+#if DEVELOPER
+static u32 max_scids_encode_bytes = -1U;
+#endif
+
 struct daemon {
 	/* Who am I? */
 	struct pubkey id;
@@ -216,8 +234,27 @@ struct peer {
 	/* High water mark for the staggered broadcast */
 	u64 broadcast_index;
 
-	/* Is it time to continue the staggered broadcast? */
-	bool gossip_sync;
+	/* Timestamp range to filter gossip by */
+	u32 gossip_timestamp_min, gossip_timestamp_max;
+
+	/* Are there outstanding queries on short_channel_ids? */
+	const struct short_channel_id *scid_queries;
+	size_t scid_query_idx;
+
+	/* Are there outstanding node_announcements from scid_queries? */
+	struct pubkey *scid_query_nodes;
+	size_t scid_query_nodes_idx;
+
+	/* If this is NULL, we're syncing gossip now. */
+	struct oneshot *gossip_timer;
+
+	/* How many query responses are we expecting? */
+	size_t num_scid_queries_outstanding;
+
+	/* Map of outstanding channel_range requests. */
+	u8 *query_channel_blocks;
+	u32 first_channel_range;
+	struct short_channel_id *query_channel_scids;
 
 	/* Only one of these is set: */
 	struct local_peer_state *local;
@@ -237,7 +274,6 @@ struct addrhint {
 static struct io_plan *peer_start_gossip(struct io_conn *conn,
 					 struct peer *peer);
 static bool send_peer_with_fds(struct peer *peer, const u8 *msg);
-static void wake_pkt_out(struct peer *peer);
 static void retry_important(struct important_peerid *imp);
 
 static void destroy_peer(struct peer *peer)
@@ -334,7 +370,16 @@ static struct peer *new_peer(const tal_t *ctx,
 	peer->addr = *addr;
 	peer->daemon = daemon;
 	peer->local = new_local_peer_state(peer, cs);
+	peer->gossip_timer = NULL;
 	peer->remote = NULL;
+	peer->scid_queries = NULL;
+	peer->scid_query_idx = 0;
+	peer->scid_query_nodes = NULL;
+	peer->scid_query_nodes_idx = 0;
+	peer->num_scid_queries_outstanding = 0;
+	peer->query_channel_blocks = NULL;
+	peer->gossip_timestamp_min = 0;
+	peer->gossip_timestamp_max = UINT32_MAX;
 
 	return peer;
 }
@@ -390,6 +435,68 @@ static void reached_peer(struct peer *peer, struct io_conn *conn)
 	tal_free(r);
 }
 
+static u8 *encode_short_channel_ids_start(const tal_t *ctx)
+{
+	u8 *encoded = tal_arr(tmpctx, u8, 0);
+	towire_u8(&encoded, SHORTIDS_ZLIB);
+	return encoded;
+}
+
+static void encode_add_short_channel_id(u8 **encoded,
+					const struct short_channel_id *scid)
+{
+	towire_short_channel_id(encoded, scid);
+}
+
+static u8 *zencode_scids(const tal_t *ctx, const u8 *scids, size_t len)
+{
+	u8 *z;
+	int err;
+	unsigned long compressed_len = len;
+
+	/* Prefer to fail if zlib makes it larger */
+	z = tal_arr(ctx, u8, len);
+	err = compress2(z, &compressed_len, scids, len, Z_BEST_COMPRESSION);
+	if (err == Z_OK) {
+		status_trace("short_ids compressed %zu into %lu",
+			     len, compressed_len);
+		tal_resize(&z, compressed_len);
+		return z;
+	}
+	status_trace("short_ids compress %zu returned %i:"
+		     " not compresssing", len, err);
+	return NULL;
+}
+
+static bool encode_short_channel_ids_end(u8 **encoded, size_t max_bytes)
+{
+	u8 *z;
+
+	switch ((enum scid_encode_types)(*encoded)[0]) {
+	case SHORTIDS_ZLIB:
+		z = zencode_scids(tmpctx, *encoded + 1, tal_len(*encoded) - 1);
+		if (z) {
+			tal_resize(encoded, 1 + tal_len(z));
+			memcpy((*encoded) + 1, z, tal_len(z));
+			goto check_length;
+		}
+		(*encoded)[0] = SHORTIDS_UNCOMPRESSED;
+		/* Fall thru */
+	case SHORTIDS_UNCOMPRESSED:
+		goto check_length;
+	}
+
+	status_failed(STATUS_FAIL_INTERNAL_ERROR,
+		      "Unknown short_ids encoding %u", (*encoded)[0]);
+
+check_length:
+#if DEVELOPER
+	if (tal_len(*encoded) > max_scids_encode_bytes)
+		return false;
+#endif
+	return tal_len(*encoded) <= max_bytes;
+}
+
 static void queue_peer_msg(struct peer *peer, const u8 *msg TAKES)
 {
 	if (peer->local) {
@@ -402,6 +509,19 @@ static void queue_peer_msg(struct peer *peer, const u8 *msg TAKES)
 	}
 }
 
+static void wake_gossip_out(struct peer *peer)
+{
+	/* If we were waiting, we're not any more */
+	peer->gossip_timer = tal_free(peer->gossip_timer);
+
+	if (peer->local)
+		/* Notify the peer-write loop */
+		msg_wake(&peer->local->peer_out);
+	else if (peer->remote)
+		/* Notify the daemon_conn-write loop */
+		msg_wake(&peer->remote->out);
+}
+
 static void peer_error(struct peer *peer, const char *fmt, ...)
 {
 	va_list ap;
@@ -452,6 +572,25 @@ static struct io_plan *retry_peer_connected(struct io_conn *conn,
 	return peer_connected(conn, peer);
 }
 
+static void setup_gossip_range(struct peer *peer)
+{
+	bool gossip_queries;
+	u8 *msg;
+
+	gossip_queries = feature_offered(peer->lfeatures, LOCAL_GOSSIP_QUERIES)
+		&& feature_offered(peer->daemon->localfeatures,
+				   LOCAL_GOSSIP_QUERIES);
+
+	if (!gossip_queries)
+		return;
+
+	/* Tell it to start gossip!  (And give us everything!) */
+	msg = towire_gossip_timestamp_filter(peer,
+					     &peer->daemon->rstate->chain_hash,
+					     0, UINT32_MAX);
+	queue_peer_msg(peer, take(msg));
+}
+
 static struct io_plan *peer_connected(struct io_conn *conn, struct peer *peer)
 {
 	struct peer *old_peer;
@@ -482,16 +621,34 @@ static struct io_plan *peer_connected(struct io_conn *conn, struct peer *peer)
 
 	/* BOLT #7:
 	 *
-	 * Upon receiving an `init` message with the `initial_routing_sync`
-	 * flag set the node sends `channel_announcement`s, `channel_update`s
-	 * and `node_announcement`s for all known channels and nodes as if
-	 * they were just received.
+	 *   - if the `gossip_queries` feature is negotiated:
+	 *	- MUST NOT relay any gossip messages unless explicitly requested.
 	 */
-	if (feature_offered(peer->lfeatures, LOCAL_INITIAL_ROUTING_SYNC))
-		peer->broadcast_index = 0;
-	else
-		peer->broadcast_index
-			= peer->daemon->rstate->broadcasts->next_index;
+	if (feature_offered(peer->lfeatures, LOCAL_GOSSIP_QUERIES)
+	    && feature_offered(peer->daemon->localfeatures, LOCAL_GOSSIP_QUERIES)) {
+		peer->broadcast_index = UINT64_MAX;
+		/* Nothing in this range */
+		peer->gossip_timestamp_min = UINT32_MAX;
+		peer->gossip_timestamp_max = 0;
+	} else {
+		/* BOLT #7:
+		 *
+		 * - upon receiving an `init` message with the
+		 *   `initial_routing_sync` flag set to 1:
+		 *   - SHOULD send `channel_announcement`s, `channel_update`s
+		 *    and `node_announcement`s for all known channels and
+		 *    nodes, as if they were just received.
+		 * - if the `initial_routing_sync` flag is set to 0, OR if the
+		 *   initial sync was completed:
+		 *   - SHOULD resume normal operation, as specified in the
+		 *     following [Rebroadcasting](#rebroadcasting) section.
+		 */
+		if (feature_offered(peer->lfeatures, LOCAL_INITIAL_ROUTING_SYNC))
+			peer->broadcast_index = 0;
+		else
+			peer->broadcast_index
+				= peer->daemon->rstate->broadcasts->next_index;
+	}
 
 	/* This is a full peer now; we keep it around until master says
 	 * it's dead. */
@@ -505,8 +662,9 @@ static struct io_plan *peer_connected(struct io_conn *conn, struct peer *peer)
 		return io_close(conn);
 
 	/* Start the gossip flowing. */
-	wake_pkt_out(peer);
+	wake_gossip_out(peer);
 
+	setup_gossip_range(peer);
 	return io_close_taken_fd(conn);
 }
 
@@ -623,6 +781,17 @@ static void send_node_announcement(struct daemon *daemon)
 			      tal_hex(tmpctx, err));
 }
 
+/* Should we announce our own node? */
+static void maybe_send_own_node_announce(struct daemon *daemon)
+{
+	if (!daemon->rstate->local_channel_announced)
+		return;
+
+	/* FIXME: We may not need to retransmit here, if previous still valid. */
+	send_node_announcement(daemon);
+	daemon->rstate->local_channel_announced = false;
+}
+
 /**
  * Handle an incoming gossip message
  *
@@ -661,6 +830,8 @@ static u8 *handle_gossip_msg(struct daemon *daemon, const u8 *msg,
 		err = handle_channel_update(rstate, msg, source);
 		if (err)
 			return err;
+		/* In case we just announced a new local channel. */
+		maybe_send_own_node_announce(daemon);
 		break;
 	}
 
@@ -668,6 +839,277 @@ static u8 *handle_gossip_msg(struct daemon *daemon, const u8 *msg,
 	return NULL;
 }
 
+static u8 *unzlib(const tal_t *ctx, const u8 *encoded, size_t len)
+{
+	/* http://www.zlib.net/zlib_tech.html gives 1032:1 as worst-case,
+	 * which is 67632120 bytes for us.  But they're not encoding zeroes,
+	 * and each scid must be unique.  So 1MB is far more reasonable. */
+	unsigned long unclen = 1024*1024;
+	int zerr;
+	u8 *unc = tal_arr(ctx, u8, unclen);
+
+	zerr = uncompress(unc, &unclen, encoded, len);
+	if (zerr != Z_OK) {
+		status_trace("unzlib: error %i", zerr);
+		return tal_free(unc);
+	}
+
+	/* Truncate and return. */
+	tal_resize(&unc, unclen);
+	return unc;
+}
+
+static struct short_channel_id *decode_short_ids(const tal_t *ctx,
+						 const u8 *encoded)
+{
+	struct short_channel_id *scids;
+	size_t max = tal_len(encoded), n;
+	enum scid_encode_types type;
+
+	/* BOLT #7:
+	 *
+	 * The receiver:
+	 *   - if the first byte of `encoded_short_ids` is not a known encoding
+	 *     type:
+	 *     - MAY fail the connection
+	 *   - if `encoded_short_ids` does not decode into a whole number of
+	 *     `short_channel_id`:
+	 *     - MAY fail the connection
+	 */
+	type = fromwire_u8(&encoded, &max);
+	switch (type) {
+	case SHORTIDS_ZLIB:
+		encoded = unzlib(tmpctx, encoded, max);
+		if (!encoded)
+			return NULL;
+		status_trace("Uncompressed %zu into %zu bytes (%s)",
+			     max, tal_len(encoded), tal_hex(tmpctx, encoded));
+		max = tal_len(encoded);
+		/* fall thru */
+	case SHORTIDS_UNCOMPRESSED:
+		n = 0;
+		scids = tal_arr(ctx, struct short_channel_id, n);
+		while (max) {
+			tal_resize(&scids, n+1);
+			fromwire_short_channel_id(&encoded, &max, &scids[n++]);
+		}
+
+		/* encoded is set to NULL if we ran over */
+		if (!encoded)
+			return tal_free(scids);
+		return scids;
+	}
+	return NULL;
+}
+
+static void handle_query_short_channel_ids(struct peer *peer, u8 *msg)
+{
+	struct routing_state *rstate = peer->daemon->rstate;
+	struct bitcoin_blkid chain;
+	u8 *encoded;
+	struct short_channel_id *scids;
+
+	if (!fromwire_query_short_channel_ids(tmpctx, msg, &chain, &encoded)) {
+		peer_error(peer, "Bad query_short_channel_ids %s",
+			   tal_hex(tmpctx, msg));
+		return;
+	}
+
+	if (!structeq(&rstate->chain_hash, &chain)) {
+		status_trace("%s sent query_short_channel_ids chainhash %s",
+			     type_to_string(tmpctx, struct pubkey, &peer->id),
+			     type_to_string(tmpctx, struct bitcoin_blkid, &chain));
+		return;
+	}
+
+	/* BOLT #7:
+	 *
+	 * - if it has not sent `reply_short_channel_ids_end` to a
+	 *   previously received `query_short_channel_ids` from this
+         *   sender:
+	 *    - MAY fail the connection.
+	 */
+	if (peer->scid_queries || peer->scid_query_nodes) {
+		peer_error(peer, "Bad concurrent query_short_channel_ids");
+		return;
+	}
+
+	scids = decode_short_ids(tmpctx, encoded);
+	if (!scids) {
+		peer_error(peer, "Bad query_short_channel_ids encoding %s",
+			   tal_hex(tmpctx, encoded));
+		return;
+	}
+
+	/* BOLT #7:
+	 *
+	 * - SHOULD respond to each known `short_channel_id` with a
+	 *   `channel_announce`  and the latest `channel_update`s for each end
+	 *    - SHOULD NOT wait for the next outgoing announcement flush to send
+	 *      these.
+	 */
+	peer->scid_queries = tal_steal(peer, scids);
+	peer->scid_query_idx = 0;
+	peer->scid_query_nodes = tal_arr(peer, struct pubkey, 0);
+
+	/* Wake writer. */
+	if (peer->local)
+		/* Notify the peer-write loop */
+		msg_wake(&peer->local->peer_out);
+	else
+		/* Notify the daemon_conn-write loop */
+		msg_wake(&peer->remote->out);
+}
+
+static void handle_gossip_timestamp_filter(struct peer *peer, u8 *msg)
+{
+	struct bitcoin_blkid chain_hash;
+	u32 first_timestamp, timestamp_range;
+
+	if (!fromwire_gossip_timestamp_filter(msg, &chain_hash,
+					      &first_timestamp,
+					      &timestamp_range)) {
+		peer_error(peer, "Bad gossip_timestamp_filter %s",
+			   tal_hex(tmpctx, msg));
+		return;
+	}
+
+	if (!structeq(&peer->daemon->rstate->chain_hash, &chain_hash)) {
+		status_trace("%s sent gossip_timestamp_filter chainhash %s",
+			     type_to_string(tmpctx, struct pubkey, &peer->id),
+			     type_to_string(tmpctx, struct bitcoin_blkid,
+					    &chain_hash));
+		return;
+	}
+
+	/* First time, start gossip sync immediately. */
+	if (peer->gossip_timestamp_min > peer->gossip_timestamp_max)
+		wake_gossip_out(peer);
+
+	/* FIXME: We don't index by timestamp, so this forces a brute
+	 * search! */
+	peer->gossip_timestamp_min = first_timestamp;
+	peer->gossip_timestamp_max = first_timestamp + timestamp_range - 1;
+	if (peer->gossip_timestamp_max < peer->gossip_timestamp_min)
+		peer->gossip_timestamp_max = UINT32_MAX;
+	peer->broadcast_index = 0;
+}
+
+static void reply_channel_range(struct peer *peer,
+				u32 first_blocknum, u32 number_of_blocks,
+				const u8 *encoded)
+{
+	/* BOLT #7:
+	 *
+	 * - For each `reply_channel_range`:
+	 *   - MUST set with `chain_hash` equal to that of `query_channel_range`,
+	 *   - MUST encode a `short_channel_id` for every open channel it
+	 *     knows in blocks `first_blocknum` to `first_blocknum` plus
+	 *     `number_of_blocks` minus one.
+	 *   - MUST limit `number_of_blocks` to the maximum number of blocks
+         *     whose results could fit in `encoded_short_ids`
+	 *   - if does not maintain up-to-date channel information for
+	 *     `chain_hash`:
+	 *     - MUST set `complete` to 0.
+	 *   - otherwise:
+	 *     - SHOULD set `complete` to 1.
+	 */
+	u8 *msg = towire_reply_channel_range(NULL,
+					     &peer->daemon->rstate->chain_hash,
+					     first_blocknum,
+					     number_of_blocks,
+					     1, encoded);
+	queue_peer_msg(peer, take(msg));
+}
+
+static void queue_channel_ranges(struct peer *peer,
+				 u32 first_blocknum, u32 number_of_blocks)
+{
+	struct routing_state *rstate = peer->daemon->rstate;
+	u8 *encoded = encode_short_channel_ids_start(tmpctx);
+	struct short_channel_id scid;
+
+	/* BOLT #7:
+	 *
+	 * 1. type: 264 (`reply_channel_range`) (`gossip_queries`)
+	 * 2. data:
+	 *   * [`32`:`chain_hash`]
+	 *   * [`4`:`first_blocknum`]
+	 *   * [`4`:`number_of_blocks`]
+	 *   * [`1`:`complete`]
+	 *   * [`2`:`len`]
+	 *   * [`len`:`encoded_short_ids`]
+	 */
+	const size_t reply_overhead = 32 + 4 + 4 + 1 + 2;
+	const size_t max_encoded_bytes = 65535 - 2 - reply_overhead;
+
+	/* Avoid underflow: we don't use block 0 anyway */
+	if (first_blocknum == 0)
+		mk_short_channel_id(&scid, 1, 0, 0);
+	else
+		mk_short_channel_id(&scid, first_blocknum, 0, 0);
+	scid.u64--;
+
+	while (uintmap_after(&rstate->chanmap, &scid.u64)) {
+		u32 blocknum = short_channel_id_blocknum(&scid);
+		if (blocknum >= first_blocknum + number_of_blocks)
+			break;
+
+		encode_add_short_channel_id(&encoded, &scid);
+	}
+
+	if (encode_short_channel_ids_end(&encoded, max_encoded_bytes)) {
+		reply_channel_range(peer, first_blocknum, number_of_blocks,
+				    encoded);
+		return;
+	}
+
+	/* It wouldn't all fit: divide in half */
+	/* We assume we can always send one block! */
+	if (number_of_blocks <= 1) {
+		/* We always assume we can send 1 blocks worth */
+		status_broken("Could not fit scids for single block %u",
+			      first_blocknum);
+		return;
+	}
+	status_debug("queue_channel_ranges full: splitting %u+%u and %u+%u",
+		     first_blocknum,
+		     number_of_blocks / 2,
+		     first_blocknum + number_of_blocks / 2,
+		     number_of_blocks - number_of_blocks / 2);
+	queue_channel_ranges(peer, first_blocknum, number_of_blocks / 2);
+	queue_channel_ranges(peer, first_blocknum + number_of_blocks / 2,
+			     number_of_blocks - number_of_blocks / 2);
+}
+
+static void handle_query_channel_range(struct peer *peer, u8 *msg)
+{
+	struct bitcoin_blkid chain_hash;
+	u32 first_blocknum, number_of_blocks;
+
+	if (!fromwire_query_channel_range(msg, &chain_hash,
+					  &first_blocknum, &number_of_blocks)) {
+		peer_error(peer, "Bad query_channel_range %s",
+			   tal_hex(tmpctx, msg));
+		return;
+	}
+
+	if (!structeq(&peer->daemon->rstate->chain_hash, &chain_hash)) {
+		status_trace("%s sent query_channel_range chainhash %s",
+			     type_to_string(tmpctx, struct pubkey, &peer->id),
+			     type_to_string(tmpctx, struct bitcoin_blkid,
+					    &chain_hash));
+		return;
+	}
+
+	if (first_blocknum + number_of_blocks < first_blocknum) {
+		peer_error(peer, "query_channel_range overflow %u+%u",
+			   first_blocknum, number_of_blocks);
+		return;
+	}
+	queue_channel_ranges(peer, first_blocknum, number_of_blocks);
+}
+
 static void handle_ping(struct peer *peer, u8 *ping)
 {
 	u8 *pong;
@@ -695,6 +1137,125 @@ static void handle_pong(struct peer *peer, const u8 *pong)
 						       tal_len(pong))));
 }
 
+static void handle_reply_short_channel_ids_end(struct peer *peer, u8 *msg)
+{
+	struct bitcoin_blkid chain;
+	u8 complete;
+
+	if (!fromwire_reply_short_channel_ids_end(msg, &chain, &complete)) {
+		peer_error(peer, "Bad reply_short_channel_ids_end %s",
+			   tal_hex(tmpctx, msg));
+		return;
+	}
+
+	if (!structeq(&peer->daemon->rstate->chain_hash, &chain)) {
+		peer_error(peer, "reply_short_channel_ids_end for bad chain: %s",
+			   tal_hex(tmpctx, msg));
+		return;
+	}
+
+	if (peer->num_scid_queries_outstanding == 0) {
+		peer_error(peer, "unexpected reply_short_channel_ids_end: %s",
+			   tal_hex(tmpctx, msg));
+		return;
+	}
+
+	peer->num_scid_queries_outstanding--;
+	msg = towire_gossip_scids_reply(msg, true, complete);
+	daemon_conn_send(&peer->daemon->master, take(msg));
+}
+
+static void handle_reply_channel_range(struct peer *peer, u8 *msg)
+{
+	struct bitcoin_blkid chain;
+	u8 complete;
+	u32 first_blocknum, number_of_blocks;
+	u8 *encoded, *p;
+	struct short_channel_id *scids;
+	size_t n;
+
+	if (!fromwire_reply_channel_range(tmpctx, msg, &chain, &first_blocknum,
+					  &number_of_blocks, &complete,
+					  &encoded)) {
+		peer_error(peer, "Bad reply_channel_range %s",
+			   tal_hex(tmpctx, msg));
+		return;
+	}
+
+	if (!structeq(&peer->daemon->rstate->chain_hash, &chain)) {
+		peer_error(peer, "reply_channel_range for bad chain: %s",
+			   tal_hex(tmpctx, msg));
+		return;
+	}
+
+	if (!peer->query_channel_blocks) {
+		peer_error(peer, "reply_channel_range without query: %s",
+			   tal_hex(tmpctx, msg));
+		return;
+	}
+
+	if (first_blocknum + number_of_blocks < first_blocknum) {
+		peer_error(peer, "reply_channel_range invalid %u+%u",
+			   first_blocknum, number_of_blocks);
+		return;
+	}
+
+	scids = decode_short_ids(tmpctx, encoded);
+	if (!scids) {
+		peer_error(peer, "Bad reply_channel_range encoding %s",
+			   tal_hex(tmpctx, encoded));
+		return;
+	}
+
+	n = first_blocknum - peer->first_channel_range;
+	if (first_blocknum < peer->first_channel_range
+	    || n + number_of_blocks > tal_count(peer->query_channel_blocks)) {
+		peer_error(peer, "reply_channel_range invalid %u+%u for query %u+%u",
+			   first_blocknum, number_of_blocks,
+			   peer->first_channel_range,
+			   tal_count(peer->query_channel_blocks));
+		return;
+	}
+
+	p = memchr(peer->query_channel_blocks + n, 1, number_of_blocks);
+	if (p) {
+		peer_error(peer, "reply_channel_range %u+%u already have block %zu",
+			   first_blocknum, number_of_blocks,
+			   peer->first_channel_range + (p - peer->query_channel_blocks));
+		return;
+	}
+
+	/* Mark these blocks received */
+	memset(peer->query_channel_blocks + n, 1, number_of_blocks);
+
+	/* Add scids */
+	n = tal_count(peer->query_channel_scids);
+	tal_resize(&peer->query_channel_scids, n + tal_count(scids));
+	memcpy(peer->query_channel_scids + n, scids, tal_len(scids));
+
+	status_debug("peer %s reply_channel_range %u+%u (of %u+%zu) %zu scids",
+		     type_to_string(tmpctx, struct pubkey, &peer->id),
+		     first_blocknum, number_of_blocks,
+		     peer->first_channel_range,
+		     tal_count(peer->query_channel_blocks),
+		     tal_count(scids));
+
+	/* Still more to go? */
+	if (memchr(peer->query_channel_blocks, 0,
+		   tal_count(peer->query_channel_blocks)))
+		return;
+
+	/* All done, send reply */
+	msg = towire_gossip_query_channel_range_reply(NULL,
+						      first_blocknum,
+						      number_of_blocks,
+						      complete,
+						      peer->query_channel_scids);
+	daemon_conn_send(&peer->daemon->master, take(msg));
+	peer->query_channel_scids = tal_free(peer->query_channel_scids);
+	peer->query_channel_blocks = tal_free(peer->query_channel_blocks);
+}
+
 /* If master asks us to release peer, we attach this destructor in case it
  * dies while we're waiting for it to finish IO */
 static void fail_release(struct peer *peer)
@@ -774,6 +1335,26 @@ static struct io_plan *peer_msgin(struct io_conn *conn,
 		handle_pong(peer, msg);
 		return peer_next_in(conn, peer);
 
+	case WIRE_QUERY_SHORT_CHANNEL_IDS:
+		handle_query_short_channel_ids(peer, msg);
+		return peer_next_in(conn, peer);
+
+	case WIRE_REPLY_SHORT_CHANNEL_IDS_END:
+		handle_reply_short_channel_ids_end(peer, msg);
+		return peer_next_in(conn, peer);
+
+	case WIRE_GOSSIP_TIMESTAMP_FILTER:
+		handle_gossip_timestamp_filter(peer, msg);
+		return peer_next_in(conn, peer);
+
+	case WIRE_QUERY_CHANNEL_RANGE:
+		handle_query_channel_range(peer, msg);
+		return peer_next_in(conn, peer);
+
+	case WIRE_REPLY_CHANNEL_RANGE:
+		handle_reply_channel_range(peer, msg);
+		return peer_next_in(conn, peer);
+
 	case WIRE_OPEN_CHANNEL:
 	case WIRE_CHANNEL_REESTABLISH:
 	case WIRE_ACCEPT_CHANNEL:
@@ -813,33 +1394,172 @@ static struct io_plan *peer_msgin(struct io_conn *conn,
 	return peer_next_in(conn, peer);
 }
 
-/* Wake up the outgoing direction of the connection and write any
- * queued messages. Needed since the `io_wake` method signature does
- * not allow us to specify it as the callback for `new_reltimer`, but
- * it allows us to set an additional flag for the routing dump..
+/* Mutual recursion. */
+static struct io_plan *peer_pkt_out(struct io_conn *conn, struct peer *peer);
+
+/* We keep a simple array of node ids while we're sending channel info */
+static void append_query_node(struct peer *peer, const struct pubkey *id)
+{
+	size_t n;
+	n = tal_count(peer->scid_query_nodes);
+	tal_resize(&peer->scid_query_nodes, n+1);
+	peer->scid_query_nodes[n] = *id;
+}
+
+/* Arbitrary ordering function of pubkeys.
+ *
+ * Note that we could use memcmp() here: even if they had somehow different
+ * bitwise representations for the same key, we copied them all from struct
+ * node which should make them unique.  Even if not (say, a node vanished
+ * and reappeared) we'd just end up sending two node_announcement for the
+ * same node.
  */
-static void wake_pkt_out(struct peer *peer)
+static int pubkey_order(const struct pubkey *k1, const struct pubkey *k2,
+			void *unused UNUSED)
 {
-	peer->gossip_sync = true;
-	new_reltimer(&peer->daemon->timers, peer,
-		     time_from_msec(peer->daemon->broadcast_interval),
-		     wake_pkt_out, peer);
+	return pubkey_cmp(k1, k2);
+}
 
-	if (peer->local)
-		/* Notify the peer-write loop */
-		msg_wake(&peer->local->peer_out);
-	else if (peer->remote)
-		/* Notify the daemon_conn-write loop */
-		msg_wake(&peer->remote->out);
+static void uniquify_node_ids(struct pubkey **ids)
+{
+	size_t dst, src;
+
+	/* BOLT #7:
+	 *
+	 * - MUST follow with any `node_announcement`s for each
+	 *   `channel_announcement`
+	 *
+	 *   - SHOULD avoid sending duplicate `node_announcements` in
+	 *     response to a single `query_short_channel_ids`.
+	 */
+	asort(*ids, tal_count(*ids), pubkey_order, NULL);
+
+	for (dst = 0, src = 0; src < tal_count(*ids); src++) {
+		if (dst && pubkey_eq(&(*ids)[dst-1], &(*ids)[src]))
+			continue;
+		(*ids)[dst++] = (*ids)[src];
+	}
+	tal_resize(ids, dst);
 }
 
-/* Mutual recursion. */
-static struct io_plan *peer_pkt_out(struct io_conn *conn, struct peer *peer);
+static bool create_next_scid_reply(struct peer *peer)
+{
+	struct routing_state *rstate = peer->daemon->rstate;
+	size_t i, num;
+	bool sent = false;
+
+	/* BOLT #7:
+	 *
+	 *   - SHOULD respond to each known `short_channel_id` with a
+	 *     `channel_announce` and the latest `channel_update`s for
+	 *     each end
+	 *
+	 *   - SHOULD NOT wait for the next outgoing announcement flush
+	 *     to send these.
+	 */
+	num = tal_count(peer->scid_queries);
+	for (i = peer->scid_query_idx; !sent && i < num; i++) {
+		struct chan *chan;
+
+		chan = get_channel(rstate, &peer->scid_queries[i]);
+		if (!chan || !is_chan_public(chan))
+			continue;
+
+		queue_peer_msg(peer, chan->channel_announce);
+		if (chan->half[0].channel_update)
+			queue_peer_msg(peer, chan->half[0].channel_update);
+		if (chan->half[1].channel_update)
+			queue_peer_msg(peer, chan->half[0].channel_update);
+
+		/* Record node ids for later transmission of node_announcement */
+		append_query_node(peer, &chan->nodes[0]->id);
+		append_query_node(peer, &chan->nodes[1]->id);
+		sent = true;
+	}
+
+	/* Just finished channels?  Remove duplicate nodes. */
+	if (peer->scid_query_idx != num && i == num)
+		uniquify_node_ids(&peer->scid_query_nodes);
+	peer->scid_query_idx = i;
+
+	/* BOLT #7:
+	 *
+	 *  - MUST follow with any `node_announcement`s for each
+	 *   `channel_announcement`
+	 *    - SHOULD avoid sending duplicate `node_announcements` in response
+	 *     to a single `query_short_channel_ids`.
+	 */
+	num = tal_count(peer->scid_query_nodes);
+	for (i = peer->scid_query_nodes_idx; !sent && i < num; i++) {
+		const struct node *n;
+
+		n = get_node(rstate, &peer->scid_query_nodes[i]);
+		if (!n || !n->node_announcement || !n->node_announcement_public)
+			continue;
+
+		queue_peer_msg(peer, n->node_announcement);
+		sent = true;
+	}
+	peer->scid_query_nodes_idx = i;
+
+	/* All finished? */
+	if (peer->scid_queries && peer->scid_query_nodes_idx == num) {
+		/* BOLT #7:
+		 *
+		 * - MUST follow these responses with
+		 *   `reply_short_channel_ids_end`.
+		 *   - if does not maintain up-to-date channel information for
+		 *     `chain_hash`:
+		 *      - MUST set `complete` to 0.
+		 *   - otherwise:
+		 *      - SHOULD set `complete` to 1.
+		 */
+		u8 *end = towire_reply_short_channel_ids_end(peer,
+							     &rstate->chain_hash,
+							     true);
+		queue_peer_msg(peer, take(end));
+		peer->scid_queries = tal_free(peer->scid_queries);
+		peer->scid_query_idx = 0;
+		peer->scid_query_nodes = tal_free(peer->scid_query_nodes);
+		peer->scid_query_nodes_idx = 0;
+	}
+
+	return sent;
+}
+
+/* If we're supposed to be sending gossip, do so now. */
+static bool maybe_queue_gossip(struct peer *peer)
+{
+	const u8 *next;
+
+	if (peer->gossip_timer)
+		return false;
+
+	next = next_broadcast(peer->daemon->rstate->broadcasts,
+			      peer->gossip_timestamp_min,
+			      peer->gossip_timestamp_max,
+			      &peer->broadcast_index);
+
+	if (next) {
+		queue_peer_msg(peer, next);
+		return true;
+	}
+
+	/* Gossip is drained.  Wait for next timer. */
+	peer->gossip_timer
+		= new_reltimer(&peer->daemon->timers, peer,
+			       time_from_msec(peer->daemon->broadcast_interval),
+			       wake_gossip_out, peer);
+	return false;
+}
 
 static struct io_plan *peer_pkt_out(struct io_conn *conn, struct peer *peer)
 {
 	/* First priority is queued packets, if any */
-	const u8 *out = msg_dequeue(&peer->local->peer_out);
+	const u8 *out;
+
+again:
+	out = msg_dequeue(&peer->local->peer_out);
 	if (out) {
 		if (is_all_channel_error(out))
 			return peer_write_message(conn, &peer->local->pcs,
@@ -853,20 +1573,10 @@ static struct io_plan *peer_pkt_out(struct io_conn *conn, struct peer *peer)
 	if (peer->local->return_to_master) {
 		if (!peer_in_started(conn, &peer->local->pcs))
 			return ready_for_master(conn, peer);
-	} else if (peer->gossip_sync) {
-		/* If we're supposed to be sending gossip, do so now. */
-		const u8 *next;
-
-		next = next_broadcast(peer->daemon->rstate->broadcasts,
-				      &peer->broadcast_index);
-
-		if (next)
-			return peer_write_message(conn, &peer->local->pcs,
-						  next,
-						  peer_pkt_out);
-
-		/* Gossip is drained.  Wait for next timer. */
-		peer->gossip_sync = false;
+	} else if (create_next_scid_reply(peer)) {
+		goto again;
+	} else if (maybe_queue_gossip(peer)) {
+		goto again;
 	}
 
 	return msg_queue_wait(conn, &peer->local->peer_out, peer_pkt_out, peer);
@@ -875,7 +1585,7 @@ static struct io_plan *peer_pkt_out(struct io_conn *conn, struct peer *peer)
 /* Now we're a fully-fledged peer. */
 static struct io_plan *peer_start_gossip(struct io_conn *conn, struct peer *peer)
 {
-	wake_pkt_out(peer);
+	wake_gossip_out(peer);
 	return io_duplex(conn,
 			 peer_next_in(conn, peer),
 			 peer_pkt_out(conn, peer));
@@ -1042,6 +1752,9 @@ static void handle_local_channel_update(struct peer *peer, const u8 *msg)
 	/* We always tell peer, even if it's not public yet */
 	if (!is_chan_public(chan))
 		queue_peer_msg(peer, take(cupdate));
+
+	/* That channel_update might trigger our first channel_announcement */
+	maybe_send_own_node_announce(peer->daemon);
 }
 
 /**
@@ -1060,7 +1773,12 @@ static struct io_plan *owner_msg_in(struct io_conn *conn,
 		err = handle_gossip_msg(peer->daemon, dc->msg_in, "subdaemon");
 		if (err)
 			queue_peer_msg(peer, take(err));
-
+	} else if (type == WIRE_QUERY_SHORT_CHANNEL_IDS) {
+		handle_query_short_channel_ids(peer, dc->msg_in);
+	} else if (type == WIRE_REPLY_SHORT_CHANNEL_IDS_END) {
+		handle_reply_short_channel_ids_end(peer, dc->msg_in);
+	} else if (type == WIRE_GOSSIP_TIMESTAMP_FILTER) {
+		handle_gossip_timestamp_filter(peer, dc->msg_in);
 	} else if (type == WIRE_GOSSIP_GET_UPDATE) {
 		handle_get_update(peer, dc->msg_in);
 	} else if (type == WIRE_GOSSIP_LOCAL_ADD_CHANNEL) {
@@ -1069,6 +1787,10 @@ static struct io_plan *owner_msg_in(struct io_conn *conn,
 		handle_local_add_channel(peer->daemon->rstate, dc->msg_in);
 	} else if (type == WIRE_GOSSIP_LOCAL_CHANNEL_UPDATE) {
 		handle_local_channel_update(peer, dc->msg_in);
+	} else if (type == WIRE_QUERY_CHANNEL_RANGE) {
+		handle_query_channel_range(peer, dc->msg_in);
+	} else if (type == WIRE_REPLY_CHANNEL_RANGE) {
+		handle_reply_channel_range(peer, dc->msg_in);
 	} else {
 		status_broken("peer %s: send us unknown msg of type %s",
 			      type_to_string(tmpctx, struct pubkey, &peer->id),
@@ -1129,27 +1851,17 @@ static bool send_peer_with_fds(struct peer *peer, const u8 *msg)
  */
 static bool nonlocal_dump_gossip(struct io_conn *conn, struct daemon_conn *dc)
 {
-	const u8 *next;
 	struct peer *peer = dc->ctx;
 
 	/* Make sure we are not connected directly */
 	assert(!peer->local);
 
-	/* Nothing to do if we're not gossiping */
-	if (!peer->gossip_sync)
-		return false;
-
-	next = next_broadcast(peer->daemon->rstate->broadcasts,
-			      &peer->broadcast_index);
-
-	if (!next) {
-		peer->gossip_sync = false;
-		return false;
-	} else {
-		u8 *msg = towire_gossip_send_gossip(NULL, next);
-		daemon_conn_send(peer->remote, take(msg));
+	/* Do we have scid query replies to send? */
+	if (create_next_scid_reply(peer))
 		return true;
-	}
+
+	/* Otherwise queue any gossip we want to send */
+	return maybe_queue_gossip(peer);
 }
 
 static struct io_plan *new_peer_got_fd(struct io_conn *conn, struct peer *peer)
@@ -1472,6 +2184,7 @@ static struct io_plan *getnodes(struct io_conn *conn, struct daemon *daemon,
 	return daemon_conn_read_next(conn, &daemon->master);
 }
 
+#if DEVELOPER
 static struct io_plan *ping_req(struct io_conn *conn, struct daemon *daemon,
 				const u8 *msg)
 {
@@ -1514,6 +2227,161 @@ static struct io_plan *ping_req(struct io_conn *conn, struct daemon *daemon,
 	return daemon_conn_read_next(conn, &daemon->master);
 }
 
+static struct io_plan *query_scids_req(struct io_conn *conn,
+				       struct daemon *daemon,
+				       const u8 *msg)
+{
+	struct pubkey id;
+	struct short_channel_id *scids;
+	struct peer *peer;
+	u8 *encoded;
+	/* BOLT #7:
+	 *
+	 * 1. type: 261 (`query_short_channel_ids`) (`gossip_queries`)
+	 * 2. data:
+	 *     * [`32`:`chain_hash`]
+	 *     * [`2`:`len`]
+	 *     * [`len`:`encoded_short_ids`]
+	 */
+	const size_t reply_overhead = 32 + 2;
+	const size_t max_encoded_bytes = 65535 - 2 - reply_overhead;
+
+	if (!fromwire_gossip_query_scids(msg, msg, &id, &scids))
+		master_badmsg(WIRE_GOSSIP_QUERY_SCIDS, msg);
+
+	peer = find_peer(daemon, &id);
+	if (!peer) {
+		status_broken("query_scids: unknown peer %s",
+			      type_to_string(tmpctx, struct pubkey, &id));
+		goto fail;
+	}
+
+	if (!feature_offered(peer->lfeatures, LOCAL_GOSSIP_QUERIES)) {
+		status_broken("query_scids: no gossip_query support in peer %s",
+			      type_to_string(tmpctx, struct pubkey, &id));
+		goto fail;
+	}
+
+	encoded = encode_short_channel_ids_start(tmpctx);
+	for (size_t i = 0; i < tal_count(scids); i++)
+		encode_add_short_channel_id(&encoded, &scids[i]);
+
+	if (!encode_short_channel_ids_end(&encoded, max_encoded_bytes)) {
+		status_broken("query_short_channel_ids: %zu is too many",
+			      tal_count(scids));
+		goto fail;
+	}
+
+	msg = towire_query_short_channel_ids(NULL, &daemon->rstate->chain_hash,
+					     encoded);
+	queue_peer_msg(peer, take(msg));
+	peer->num_scid_queries_outstanding++;
+
+	status_trace("sending query for %zu scids", tal_count(scids));
+out:
+	return daemon_conn_read_next(conn, &daemon->master);
+
+fail:
+	daemon_conn_send(&daemon->master,
+			 take(towire_gossip_scids_reply(NULL, false, false)));
+	goto out;
+}
+
+static struct io_plan *send_timestamp_filter(struct io_conn *conn,
+					     struct daemon *daemon,
+					     const u8 *msg)
+{
+	struct pubkey id;
+	u32 first, range;
+	struct peer *peer;
+
+	if (!fromwire_gossip_send_timestamp_filter(msg, &id, &first, &range))
+		master_badmsg(WIRE_GOSSIP_SEND_TIMESTAMP_FILTER, msg);
+
+	peer = find_peer(daemon, &id);
+	if (!peer) {
+		status_broken("send_timestamp_filter: unknown peer %s",
+			      type_to_string(tmpctx, struct pubkey, &id));
+		goto out;
+	}
+
+	if (!feature_offered(peer->lfeatures, LOCAL_GOSSIP_QUERIES)) {
+		status_broken("send_timestamp_filter: no gossip_query support in peer %s",
+			      type_to_string(tmpctx, struct pubkey, &id));
+		goto out;
+	}
+
+	msg = towire_gossip_timestamp_filter(NULL, &daemon->rstate->chain_hash,
+					     first, range);
+	queue_peer_msg(peer, take(msg));
+out:
+	return daemon_conn_read_next(conn, &daemon->master);
+}
+
+static struct io_plan *query_channel_range(struct io_conn *conn,
+					   struct daemon *daemon,
+					   const u8 *msg)
+{
+	struct pubkey id;
+	u32 first_blocknum, number_of_blocks;
+	struct peer *peer;
+
+	if (!fromwire_gossip_query_channel_range(msg, &id, &first_blocknum,
+						 &number_of_blocks))
+		master_badmsg(WIRE_GOSSIP_QUERY_SCIDS, msg);
+
+	peer = find_peer(daemon, &id);
+	if (!peer) {
+		status_broken("query_channel_range: unknown peer %s",
+			      type_to_string(tmpctx, struct pubkey, &id));
+		goto fail;
+	}
+
+	if (!feature_offered(peer->lfeatures, LOCAL_GOSSIP_QUERIES)) {
+		status_broken("query_channel_range: no gossip_query support in peer %s",
+			      type_to_string(tmpctx, struct pubkey, &id));
+		goto fail;
+	}
+
+	if (peer->query_channel_blocks) {
+		status_broken("query_channel_range: previous query active");
+		goto fail;
+	}
+
+	status_debug("sending query_channel_range for blocks %u+%u",
+		     first_blocknum, number_of_blocks);
+	msg = towire_query_channel_range(NULL, &daemon->rstate->chain_hash,
+					 first_blocknum, number_of_blocks);
+	queue_peer_msg(peer, take(msg));
+	peer->first_channel_range = first_blocknum;
+	/* This uses 8 times as much as it needs to, but it's only for dev */
+	peer->query_channel_blocks = tal_arrz(peer, u8, number_of_blocks);
+	peer->query_channel_scids = tal_arr(peer, struct short_channel_id, 0);
+
+out:
+	return daemon_conn_read_next(conn, &daemon->master);
+
+fail:
+	daemon_conn_send(&daemon->master,
+			 take(towire_gossip_query_channel_range_reply(NULL,
+								      0, 0,
+								      false,
+								      NULL)));
+	goto out;
+}
+
+static struct io_plan *dev_set_max_scids_encode_size(struct io_conn *conn,
+						     struct daemon *daemon,
+						     const u8 *msg)
+{
+	if (!fromwire_gossip_dev_set_max_scids_encode_size(msg,
+							   &max_scids_encode_bytes))
+		master_badmsg(WIRE_GOSSIP_DEV_SET_MAX_SCIDS_ENCODE_SIZE, msg);
+
+	return daemon_conn_read_next(conn, &daemon->master);
+}
+#endif /* DEVELOPER */
+
 static int make_listen_fd(int domain, void *addr, socklen_t len, bool mayfail)
 {
 	int fd = socket(domain, SOCK_STREAM, 0);
@@ -2005,6 +2873,10 @@ static struct io_plan *gossip_activate(struct daemon_conn *master,
 	else
 		binding = NULL;
 
+	/* Now we know our addresses, re-announce ourselves if we have a
+	 * channel, in case options have changed. */
+	maybe_send_own_node_announce(daemon);
+
 	/* OK, we're ready! */
 	daemon_conn_send(&daemon->master,
 			 take(towire_gossipctl_activate_reply(NULL,
@@ -2562,8 +3434,8 @@ static struct io_plan *handle_txout_reply(struct io_conn *conn,
 	if (!fromwire_gossip_get_txout_reply(msg, msg, &scid, &satoshis, &outscript))
 		master_badmsg(WIRE_GOSSIP_GET_TXOUT_REPLY, msg);
 
-	if (handle_pending_cannouncement(daemon->rstate, &scid, satoshis, outscript))
-		send_node_announcement(daemon);
+	handle_pending_cannouncement(daemon->rstate, &scid, satoshis, outscript);
+	maybe_send_own_node_announce(daemon);
 
 	return daemon_conn_read_next(conn, &daemon->master);
 }
@@ -2683,9 +3555,6 @@ static struct io_plan *recv_req(struct io_conn *conn, struct daemon_conn *master
 	case WIRE_GOSSIP_GETCHANNELS_REQUEST:
 		return getchannels_req(conn, daemon, daemon->master.msg_in);
 
-	case WIRE_GOSSIP_PING:
-		return ping_req(conn, daemon, daemon->master.msg_in);
-
 	case WIRE_GOSSIP_RESOLVE_CHANNEL_REQUEST:
 		return resolve_channel_req(conn, daemon, daemon->master.msg_in);
 
@@ -2725,6 +3594,31 @@ static struct io_plan *recv_req(struct io_conn *conn, struct daemon_conn *master
 	case WIRE_GOSSIP_LOCAL_CHANNEL_CLOSE:
 		return handle_local_channel_close(conn, daemon, master->msg_in);
 
+#if DEVELOPER
+	case WIRE_GOSSIP_PING:
+		return ping_req(conn, daemon, daemon->master.msg_in);
+
+	case WIRE_GOSSIP_QUERY_SCIDS:
+		return query_scids_req(conn, daemon, daemon->master.msg_in);
+
+	case WIRE_GOSSIP_SEND_TIMESTAMP_FILTER:
+		return send_timestamp_filter(conn, daemon, daemon->master.msg_in);
+
+	case WIRE_GOSSIP_QUERY_CHANNEL_RANGE:
+		return query_channel_range(conn, daemon, daemon->master.msg_in);
+
+	case WIRE_GOSSIP_DEV_SET_MAX_SCIDS_ENCODE_SIZE:
+		return dev_set_max_scids_encode_size(conn, daemon,
+						     daemon->master.msg_in);
+#else
+	case WIRE_GOSSIP_PING:
+	case WIRE_GOSSIP_QUERY_SCIDS:
+	case WIRE_GOSSIP_SEND_TIMESTAMP_FILTER:
+	case WIRE_GOSSIP_QUERY_CHANNEL_RANGE:
+	case WIRE_GOSSIP_DEV_SET_MAX_SCIDS_ENCODE_SIZE:
+		break;
+#endif /* !DEVELOPER */
+
 	/* We send these, we don't receive them */
 	case WIRE_GOSSIPCTL_ACTIVATE_REPLY:
 	case WIRE_GOSSIPCTL_RELEASE_PEER_REPLY:
@@ -2734,6 +3628,8 @@ static struct io_plan *recv_req(struct io_conn *conn, struct daemon_conn *master
 	case WIRE_GOSSIP_GETCHANNELS_REPLY:
 	case WIRE_GOSSIP_GETPEERS_REPLY:
 	case WIRE_GOSSIP_PING_REPLY:
+	case WIRE_GOSSIP_SCIDS_REPLY:
+	case WIRE_GOSSIP_QUERY_CHANNEL_RANGE_REPLY:
 	case WIRE_GOSSIP_RESOLVE_CHANNEL_REPLY:
 	case WIRE_GOSSIP_PEER_CONNECTED:
 	case WIRE_GOSSIPCTL_CONNECT_TO_PEER_RESULT:
@@ -2778,7 +3674,6 @@ int main(int argc, char *argv[])
 	timers_init(&daemon->timers, time_mono());
 	daemon->broadcast_interval = 30000;
 	daemon->last_announce_timestamp = 0;
-
 	/* stdin == control */
 	daemon_conn_init(daemon, &daemon->master, STDIN_FILENO, recv_req,
 			 master_gone);
diff --git a/gossipd/gossip_wire.csv b/gossipd/gossip_wire.csv
index 53acd72dfec1..7d2461632f36 100644
--- a/gossipd/gossip_wire.csv
+++ b/gossipd/gossip_wire.csv
@@ -155,6 +155,41 @@ gossip_ping_reply,,sent,bool
 # 0 == no pong expected
 gossip_ping_reply,,totlen,u16
 
+# Test of query_short_channel_ids.  Master->gossipd
+gossip_query_scids,3031
+gossip_query_scids,,id,struct pubkey
+gossip_query_scids,,num_ids,u16
+gossip_query_scids,,ids,num_ids*struct short_channel_id
+
+# Gossipd -> master
+gossip_scids_reply,3131
+gossip_scids_reply,,ok,bool
+gossip_scids_reply,,complete,bool
+
+# Test gossip timestamp filtering.
+gossip_send_timestamp_filter,3028
+gossip_send_timestamp_filter,,id,struct pubkey
+gossip_send_timestamp_filter,,first_timestamp,u32
+gossip_send_timestamp_filter,,timestamp_range,u32
+
+# Test of query_channel_range.  Master->gossipd
+gossip_query_channel_range,3029
+gossip_query_channel_range,,id,struct pubkey
+gossip_query_channel_range,,first_blocknum,u32
+gossip_query_channel_range,,number_of_blocks,u32
+
+# Gossipd -> master
+gossip_query_channel_range_reply,3129
+gossip_query_channel_range_reply,,final_first_block,u32
+gossip_query_channel_range_reply,,final_num_blocks,u32
+gossip_query_channel_range_reply,,final_complete,bool
+gossip_query_channel_range_reply,,num,u16
+gossip_query_channel_range_reply,,scids,num*struct short_channel_id
+
+# Set artificial maximum reply_channel_range size.  Master->gossipd
+gossip_dev_set_max_scids_encode_size,3030
+gossip_dev_set_max_scids_encode_size,,max,u32
+
 # Given a short_channel_id, return the endpoints
 gossip_resolve_channel_request,3009
 gossip_resolve_channel_request,,channel_id,struct short_channel_id
diff --git a/gossipd/routing.c b/gossipd/routing.c
index 23dcb1fe4e23..03ddd362bd3f 100644
--- a/gossipd/routing.c
+++ b/gossipd/routing.c
@@ -98,6 +98,7 @@ struct routing_state *new_routing_state(const tal_t *ctx,
 	rstate->prune_timeout = prune_timeout;
 	rstate->store = gossip_store_new(rstate);
 	rstate->dev_allow_localhost = dev_allow_localhost;
+	rstate->local_channel_announced = false;
 	list_head_init(&rstate->pending_cannouncement);
 	uintmap_init(&rstate->chanmap);
 
@@ -149,6 +150,7 @@ static struct node *new_node(struct routing_state *rstate,
 	n->chans = tal_arr(n, struct chan *, 0);
 	n->alias = NULL;
 	n->node_announcement = NULL;
+	n->node_announcement_public = false;
 	n->last_timestamp = -1;
 	n->addresses = tal_arr(n, struct wireaddr, 0);
 	node_map_add(rstate->nodes, n);
@@ -604,6 +606,34 @@ static void destroy_pending_cannouncement(struct pending_cannouncement *pending,
 	list_del_from(&rstate->pending_cannouncement, &pending->list);
 }
 
+static bool is_local_channel(const struct routing_state *rstate,
+			     const struct chan *chan)
+{
+	return pubkey_eq(&chan->nodes[0]->id, &rstate->local_id)
+		|| pubkey_eq(&chan->nodes[1]->id, &rstate->local_id);
+}
+
+static void add_channel_announce_to_broadcast(struct routing_state *rstate,
+					      struct chan *chan,
+					      u32 timestamp)
+{
+	insert_broadcast(rstate->broadcasts, chan->channel_announce, timestamp);
+	rstate->local_channel_announced |= is_local_channel(rstate, chan);
+
+	/* If we've been waiting for this, now we can announce node */
+	for (size_t i = 0; i < ARRAY_SIZE(chan->nodes); i++) {
+		struct node *node = chan->nodes[i];
+		if (!node->node_announcement)
+			continue;
+		if (!node->node_announcement_public) {
+			node->node_announcement_public = true;
+			insert_broadcast(rstate->broadcasts,
+					 node->node_announcement,
+					 node->last_timestamp);
+		}
+	}
+}
+
 bool routing_add_channel_announcement(struct routing_state *rstate,
 				      const u8 *msg TAKES, u64 satoshis)
 {
@@ -635,16 +665,11 @@ bool routing_add_channel_announcement(struct routing_state *rstate,
 	/* Channel is now public. */
 	chan->channel_announce = tal_dup_arr(chan, u8, msg, tal_len(msg), 0);
 
-	/* Now we can broadcast channel announce */
-	insert_broadcast(rstate->broadcasts, chan->channel_announce);
-
-	/* If we had private updates for channels, we can broadcast them too. */
-	for (size_t i = 0; i < ARRAY_SIZE(chan->half); i++) {
-		if (!is_halfchan_defined(&chan->half[i]))
-			continue;
-		insert_broadcast(rstate->broadcasts,
-				 chan->half[i].channel_update);
-	}
+	/* Clear any private updates: new updates will trigger broadcast of
+	 * this channel_announce. */
+	for (size_t i = 0; i < ARRAY_SIZE(chan->half); i++)
+		chan->half[i].channel_update
+			= tal_free(chan->half[i].channel_update);
 
 	return true;
 }
@@ -802,18 +827,17 @@ static void process_pending_channel_update(struct routing_state *rstate,
 	}
 }
 
-bool handle_pending_cannouncement(struct routing_state *rstate,
+void handle_pending_cannouncement(struct routing_state *rstate,
 				  const struct short_channel_id *scid,
 				  const u64 satoshis,
 				  const u8 *outscript)
 {
-	bool local;
 	const u8 *s;
 	struct pending_cannouncement *pending;
 
 	pending = find_pending_cannouncement(rstate, scid);
 	if (!pending)
-		return false;
+		return;
 
 	/* BOLT #7:
 	 *
@@ -824,7 +848,7 @@ bool handle_pending_cannouncement(struct routing_state *rstate,
 			     type_to_string(pending, struct short_channel_id,
 					    scid));
 		tal_free(pending);
-		return false;
+		return;
 	}
 
 	/* BOLT #7:
@@ -846,7 +870,7 @@ bool handle_pending_cannouncement(struct routing_state *rstate,
 					    scid),
 			     tal_hex(tmpctx, s), tal_hex(tmpctx, outscript));
 		tal_free(pending);
-		return false;
+		return;
 	}
 
 	if (!routing_add_channel_announcement(rstate, pending->announce, satoshis))
@@ -854,9 +878,6 @@ bool handle_pending_cannouncement(struct routing_state *rstate,
 			      "Could not add channel_announcement");
 	gossip_store_add_channel_announcement(rstate->store, pending->announce, satoshis);
 
-	local = pubkey_eq(&pending->node_id_1, &rstate->local_id) ||
-		pubkey_eq(&pending->node_id_2, &rstate->local_id);
-
 	/* Did we have an update waiting?  If so, apply now. */
 	process_pending_channel_update(rstate, scid, pending->updates[0]);
 	process_pending_channel_update(rstate, scid, pending->updates[1]);
@@ -865,7 +886,6 @@ bool handle_pending_cannouncement(struct routing_state *rstate,
 	process_pending_node_announcement(rstate, &pending->node_id_2);
 
 	tal_free(pending);
-	return local;
 }
 
 static void update_pending(struct pending_cannouncement *pending,
@@ -937,6 +957,7 @@ bool routing_add_channel_update(struct routing_state *rstate,
 	struct bitcoin_blkid chain_hash;
 	struct chan *chan;
 	u8 direction;
+	bool have_broadcast_announce;
 
 	if (!fromwire_channel_update(update, &signature, &chain_hash,
 				     &short_channel_id, &timestamp, &flags,
@@ -947,6 +968,10 @@ bool routing_add_channel_update(struct routing_state *rstate,
 	if (!chan)
 		return false;
 
+	/* We broadcast announce once we have one update */
+	have_broadcast_announce = is_halfchan_defined(&chan->half[0])
+		|| is_halfchan_defined(&chan->half[1]);
+
 	direction = flags & 0x1;
 	set_connection_values(chan, direction, fee_base_msat,
 			      fee_proportional_millionths, expiry,
@@ -962,8 +987,18 @@ bool routing_add_channel_update(struct routing_state *rstate,
 	if (!chan->channel_announce)
 		return true;
 
+	/* BOLT #7:
+	 *   - MUST consider the `timestamp` of the `channel_announcement` to be
+	 *     the `timestamp` of a corresponding `channel_update`.
+	 *   - MUST consider whether to send the `channel_announcement` after
+	 *     receiving the first corresponding `channel_update`.
+	 */
+	if (!have_broadcast_announce)
+		add_channel_announce_to_broadcast(rstate, chan, timestamp);
+
 	insert_broadcast(rstate->broadcasts,
-			 chan->half[direction].channel_update);
+			 chan->half[direction].channel_update,
+			 timestamp);
 	return true;
 }
 
@@ -1036,6 +1071,28 @@ u8 *handle_channel_update(struct routing_state *rstate, const u8 *update,
 		}
 	}
 
+	/* BOLT #7:
+	 *
+	 *  - if the `timestamp` is unreasonably far in the future:
+	 *    - MAY discard the `channel_announcement`.
+	 */
+	if (timestamp > time_now().ts.tv_sec + rstate->prune_timeout) {
+		status_debug("Received channel_update for %s with far time %u",
+			     type_to_string(tmpctx, struct short_channel_id,
+					    &short_channel_id),
+			     timestamp);
+		return NULL;
+	}
+
+	/* Note: we can consider old timestamps a case of "instant prune" too */
+	if (timestamp < time_now().ts.tv_sec - rstate->prune_timeout) {
+		status_debug("Received channel_update for %s with old time %u",
+			     type_to_string(tmpctx, struct short_channel_id,
+					    &short_channel_id),
+			     timestamp);
+		return NULL;
+	}
+
 	c = &chan->half[direction];
 
 	if (is_halfchan_defined(c) && timestamp <= c->last_timestamp) {
@@ -1070,11 +1127,12 @@ u8 *handle_channel_update(struct routing_state *rstate, const u8 *update,
 		return err;
 	}
 
-	status_trace("Received channel_update for channel %s(%d) now %s",
+	status_trace("Received channel_update for channel %s(%d) now %s (from %s)",
 		     type_to_string(tmpctx, struct short_channel_id,
 				    &short_channel_id),
 		     flags & 0x01,
-		     flags & ROUTING_FLAGS_DISABLED ? "DISABLED" : "ACTIVE");
+		     flags & ROUTING_FLAGS_DISABLED ? "DISABLED" : "ACTIVE",
+		     source);
 
 	if (!routing_add_channel_update(rstate, serialized))
 		status_failed(STATUS_FAIL_INTERNAL_ERROR,
@@ -1122,6 +1180,29 @@ static struct wireaddr *read_addresses(const tal_t *ctx, const u8 *ser)
 	return wireaddrs;
 }
 
+/* We've received a channel_announce for a channel attached to this node */
+static bool node_has_public_channels(struct node *node)
+{
+	for (size_t i = 0; i < tal_count(node->chans); i++)
+		if (is_chan_public(node->chans[i]))
+			return true;
+	return false;
+}
+
+/* We can *send* a channel_announce for a channel attached to this node:
+ * we only send once we have a channel_update. */
+static bool node_has_broadcastable_channels(struct node *node)
+{
+	for (size_t i = 0; i < tal_count(node->chans); i++) {
+		if (!is_chan_public(node->chans[i]))
+			continue;
+		if (is_halfchan_defined(&node->chans[i]->half[0])
+		    || is_halfchan_defined(&node->chans[i]->half[1]))
+			return true;
+	}
+	return false;
+}
+
 bool routing_add_node_announcement(struct routing_state *rstate, const u8 *msg TAKES)
 {
 	struct node *node;
@@ -1157,16 +1238,17 @@ bool routing_add_node_announcement(struct routing_state *rstate, const u8 *msg T
 
 	tal_free(node->node_announcement);
 	node->node_announcement = tal_dup_arr(node, u8, msg, tal_len(msg), 0);
-	insert_broadcast(rstate->broadcasts, node->node_announcement);
-	return true;
-}
 
-static bool node_has_public_channels(struct node *node)
-{
-	for (size_t i = 0; i < tal_count(node->chans); i++)
-		if (is_chan_public(node->chans[i]))
-			return true;
-	return false;
+	/* FIXME:
+	 * When a channel is closed, the node announce may now be out of
+	 * order.  It's not vital, but would be nice to fix.
+	 */
+	/* We might be waiting for channel_announce to be released. */
+	node->node_announcement_public = node_has_broadcastable_channels(node);
+	if (node->node_announcement_public)
+		insert_broadcast(rstate->broadcasts, node->node_announcement,
+				 timestamp);
+	return true;
 }
 
 u8 *handle_node_announcement(struct routing_state *rstate, const u8 *node_ann)
diff --git a/gossipd/routing.h b/gossipd/routing.h
index 39b90d54fc42..46be560ab69a 100644
--- a/gossipd/routing.h
+++ b/gossipd/routing.h
@@ -101,6 +101,7 @@ struct node {
 
 	/* Cached `node_announcement` we might forward to new peers (or NULL). */
 	const u8 *node_announcement;
+	bool node_announcement_public;
 };
 
 const secp256k1_pubkey *node_map_keyof_node(const struct node *n);
@@ -175,6 +176,9 @@ struct routing_state {
 
         /* A map of channels indexed by short_channel_ids */
 	UINTMAP(struct chan *) chanmap;
+
+	/* Has one of our own channels been announced? */
+	bool local_channel_announced;
 };
 
 static inline struct chan *
@@ -217,12 +221,8 @@ u8 *handle_channel_announcement(struct routing_state *rstate,
 /**
  * handle_pending_cannouncement -- handle channel_announce once we've
  * completed short_channel_id lookup.
- *
- * Returns true if the channel was new and is local. This means that
- * if we haven't sent a node_announcement just yet, now would be a
- * good time.
  */
-bool handle_pending_cannouncement(struct routing_state *rstate,
+void handle_pending_cannouncement(struct routing_state *rstate,
 				  const struct short_channel_id *scid,
 				  const u64 satoshis,
 				  const u8 *txscript);
diff --git a/gossipd/test/run-bench-find_route.c b/gossipd/test/run-bench-find_route.c
index d98d9b01cd3f..28c66af2f828 100644
--- a/gossipd/test/run-bench-find_route.c
+++ b/gossipd/test/run-bench-find_route.c
@@ -93,7 +93,8 @@ u8 fromwire_u8(const u8 **cursor UNNEEDED, size_t *max UNNEEDED)
 bool fromwire_wireaddr(const u8 **cursor UNNEEDED, size_t *max UNNEEDED, struct wireaddr *addr UNNEEDED)
 { fprintf(stderr, "fromwire_wireaddr called!\n"); abort(); }
 /* Generated stub for insert_broadcast */
-void insert_broadcast(struct broadcast_state *bstate UNNEEDED, const u8 *msg UNNEEDED)
+void insert_broadcast(struct broadcast_state *bstate UNNEEDED, const u8 *msg UNNEEDED,
+		      u32 timestamp UNNEEDED)
 { fprintf(stderr, "insert_broadcast called!\n"); abort(); }
 /* Generated stub for onion_type_name */
 const char *onion_type_name(int e UNNEEDED)
diff --git a/gossipd/test/run-find_route-specific.c b/gossipd/test/run-find_route-specific.c
index 776684aaf555..ab97544b99fa 100644
--- a/gossipd/test/run-find_route-specific.c
+++ b/gossipd/test/run-find_route-specific.c
@@ -57,7 +57,8 @@ u8 fromwire_u8(const u8 **cursor UNNEEDED, size_t *max UNNEEDED)
 bool fromwire_wireaddr(const u8 **cursor UNNEEDED, size_t *max UNNEEDED, struct wireaddr *addr UNNEEDED)
 { fprintf(stderr, "fromwire_wireaddr called!\n"); abort(); }
 /* Generated stub for insert_broadcast */
-void insert_broadcast(struct broadcast_state *bstate UNNEEDED, const u8 *msg UNNEEDED)
+void insert_broadcast(struct broadcast_state *bstate UNNEEDED, const u8 *msg UNNEEDED,
+		      u32 timestamp UNNEEDED)
 { fprintf(stderr, "insert_broadcast called!\n"); abort(); }
 /* Generated stub for onion_type_name */
 const char *onion_type_name(int e UNNEEDED)
diff --git a/gossipd/test/run-find_route.c b/gossipd/test/run-find_route.c
index 45e488a7fc33..f34e44b083b3 100644
--- a/gossipd/test/run-find_route.c
+++ b/gossipd/test/run-find_route.c
@@ -55,7 +55,8 @@ u8 fromwire_u8(const u8 **cursor UNNEEDED, size_t *max UNNEEDED)
 bool fromwire_wireaddr(const u8 **cursor UNNEEDED, size_t *max UNNEEDED, struct wireaddr *addr UNNEEDED)
 { fprintf(stderr, "fromwire_wireaddr called!\n"); abort(); }
 /* Generated stub for insert_broadcast */
-void insert_broadcast(struct broadcast_state *bstate UNNEEDED, const u8 *msg UNNEEDED)
+void insert_broadcast(struct broadcast_state *bstate UNNEEDED, const u8 *msg UNNEEDED,
+		      u32 timestamp UNNEEDED)
 { fprintf(stderr, "insert_broadcast called!\n"); abort(); }
 /* Generated stub for onion_type_name */
 const char *onion_type_name(int e UNNEEDED)
diff --git a/lightningd/gossip_control.c b/lightningd/gossip_control.c
index 39e553bd4d44..0e20dac1bbb3 100644
--- a/lightningd/gossip_control.c
+++ b/lightningd/gossip_control.c
@@ -136,6 +136,10 @@ static unsigned gossip_msg(struct subd *gossip, const u8 *msg, const int *fds)
 	case WIRE_GOSSIP_OUTPOINT_SPENT:
 	case WIRE_GOSSIP_ROUTING_FAILURE:
 	case WIRE_GOSSIP_MARK_CHANNEL_UNROUTABLE:
+	case WIRE_GOSSIP_QUERY_SCIDS:
+	case WIRE_GOSSIP_QUERY_CHANNEL_RANGE:
+	case WIRE_GOSSIP_SEND_TIMESTAMP_FILTER:
+	case WIRE_GOSSIP_DEV_SET_MAX_SCIDS_ENCODE_SIZE:
 	case WIRE_GOSSIPCTL_PEER_DISCONNECT:
 	case WIRE_GOSSIPCTL_PEER_IMPORTANT:
 	case WIRE_GOSSIPCTL_PEER_DISCONNECTED:
@@ -147,6 +151,8 @@ static unsigned gossip_msg(struct subd *gossip, const u8 *msg, const int *fds)
 	case WIRE_GOSSIP_GETCHANNELS_REPLY:
 	case WIRE_GOSSIP_GETPEERS_REPLY:
 	case WIRE_GOSSIP_PING_REPLY:
+	case WIRE_GOSSIP_SCIDS_REPLY:
+	case WIRE_GOSSIP_QUERY_CHANNEL_RANGE_REPLY:
 	case WIRE_GOSSIP_RESOLVE_CHANNEL_REPLY:
 	case WIRE_GOSSIPCTL_RELEASE_PEER_REPLY:
 	case WIRE_GOSSIPCTL_RELEASE_PEER_REPLYFAIL:
@@ -543,3 +549,252 @@ static const struct json_command listchannels_command = {
 	"Show channel {short_channel_id} (or all known channels, if no {short_channel_id})"
 };
 AUTODATA(json_command, &listchannels_command);
+
+#if DEVELOPER
+static void json_scids_reply(struct subd *gossip UNUSED, const u8 *reply,
+			     const int *fds UNUSED, struct command *cmd)
+{
+	bool ok, complete;
+	struct json_result *response = new_json_result(cmd);
+
+	if (!fromwire_gossip_scids_reply(reply, &ok, &complete)) {
+		command_fail(cmd, LIGHTNINGD,
+			     "Gossip gave bad gossip_scids_reply");
+		return;
+	}
+
+	if (!ok) {
+		command_fail(cmd, LIGHTNINGD,
+			     "Gossip refused to query peer");
+		return;
+	}
+
+	json_object_start(response, NULL);
+	json_add_bool(response, "complete", complete);
+	json_object_end(response);
+	command_success(cmd, response);
+}
+
+static void json_dev_query_scids(struct command *cmd,
+				 const char *buffer, const jsmntok_t *params)
+{
+	u8 *msg;
+	jsmntok_t *idtok, *scidstok;
+	const jsmntok_t *t, *end;
+	struct pubkey id;
+	struct short_channel_id *scids;
+	size_t i;
+
+	if (!json_get_params(cmd, buffer, params,
+			     "id", &idtok,
+			     "scids", &scidstok,
+			     NULL)) {
+		return;
+	}
+
+	if (!json_tok_pubkey(buffer, idtok, &id)) {
+		command_fail(cmd, JSONRPC2_INVALID_PARAMS,
+			     "'%.*s' is not a valid id",
+			     idtok->end - idtok->start,
+			     buffer + idtok->start);
+		return;
+	}
+
+	if (scidstok->type != JSMN_ARRAY) {
+		command_fail(cmd, JSONRPC2_INVALID_PARAMS,
+			     "'%.*s' is not an array",
+			     scidstok->end - scidstok->start,
+			     buffer + scidstok->start);
+		return;
+	}
+
+	scids = tal_arr(cmd, struct short_channel_id, scidstok->size);
+	end = json_next(scidstok);
+	for (i = 0, t = scidstok + 1; t < end; t = json_next(t), i++) {
+		if (!json_tok_short_channel_id(buffer, t, &scids[i])) {
+			command_fail(cmd, JSONRPC2_INVALID_PARAMS,
+				     "scid %zu '%.*s' is not an scid",
+				     i, t->end - t->start,
+				     buffer + t->start);
+			return;
+		}
+	}
+
+	/* Tell gossipd, since this is a gossip query. */
+	msg = towire_gossip_query_scids(cmd, &id, scids);
+	subd_req(cmd->ld->gossip, cmd->ld->gossip,
+		 take(msg), -1, 0, json_scids_reply, cmd);
+	command_still_pending(cmd);
+}
+
+static const struct json_command dev_query_scids_command = {
+	"dev-query-scids",
+	json_dev_query_scids,
+	"Query {peerid} for [scids]"
+};
+AUTODATA(json_command, &dev_query_scids_command);
+
+static void json_dev_send_timestamp_filter(struct command *cmd,
+					   const char *buffer,
+					   const jsmntok_t *params)
+{
+	u8 *msg;
+	jsmntok_t *idtok, *firsttok, *rangetok;
+	struct pubkey id;
+	u32 first, range;
+
+	if (!json_get_params(cmd, buffer, params,
+			     "id", &idtok,
+			     "first", &firsttok,
+			     "range", &rangetok,
+			     NULL)) {
+		return;
+	}
+
+	if (!json_tok_pubkey(buffer, idtok, &id)) {
+		command_fail(cmd, JSONRPC2_INVALID_PARAMS,
+			     "'%.*s' is not a valid id",
+			     idtok->end - idtok->start,
+			     buffer + idtok->start);
+		return;
+	}
+
+	if (!json_tok_number(buffer, firsttok, &first)
+	    || !json_tok_number(buffer, rangetok, &range)) {
+		command_fail(cmd, JSONRPC2_INVALID_PARAMS,
+			     "bad first or range numbers");
+		return;
+	}
+
+	log_debug(cmd->ld->log, "Setting timestamp range %u+%u", first, range);
+	/* Tell gossipd, since this is a gossip query. */
+	msg = towire_gossip_send_timestamp_filter(NULL, &id, first, range);
+	subd_send_msg(cmd->ld->gossip, take(msg));
+
+	command_success(cmd, null_response(cmd));
+}
+
+static const struct json_command dev_send_timestamp_filter = {
+	"dev-send-timestamp-filter",
+	json_dev_send_timestamp_filter,
+	"Send {peerid} the timestamp filter {first} {range}"
+};
+AUTODATA(json_command, &dev_send_timestamp_filter);
+
+static void json_channel_range_reply(struct subd *gossip UNUSED, const u8 *reply,
+				     const int *fds UNUSED, struct command *cmd)
+{
+	struct json_result *response = new_json_result(cmd);
+	u32 final_first_block, final_num_blocks;
+	bool final_complete;
+	struct short_channel_id *scids;
+
+	if (!fromwire_gossip_query_channel_range_reply(tmpctx, reply,
+						       &final_first_block,
+						       &final_num_blocks,
+						       &final_complete,
+						       &scids)) {
+		command_fail(cmd, LIGHTNINGD,
+			     "Gossip gave bad gossip_query_channel_range_reply");
+		return;
+	}
+
+	if (final_num_blocks == 0 && final_num_blocks == 0 && !final_complete) {
+		command_fail(cmd, LIGHTNINGD,
+			     "Gossip refused to query peer");
+		return;
+	}
+
+	json_object_start(response, NULL);
+	/* As this is a dev interface, we don't bother saving and
+	 * returning all the replies, just the final one. */
+	json_add_num(response, "final_first_block", final_first_block);
+	json_add_num(response, "final_num_blocks", final_num_blocks);
+	json_add_bool(response, "final_complete", final_complete);
+	json_array_start(response, "short_channel_ids");
+	for (size_t i = 0; i < tal_count(scids); i++)
+		json_add_short_channel_id(response, NULL, &scids[i]);
+	json_array_end(response);
+	json_object_end(response);
+	command_success(cmd, response);
+}
+
+static void json_dev_query_channel_range(struct command *cmd,
+					 const char *buffer,
+					 const jsmntok_t *params)
+{
+	u8 *msg;
+	jsmntok_t *idtok, *firsttok, *numtok;
+	struct pubkey id;
+	u32 first, num;
+
+	if (!json_get_params(cmd, buffer, params,
+			     "id", &idtok,
+			     "first", &firsttok,
+			     "num", &numtok,
+			     NULL)) {
+		return;
+	}
+
+	if (!json_tok_pubkey(buffer, idtok, &id)) {
+		command_fail(cmd, JSONRPC2_INVALID_PARAMS,
+			     "'%.*s' is not a valid id",
+			     idtok->end - idtok->start,
+			     buffer + idtok->start);
+		return;
+	}
+
+	if (!json_tok_number(buffer, firsttok, &first)
+	    || !json_tok_number(buffer, numtok, &num)) {
+		command_fail(cmd, JSONRPC2_INVALID_PARAMS,
+			     "first and num must be numbers");
+		return;
+	}
+
+	/* Tell gossipd, since this is a gossip query. */
+	msg = towire_gossip_query_channel_range(cmd, &id, first, num);
+	subd_req(cmd->ld->gossip, cmd->ld->gossip,
+		 take(msg), -1, 0, json_channel_range_reply, cmd);
+	command_still_pending(cmd);
+}
+
+static const struct json_command dev_query_channel_range_command = {
+	"dev-query-channel-range",
+	json_dev_query_channel_range,
+	"Query {peerid} for short_channel_ids for {first} block + {num} blocks"
+};
+AUTODATA(json_command, &dev_query_channel_range_command);
+
+static void json_dev_set_max_scids_encode_size(struct command *cmd,
+					       const char *buffer,
+					       const jsmntok_t *params)
+{
+	u8 *msg;
+	jsmntok_t *maxtok;
+	u32 max;
+
+	if (!json_get_params(cmd, buffer, params,
+			     "max", &maxtok,
+			     NULL)) {
+		return;
+	}
+
+	if (!json_tok_number(buffer, maxtok, &max)) {
+		command_fail(cmd, JSONRPC2_INVALID_PARAMS,
+			     "max must be a number");
+		return;
+	}
+
+	msg = towire_gossip_dev_set_max_scids_encode_size(NULL, max);
+	subd_send_msg(cmd->ld->gossip, take(msg));
+
+	command_success(cmd, null_response(cmd));
+}
+
+static const struct json_command dev_set_max_scids_encode_size = {
+	"dev-set-max-scids-encode-size",
+	json_dev_set_max_scids_encode_size,
+	"Set {max} bytes of short_channel_ids per reply_channel_range"
+};
+AUTODATA(json_command, &dev_set_max_scids_encode_size);
+#endif /* DEVELOPER */
diff --git a/tests/fixtures.py b/tests/fixtures.py
index 992506f95384..992ffe2f0774 100644
--- a/tests/fixtures.py
+++ b/tests/fixtures.py
@@ -9,12 +9,14 @@
 import utils
 
 
+with open('config.vars') as configfile:
+    config = dict([(line.rstrip().split('=', 1)) for line in configfile])
+
 TEST_DIR = tempfile.mkdtemp(prefix='ltests-')
-VALGRIND = os.getenv("NO_VALGRIND", "0") == "0"
-DEVELOPER = os.getenv("DEVELOPER", "0") == "1"
+VALGRIND = os.getenv("VALGRIND", config['VALGRIND']) == "0"
+DEVELOPER = os.getenv("DEVELOPER", config['DEVELOPER']) == "1"
 TEST_DEBUG = os.getenv("TEST_DEBUG", "0") == "1"
 
-
 # A dict in which we count how often a particular test has run so far. Used to
 # give each attempt its own numbered directory, and avoid clashes.
 __attempts = {}
diff --git a/tests/test_lightningd.py b/tests/test_lightningd.py
index e9376be8aaf1..29c87da48b60 100644
--- a/tests/test_lightningd.py
+++ b/tests/test_lightningd.py
@@ -26,10 +26,13 @@
 import utils
 from lightning import LightningRpc
 
+with open('config.vars') as configfile:
+    config = dict([(line.rstrip().split('=', 1)) for line in configfile])
+
 bitcoind = None
 TEST_DIR = tempfile.mkdtemp(prefix='lightning-')
-VALGRIND = os.getenv("NO_VALGRIND", "0") == "0"
-DEVELOPER = os.getenv("DEVELOPER", "0") == "1"
+VALGRIND = os.getenv("VALGRIND", config['VALGRIND']) == "1"
+DEVELOPER = os.getenv("DEVELOPER", config['DEVELOPER']) == "1"
 TEST_DEBUG = os.getenv("TEST_DEBUG", "0") == "1"
 
 print("Testing results are in {}".format(TEST_DIR))
@@ -2455,16 +2458,14 @@ def test_gossip_jsonrpc(self):
         assert n2['nodeid'] == l2.info['id']
 
         # Might not have seen other node-announce yet.
-        # TODO(cdecker) Can't check these without DEVELOPER=1, re-enable after we get alias and color into getinfo
-        if DEVELOPER:
-            assert n1['alias'].startswith('JUNIORBEAM')
-            assert n1['color'] == '0266e4'
-            if 'alias' not in n2:
-                assert 'color' not in n2
-                assert 'addresses' not in n2
-            else:
-                assert n2['alias'].startswith('SILENTARTIST')
-                assert n2['color'] == '022d22'
+        assert n1['alias'].startswith('JUNIORBEAM')
+        assert n1['color'] == '0266e4'
+        if 'alias' not in n2:
+            assert 'color' not in n2
+            assert 'addresses' not in n2
+        else:
+            assert n2['alias'].startswith('SILENTARTIST')
+            assert n2['color'] == '022d22'
 
         assert [c['active'] for c in l1.rpc.listchannels()['channels']] == [True, True]
         assert [c['public'] for c in l1.rpc.listchannels()['channels']] == [True, True]
@@ -2622,6 +2623,290 @@ def test_ping(self):
             l1.daemon.wait_for_log('Got pong 1000 bytes \({}\.\.\.\)'
                                    .format(l2.info['version']))
 
+    @unittest.skipIf(not DEVELOPER, "needs DEVELOPER=1")
+    def test_gossip_query_channel_range(self):
+        l1 = self.node_factory.get_node(options={'log-level': 'io'})
+        l2 = self.node_factory.get_node()
+        l3 = self.node_factory.get_node()
+        l4 = self.node_factory.get_node()
+
+        l1.rpc.connect(l2.info['id'], 'localhost', l2.port)
+        l2.rpc.connect(l3.info['id'], 'localhost', l3.port)
+        l3.rpc.connect(l4.info['id'], 'localhost', l4.port)
+
+        # Make public channels.
+        scid12 = self.fund_channel(l1, l2, 10**5)
+        block12 = int(scid12.split(':')[0])
+        scid23 = self.fund_channel(l2, l3, 10**5)
+        block23 = int(scid23.split(':')[0])
+        bitcoind.generate_block(5)
+        sync_blockheight([l2, l3])
+
+        # Make sure l2 has received all the gossip.
+        l2.daemon.wait_for_logs(['Received node_announcement for node ' + l1.info['id'],
+                                 'Received node_announcement for node ' + l3.info['id']])
+
+        # l1 asks for all channels, gets both.
+        ret = l1.rpc.dev_query_channel_range(id=l2.info['id'],
+                                             first=0,
+                                             num=1000000)
+
+        assert ret['final_first_block'] == 0
+        assert ret['final_num_blocks'] == 1000000
+        assert ret['final_complete']
+        assert len(ret['short_channel_ids']) == 2
+        assert ret['short_channel_ids'][0] == scid12
+        assert ret['short_channel_ids'][1] == scid23
+
+        # Does not include scid12
+        ret = l1.rpc.dev_query_channel_range(id=l2.info['id'],
+                                             first=0,
+                                             num=block12)
+        assert ret['final_first_block'] == 0
+        assert ret['final_num_blocks'] == block12
+        assert ret['final_complete']
+        assert len(ret['short_channel_ids']) == 0
+
+        # Does include scid12
+        ret = l1.rpc.dev_query_channel_range(id=l2.info['id'],
+                                             first=0,
+                                             num=block12 + 1)
+        assert ret['final_first_block'] == 0
+        assert ret['final_num_blocks'] == block12 + 1
+        assert ret['final_complete']
+        assert len(ret['short_channel_ids']) == 1
+        assert ret['short_channel_ids'][0] == scid12
+
+        # Doesn't include scid23
+        ret = l1.rpc.dev_query_channel_range(id=l2.info['id'],
+                                             first=0,
+                                             num=block23)
+        assert ret['final_first_block'] == 0
+        assert ret['final_num_blocks'] == block23
+        assert ret['final_complete']
+        assert len(ret['short_channel_ids']) == 1
+        assert ret['short_channel_ids'][0] == scid12
+
+        # Does include scid23
+        ret = l1.rpc.dev_query_channel_range(id=l2.info['id'],
+                                             first=block12,
+                                             num=block23 - block12 + 1)
+        assert ret['final_first_block'] == block12
+        assert ret['final_num_blocks'] == block23 - block12 + 1
+        assert ret['final_complete']
+        assert len(ret['short_channel_ids']) == 2
+        assert ret['short_channel_ids'][0] == scid12
+        assert ret['short_channel_ids'][1] == scid23
+
+        # Only includes scid23
+        ret = l1.rpc.dev_query_channel_range(id=l2.info['id'],
+                                             first=block23,
+                                             num=1)
+        assert ret['final_first_block'] == block23
+        assert ret['final_num_blocks'] == 1
+        assert ret['final_complete']
+        assert len(ret['short_channel_ids']) == 1
+        assert ret['short_channel_ids'][0] == scid23
+
+        # Past both
+        ret = l1.rpc.dev_query_channel_range(id=l2.info['id'],
+                                             first=block23 + 1,
+                                             num=1000000)
+        assert ret['final_first_block'] == block23 + 1
+        assert ret['final_num_blocks'] == 1000000
+        assert ret['final_complete']
+        assert len(ret['short_channel_ids']) == 0
+
+        # Make l2 split reply into two.
+        l2.rpc.dev_set_max_scids_encode_size(max=9)
+        ret = l1.rpc.dev_query_channel_range(id=l2.info['id'],
+                                             first=0,
+                                             num=1000000)
+
+        # It should definitely have split
+        assert ret['final_first_block'] != 0 or ret['final_num_blocks'] != 1000000
+        assert ret['final_complete']
+        assert len(ret['short_channel_ids']) == 2
+        assert ret['short_channel_ids'][0] == scid12
+        assert ret['short_channel_ids'][1] == scid23
+        l2.daemon.wait_for_log('queue_channel_ranges full: splitting')
+
+        # This should actually be large enough for zlib to kick in!
+        self.fund_channel(l3, l4, 10**5)
+        bitcoind.generate_block(5)
+        l2.daemon.wait_for_log('Received node_announcement for node ' + l4.info['id'])
+
+        # Turn on IO logging in l1 channeld.
+        subprocess.run(['kill', '-USR1', l1.subd_pid('channeld')])
+
+        # Restore infinite encode size.
+        l2.rpc.dev_set_max_scids_encode_size(max=(2**32 - 1))
+        ret = l1.rpc.dev_query_channel_range(id=l2.info['id'],
+                                             first=0,
+                                             num=65535)
+        l1.daemon.wait_for_log(
+            # WIRE_REPLY_CHANNEL_RANGE
+            '\[IN\] 0108' +
+            # chain_hash
+            '................................................................' +
+            # first_blocknum
+            '00000000' +
+            # number_of_blocks
+            '0000ffff' +
+            # complete
+            '01' +
+            # length
+            '....' +
+            # encoding
+            '01'
+        )
+
+    @unittest.skipIf(not DEVELOPER, "needs DEVELOPER=1")
+    def test_query_short_channel_id(self):
+        l1 = self.node_factory.get_node(options={'log-level': 'io'})
+        l2 = self.node_factory.get_node()
+        l3 = self.node_factory.get_node()
+        l1.rpc.connect(l2.info['id'], 'localhost', l2.port)
+        l2.rpc.connect(l3.info['id'], 'localhost', l3.port)
+
+        # Need full IO logging so we can see gossip (from gossipd and channeld)
+        subprocess.run(['kill', '-USR1', l1.subd_pid('gossipd')])
+
+        # Empty result tests.
+        reply = l1.rpc.dev_query_scids(l2.info['id'], ['1:1:1', '2:2:2'])
+        # 0x0105 = query_short_channel_ids
+        l1.daemon.wait_for_log('\[OUT\] 0105.*0000000100000100010000020000020002')
+        assert reply['complete']
+
+        # Make channels public.
+        scid12 = self.fund_channel(l1, l2, 10**5)
+        scid23 = self.fund_channel(l2, l3, 10**5)
+        bitcoind.generate_block(5)
+        sync_blockheight([l1, l2, l3])
+
+        # It will know about everything.
+        l1.daemon.wait_for_log('Received node_announcement for node {}'.format(l3.info['id']))
+        subprocess.run(['kill', '-USR1', l1.subd_pid('channeld')])
+
+        # This query should get channel announcements, channel updates, and node announcements.
+        reply = l1.rpc.dev_query_scids(l2.info['id'], [scid23])
+        # 0x0105 = query_short_channel_ids
+        l1.daemon.wait_for_log('\[OUT\] 0105')
+        assert reply['complete']
+
+        # 0x0100 = channel_announcement
+        l1.daemon.wait_for_log('\[IN\] 0100')
+        # 0x0102 = channel_update
+        l1.daemon.wait_for_log('\[IN\] 0102')
+        l1.daemon.wait_for_log('\[IN\] 0102')
+        # 0x0101 = node_announcement
+        l1.daemon.wait_for_log('\[IN\] 0101')
+        l1.daemon.wait_for_log('\[IN\] 0101')
+
+        reply = l1.rpc.dev_query_scids(l2.info['id'], [scid12, scid23])
+        assert reply['complete']
+        # Technically, this order could be different, but this matches code.
+        # 0x0100 = channel_announcement
+        l1.daemon.wait_for_log('\[IN\] 0100')
+        # 0x0102 = channel_update
+        l1.daemon.wait_for_log('\[IN\] 0102')
+        l1.daemon.wait_for_log('\[IN\] 0102')
+        # 0x0100 = channel_announcement
+        l1.daemon.wait_for_log('\[IN\] 0100')
+        # 0x0102 = channel_update
+        l1.daemon.wait_for_log('\[IN\] 0102')
+        l1.daemon.wait_for_log('\[IN\] 0102')
+        # 0x0101 = node_announcement
+        l1.daemon.wait_for_log('\[IN\] 0101')
+        l1.daemon.wait_for_log('\[IN\] 0101')
+
+    @unittest.skipIf(not DEVELOPER, "needs DEVELOPER=1")
+    def test_gossip_timestamp_filter(self):
+        # Need full IO logging so we can see gossip (from gossipd and channeld)
+        l1 = self.node_factory.get_node(options={'log-level': 'io'})
+        l2 = self.node_factory.get_node()
+        l3 = self.node_factory.get_node()
+
+        # Full IO logging for gossipds
+        subprocess.run(['kill', '-USR1', l1.subd_pid('gossipd')])
+        subprocess.run(['kill', '-USR1', l2.subd_pid('gossipd')])
+
+        l1.rpc.connect(l2.info['id'], 'localhost', l2.port)
+        l2.rpc.connect(l3.info['id'], 'localhost', l3.port)
+
+        before_anything = int(time.time() - 1.0)
+
+        # Make a public channel.
+        chan12 = self.fund_channel(l1, l2, 10**5)
+        bitcoind.generate_block(5)
+        sync_blockheight([l1, l2])
+
+        self.wait_for_routes(l3, [chan12])
+        after_12 = int(time.time())
+        # Full IO logging for l1's channeld
+        subprocess.run(['kill', '-USR1', l1.subd_pid('channeld')])
+
+        # Make another one, different timestamp.
+        chan23 = self.fund_channel(l2, l3, 10**5)
+        bitcoind.generate_block(5)
+        sync_blockheight([l2, l3])
+
+        self.wait_for_routes(l1, [chan23])
+        after_23 = int(time.time())
+
+        # Make sure l1 has received all the gossip.
+        wait_for(lambda: ['alias' in node for node in l1.rpc.listnodes()['nodes']] == [True, True, True])
+
+        # l1 sets broad timestamp, will receive info about both channels again.
+        l1.rpc.dev_send_timestamp_filter(id=l2.info['id'],
+                                         first=0,
+                                         range=0xFFFFFFFF)
+        before_sendfilter = l1.daemon.logsearch_start
+
+        # 0x0100 = channel_announcement
+        # 0x0102 = channel_update
+        # 0x0101 = node_announcement
+        l1.daemon.wait_for_log('\[IN\] 0100')
+        # The order of node_announcements relative to others is undefined.
+        l1.daemon.wait_for_logs(['\[IN\] 0102',
+                                 '\[IN\] 0102',
+                                 '\[IN\] 0100',
+                                 '\[IN\] 0102',
+                                 '\[IN\] 0102',
+                                 '\[IN\] 0101',
+                                 '\[IN\] 0101',
+                                 '\[IN\] 0101'])
+
+        # Now timestamp which doesn't overlap (gives nothing).
+        before_sendfilter = l1.daemon.logsearch_start
+        l1.rpc.dev_send_timestamp_filter(id=l2.info['id'],
+                                         first=0,
+                                         range=before_anything)
+        time.sleep(1)
+        assert not l1.daemon.is_in_log('\[IN\] 0100', before_sendfilter)
+
+        # Now choose range which will only give first update.
+        l1.rpc.dev_send_timestamp_filter(id=l2.info['id'],
+                                         first=before_anything,
+                                         range=after_12 - before_anything + 1)
+        # 0x0100 = channel_announcement
+        l1.daemon.wait_for_log('\[IN\] 0100')
+        # 0x0102 = channel_update
+        # (Node announcement may have any timestamp)
+        l1.daemon.wait_for_log('\[IN\] 0102')
+        l1.daemon.wait_for_log('\[IN\] 0102')
+
+        # Now choose range which will only give second update.
+        l1.rpc.dev_send_timestamp_filter(id=l2.info['id'],
+                                         first=after_12,
+                                         range=after_23 - after_12 + 1)
+        # 0x0100 = channel_announcement
+        l1.daemon.wait_for_log('\[IN\] 0100')
+        # 0x0102 = channel_update
+        # (Node announcement may have any timestamp)
+        l1.daemon.wait_for_log('\[IN\] 0102')
+        l1.daemon.wait_for_log('\[IN\] 0102')
+
     @unittest.skipIf(not DEVELOPER, "needs DEVELOPER=1")
     def test_routing_gossip_reconnect(self):
         # Connect two peers, reconnect and then see if we resume the
@@ -2642,6 +2927,40 @@ def test_routing_gossip_reconnect(self):
         for n in [l1, l2, l3]:
             wait_for(lambda: len(n.rpc.listchannels()['channels']) == 4)
 
+    @unittest.skipIf(not DEVELOPER, "needs DEVELOPER=1")
+    def test_gossip_no_empty_announcements(self):
+        # Need full IO logging so we can see gossip
+        l1 = self.node_factory.get_node(options={'log-level': 'io'})
+        l2 = self.node_factory.get_node(options={'log-level': 'io',
+                                                 'dev-no-reconnect': None})
+        # l3 sends CHANNEL_ANNOUNCEMENT to l2, but not CHANNEL_UDPATE.
+        l3 = self.node_factory.get_node(disconnect=['+WIRE_CHANNEL_ANNOUNCEMENT'])
+        l4 = self.node_factory.get_node()
+
+        # Turn on IO logging for gossipds
+        subprocess.run(['kill', '-USR1', l1.subd_pid('gossipd')])
+        subprocess.run(['kill', '-USR1', l2.subd_pid('gossipd')])
+
+        l1.rpc.connect(l2.info['id'], 'localhost', l2.port)
+        l2.rpc.connect(l3.info['id'], 'localhost', l3.port)
+        l3.rpc.connect(l4.info['id'], 'localhost', l4.port)
+
+        # Make an announced-but-not-updated channel.
+        self.fund_channel(l3, l4, 10**5)
+        bitcoind.generate_block(5)
+        sync_blockheight([l3, l4])
+        # 0x0100 = channel_announcement, which goes to l2 before l3 dies.
+        l2.daemon.wait_for_log('\[IN\] 0100')
+
+        # But it never goes to l1, as there's no channel_update.
+        time.sleep(2)
+        assert not l1.daemon.is_in_log('\[IN\] 0100')
+        assert len(l1.rpc.listchannels()['channels']) == 0
+
+        # If we reconnect, gossip will now flow.
+        l3.rpc.connect(l2.info['id'], 'localhost', l2.port)
+        wait_for(lambda: len(l1.rpc.listchannels()['channels']) == 2)
+
     def test_second_channel(self):
         l1 = self.node_factory.get_node()
         l2 = self.node_factory.get_node()
@@ -4250,16 +4569,13 @@ def test_io_logging(self):
         # Fundchannel manually so we get channeld pid.
         self.give_funds(l1, 10**6 + 1000000)
         l1.rpc.fundchannel(l2.info['id'], 10**6)['tx']
-        # Get pid of channeld, eg 'lightning_channeld(...): pid 13933, msgfd 12'
-        pidline = l1.daemon.wait_for_log(r'lightning_channeld.*: pid [0-9]*,')
-        pid1 = re.search(r'pid ([0-9]*),', pidline).group(1)
+        pid1 = l1.subd_pid('channeld')
 
         l1.daemon.wait_for_log('sendrawtx exit 0')
         l1.bitcoin.generate_block(1)
         l1.daemon.wait_for_log(' to CHANNELD_NORMAL')
 
-        pidline = l2.daemon.wait_for_log(r'lightning_channeld.*: pid [0-9]*,')
-        pid2 = re.search(r'pid ([0-9]*),', pidline).group(1)
+        pid2 = l2.subd_pid('channeld')
         l2.daemon.wait_for_log(' to CHANNELD_NORMAL')
 
         # Send it sigusr1: should turn on logging.
diff --git a/tests/utils.py b/tests/utils.py
index f6ef25c6a3fc..3bafa0df3193 100644
--- a/tests/utils.py
+++ b/tests/utils.py
@@ -470,6 +470,16 @@ def fund_channel(self, l2, amount):
         decoded2 = self.bitcoin.rpc.decoderawtransaction(tx)
         raise ValueError("Can't find {} payment in {} (1={} 2={})".format(amount, tx, decoded, decoded2))
 
+    def subd_pid(self, subd):
+        """Get the process id of the given subdaemon, eg channeld or gossipd"""
+        ex = re.compile(r'lightning_{}.*: pid ([0-9]*),'.format(subd))
+        # Make sure we get latest one if it's restarted!
+        for l in reversed(self.daemon.logs):
+            group = ex.search(l)
+            if group:
+                return group.group(1)
+        raise ValueError("No daemon {} found".format(subd))
+
     def is_channel_active(self, chanid):
         channels = self.rpc.listchannels()['channels']
         active = [(c['short_channel_id'], c['flags']) for c in channels if c['active']]
diff --git a/tools/refresh-submodules.sh b/tools/refresh-submodules.sh
new file mode 100755
index 000000000000..9573672d6e02
--- /dev/null
+++ b/tools/refresh-submodules.sh
@@ -0,0 +1,30 @@
+#! /bin/sh
+
+if [ $# = 0 ]; then
+    echo "Usage: $0 <submoduledir1>..." >&2
+    exit 1
+fi
+
+# git submodule can't run in parallel.  Really.
+echo $$ > .refresh-submodules.$$
+if ! mv -n .refresh-submodules.$$ .refresh-submodules; then
+    rm -f .refresh-submodules.$$
+    exit 0
+fi
+trap "rm -f .refresh-submodules" EXIT
+
+# Be a little careful here, since we do rm -rf!
+for m in "$@"; do
+    if ! grep -q "path = $m\$" .gitmodules; then
+	echo "$m is not a submodule!" >&2
+	exit 1
+    fi
+done
+
+# git submodule can segfault.  Really.
+if [ $(git submodule status "$@" | grep -c '^ ') != $# ]; then
+    echo Reinitializing submodules "$@"...
+    git submodule sync "$@"
+    rm -rf "$@"
+    git submodule update --init "$@"
+fi
diff --git a/wire/gen_peer_wire_csv b/wire/gen_peer_wire_csv
index 4ac2c04ae974..5c6e81450a2e 100644
--- a/wire/gen_peer_wire_csv
+++ b/wire/gen_peer_wire_csv
@@ -146,3 +146,25 @@ channel_update,110,cltv_expiry_delta,2
 channel_update,112,htlc_minimum_msat,8
 channel_update,120,fee_base_msat,4
 channel_update,124,fee_proportional_millionths,4
+query_short_channel_ids,261
+query_short_channel_ids,0,chain_hash,32
+query_short_channel_ids,32,len,2
+query_short_channel_ids,34,encoded_short_ids,len
+reply_short_channel_ids_end,262
+reply_short_channel_ids_end,0,chain_hash,32
+reply_short_channel_ids_end,32,complete,1
+query_channel_range,263
+query_channel_range,0,chain_hash,32
+query_channel_range,32,first_blocknum,4
+query_channel_range,36,number_of_blocks,4
+reply_channel_range,264
+reply_channel_range,0,chain_hash,32
+reply_channel_range,32,first_blocknum,4
+reply_channel_range,36,number_of_blocks,4
+reply_channel_range,40,complete,1
+reply_channel_range,41,len,2
+reply_channel_range,43,encoded_short_ids,len
+gossip_timestamp_filter,265
+gossip_timestamp_filter,0,chain_hash,32
+gossip_timestamp_filter,32,first_timestamp,4
+gossip_timestamp_filter,36,timestamp_range,4
diff --git a/wire/peer_wire.c b/wire/peer_wire.c
index de8218c035f9..777b85dc685c 100644
--- a/wire/peer_wire.c
+++ b/wire/peer_wire.c
@@ -26,6 +26,11 @@ static bool unknown_type(enum wire_type t)
 	case WIRE_CHANNEL_UPDATE:
 	case WIRE_PING:
 	case WIRE_PONG:
+	case WIRE_QUERY_SHORT_CHANNEL_IDS:
+	case WIRE_REPLY_SHORT_CHANNEL_IDS_END:
+	case WIRE_QUERY_CHANNEL_RANGE:
+	case WIRE_REPLY_CHANNEL_RANGE:
+	case WIRE_GOSSIP_TIMESTAMP_FILTER:
 		return false;
 	}
 	return true;
@@ -37,6 +42,11 @@ bool is_msg_for_gossipd(const u8 *cursor)
 	case WIRE_CHANNEL_ANNOUNCEMENT:
 	case WIRE_NODE_ANNOUNCEMENT:
 	case WIRE_CHANNEL_UPDATE:
+	case WIRE_QUERY_SHORT_CHANNEL_IDS:
+	case WIRE_REPLY_SHORT_CHANNEL_IDS_END:
+	case WIRE_QUERY_CHANNEL_RANGE:
+	case WIRE_REPLY_CHANNEL_RANGE:
+	case WIRE_GOSSIP_TIMESTAMP_FILTER:
 		return true;
 	case WIRE_INIT:
 	case WIRE_ERROR: