rustyrussell · Aug 27, 2014 · Aug 29, 2014 · Aug 29, 2014 · Aug 29, 2014 · Aug 29, 2014
diff --git a/block.c b/block.c
@@ -31,7 +31,7 @@ static void destroy_block(struct block *b)
 /* This allocates the block but doesn't sew it into data structures. */
 static struct block *new_block(const tal_t *ctx,
 			       BIGNUM *prev_work,
-			       const struct protocol_double_sha *sha,
+			       const struct protocol_block_id *sha,
 			       const struct protocol_block_header *hdr,
 			       const u8 *shard_nums,
 			       const struct protocol_double_sha *merkles,
@@ -64,22 +64,9 @@ static struct block *new_block(const tal_t *ctx,
 	return block;
 }
 
-struct block *block_find(struct block *start, const u8 lower_sha[4])
-{
-	struct block *b = start;
-
-	while (b) {
-		if (memcmp(b->sha.sha, lower_sha, 4) == 0)
-			break;
-
-		b = b->prev;
-	}
-	return b;
-}
-
 struct block *block_add(struct state *state,
 			struct block *prev,
-			const struct protocol_double_sha *sha,
+			const struct protocol_block_id *sha,
 			const struct protocol_block_header *hdr,
 			const u8 *shard_nums,
 			const struct protocol_double_sha *merkles,
@@ -90,7 +77,7 @@ struct block *block_add(struct state *state,
 	struct block *block;
 
 	log_debug(state->log, "Adding block %u ", height);
-	log_add_struct(state->log, struct protocol_double_sha, sha);
+	log_add_struct(state->log, struct protocol_block_id, sha);
 
 	block = new_block(state, &prev->total_work, sha, hdr, shard_nums,
 			  merkles, prev_txhashes, tailer);
@@ -143,7 +130,7 @@ struct block *block_add(struct state *state,
 
 /* FIXME: use hash table. */
 struct block *block_find_any(struct state *state,
-			     const struct protocol_double_sha *sha)
+			     const struct protocol_block_id *sha)
 {
 	int i, n = tal_count(state->block_height);
 	struct block *b;

diff --git a/block.h b/block.h
@@ -44,18 +44,16 @@ struct block {
 	const void *complaint;
 
 	/* Cache double SHA of block */
-	struct protocol_double_sha sha;
+	struct protocol_block_id sha;
 	/* Transactions: may not be fully populated. */
 	struct block_shard **shard;
 };
 
-/* Find on this chain. */
 struct state;
-struct block *block_find(struct block *start, const u8 lower_sha[4]);
 
 /* Find anywhere. */
 struct block *block_find_any(struct state *state,
-			     const struct protocol_double_sha *sha);
+			     const struct protocol_block_id *sha);
 
 /* Do we have every tx in this block? */
 bool block_all_known(const struct block *block);
@@ -71,7 +69,7 @@ static inline const struct block *genesis_block(const struct state *state)
 /* Create a new block and add into the state structure. */
 struct block *block_add(struct state *state,
 			struct block *prev,
-			const struct protocol_double_sha *sha,
+			const struct protocol_block_id *sha,
 			const struct protocol_block_header *hdr,
 			const u8 *shard_nums,
 			const struct protocol_double_sha *merkles,

diff --git a/blockfile.c b/blockfile.c
@@ -29,7 +29,7 @@ static bool load_block(struct state *state, struct protocol_net_hdr *pkt)
 	const u8 *prev_txhashes;
 	const struct protocol_block_tailer *tailer;
 	const struct protocol_block_header *hdr;
-	struct protocol_double_sha sha;
+	struct protocol_block_id sha;
 
 	e = unmarshal_block(state->log, (void *)pkt,
 			    &hdr, &shard_nums, &merkles, &prev_txhashes,
@@ -38,7 +38,7 @@ static bool load_block(struct state *state, struct protocol_net_hdr *pkt)
 		return false;
 
 	e = check_block_header(state, hdr, shard_nums, merkles, prev_txhashes,
-			       tailer, &prev, &sha);
+			       tailer, &prev, &sha.sha);
 	if (e != PROTOCOL_ECODE_NONE)
 		return false;
 

diff --git a/ccan/README b/ccan/README
@@ -1,3 +1,3 @@
 CCAN imported from http://ccodearchive.net.
 
-CCAN version: init-1901-g8976261
+CCAN version: init-1909-gf3c9280
diff --git a/ccan/ccan/endian/endian.h b/ccan/ccan/endian/endian.h
@@ -16,8 +16,8 @@
  *	};
  */
 #define BSWAP_16(val)				\
-	((((uint16_t)val & 0x00ff) << 8)	\
-	 | (((uint16_t)val & 0xff00) >> 8))
+	((((uint16_t)(val) & 0x00ff) << 8)	\
+	 | (((uint16_t)(val) & 0xff00) >> 8))
 
 /**
  * BSWAP_32 - reverse bytes in a constant uint32_t value.
@@ -31,10 +31,10 @@
  *	};
  */
 #define BSWAP_32(val)					\
-	((((uint32_t)val & 0x000000ff) << 24)		\
-	 | (((uint32_t)val & 0x0000ff00) << 8)		\
-	 | (((uint32_t)val & 0x00ff0000) >> 8)		\
-	 | (((uint32_t)val & 0xff000000) >> 24))
+	((((uint32_t)(val) & 0x000000ff) << 24)		\
+	 | (((uint32_t)(val) & 0x0000ff00) << 8)		\
+	 | (((uint32_t)(val) & 0x00ff0000) >> 8)		\
+	 | (((uint32_t)(val) & 0xff000000) >> 24))
 
 /**
  * BSWAP_64 - reverse bytes in a constant uint64_t value.
@@ -48,14 +48,14 @@
  *	};
  */
 #define BSWAP_64(val)						\
-	((((uint64_t)val & 0x00000000000000ffULL) << 56)	\
-	 | (((uint64_t)val & 0x000000000000ff00ULL) << 40)	\
-	 | (((uint64_t)val & 0x0000000000ff0000ULL) << 24)	\
-	 | (((uint64_t)val & 0x00000000ff000000ULL) << 8)	\
-	 | (((uint64_t)val & 0x000000ff00000000ULL) >> 8)	\
-	 | (((uint64_t)val & 0x0000ff0000000000ULL) >> 24)	\
-	 | (((uint64_t)val & 0x00ff000000000000ULL) >> 40)	\
-	 | (((uint64_t)val & 0xff00000000000000ULL) >> 56))
+	((((uint64_t)(val) & 0x00000000000000ffULL) << 56)	\
+	 | (((uint64_t)(val) & 0x000000000000ff00ULL) << 40)	\
+	 | (((uint64_t)(val) & 0x0000000000ff0000ULL) << 24)	\
+	 | (((uint64_t)(val) & 0x00000000ff000000ULL) << 8)	\
+	 | (((uint64_t)(val) & 0x000000ff00000000ULL) >> 8)	\
+	 | (((uint64_t)(val) & 0x0000ff0000000000ULL) >> 24)	\
+	 | (((uint64_t)(val) & 0x00ff000000000000ULL) >> 40)	\
+	 | (((uint64_t)(val) & 0xff00000000000000ULL) >> 56))
 
 #if HAVE_BYTESWAP_H
 #include <byteswap.h>

diff --git a/ccan/ccan/io/backend.h b/ccan/ccan/io/backend.h
@@ -4,6 +4,7 @@
 #include <stdbool.h>
 #include <poll.h>
 #include "io_plan.h"
+#include <ccan/list/list.h>
 
 struct fd {
 	int fd;
@@ -62,8 +63,8 @@ struct io_conn {
 	/* For duplex to save. */
 	bool debug_saved;
 
-	/* always or closing list. */
-	struct io_conn *list;
+	/* always and closing lists. */
+	struct list_node always, closing;
 
 	void (*finish)(struct io_conn *, void *arg);
 	void *finish_arg;

diff --git a/ccan/ccan/io/io.c b/ccan/ccan/io/io.c
@@ -92,7 +92,8 @@ struct io_conn *io_new_conn_(const tal_t *ctx, int fd,
 	conn->fd.fd = fd;
 	conn->finish = NULL;
 	conn->finish_arg = NULL;
-	conn->list = NULL;
+	list_node_init(&conn->always);
+	list_node_init(&conn->closing);
 	conn->debug = false;
 
 	if (!add_conn(conn))

diff --git a/ccan/ccan/io/poll.c b/ccan/ccan/io/poll.c
@@ -8,14 +8,14 @@
 #include <sys/socket.h>
 #include <limits.h>
 #include <errno.h>
-#include <ccan/list/list.h>
 #include <ccan/time/time.h>
 #include <ccan/timer/timer.h>
 
 static size_t num_fds = 0, max_fds = 0, num_waiting = 0;
 static struct pollfd *pollfds = NULL;
 static struct fd **fds = NULL;
-static struct io_conn *closing = NULL, *always = NULL;
+static LIST_HEAD(closing);
+static LIST_HEAD(always);
 
 static bool add_fd(struct fd *fd, short events)
 {
@@ -96,31 +96,21 @@ bool add_listener(struct io_listener *l)
 
 void remove_from_always(struct io_conn *conn)
 {
-	struct io_conn **p = &always;
-
-	while (*p != conn)
-		p = &(*p)->list;
-
-	*p = conn->list;
+	list_del_init(&conn->always);
 }
 
 void backend_new_closing(struct io_conn *conn)
 {
-	/* Already on always list?  Remove it. */
-	if (conn->list)
-		remove_from_always(conn);
-
-	conn->list = closing;
-	closing = conn;
+	/* In case it's on always list, remove it. */
+	list_del_init(&conn->always);
+	list_add_tail(&closing, &conn->closing);
 }
 
 void backend_new_always(struct io_conn *conn)
 {
-	/* May already be in always list (other plan), or closing. */
-	if (!conn->list) {
-		conn->list = always;
-		always = conn;
-	}
+	/* In case it's already in always list. */
+	list_del(&conn->always);
+	list_add_tail(&always, &conn->always);
 }
 
 void backend_new_plan(struct io_conn *conn)
@@ -202,14 +192,12 @@ static void accept_conn(struct io_listener *l)
 static bool close_conns(void)
 {
 	bool ret = false;
+	struct io_conn *conn;
 
-	while (closing) {
-		struct io_conn *conn = closing;
-
+	while ((conn = list_pop(&closing, struct io_conn, closing)) != NULL) {
 		assert(conn->plan[IO_IN].status == IO_CLOSING);
 		assert(conn->plan[IO_OUT].status == IO_CLOSING);
 
-		closing = closing->list;
 		del_conn(conn);
 		ret = true;
 	}
@@ -219,16 +207,14 @@ static bool close_conns(void)
 static bool handle_always(void)
 {
 	bool ret = false;
+	struct io_conn *conn;
 
-	while (always) {
-		struct io_conn *conn = always;
-
+	while ((conn = list_pop(&always, struct io_conn, always)) != NULL) {
 		assert(conn->plan[IO_IN].status == IO_ALWAYS
 		       || conn->plan[IO_OUT].status == IO_ALWAYS);
 
-		/* Remove from list, and mark it so it knows that. */
-		always = always->list;
-		conn->list = NULL;
+		/* Re-initialize, for next time. */
+		list_node_init(&conn->always);
 		io_do_always(conn);
 		ret = true;
 	}

diff --git a/ccan/ccan/list/list.h b/ccan/ccan/list/list.h
@@ -145,6 +145,18 @@ static inline void list_head_init(struct list_head *h)
 	h->n.next = h->n.prev = &h->n;
 }
 
+/**
+ * list_node_init - initialize a list_node
+ * @n: the list_node to link to itself.
+ *
+ * You don't need to use this normally!  But it lets you list_del(@n)
+ * safely.
+ */
+static inline void list_node_init(struct list_node *n)
+{
+	n->next = n->prev = n;
+}
+
 /**
  * list_add - add an entry at the start of a linked list.
  * @h: the list_head to add the node to
@@ -237,7 +249,7 @@ static inline bool list_empty_nodebug(const struct list_head *h)
  * another list, but not deleted again.
  *
  * See also:
- *	list_del_from()
+ *	list_del_from(), list_del_init()
  *
  * Example:
  *	list_del(&child->list);
@@ -255,6 +267,27 @@ static inline void list_del_(struct list_node *n, const char* abortstr)
 #endif
 }
 
+/**
+ * list_del_init - delete a node, and reset it so it can be deleted again.
+ * @n: the list_node to be deleted.
+ *
+ * list_del(@n) or list_del_init() again after this will be safe,
+ * which can be useful in some cases.
+ *
+ * See also:
+ *	list_del_from(), list_del()
+ *
+ * Example:
+ *	list_del_init(&child->list);
+ *	parent->num_children--;
+ */
+#define list_del_init(n) list_del_init_(n, LIST_LOC)
+static inline void list_del_init_(struct list_node *n, const char *abortstr)
+{
+	list_del_(n, abortstr);
+	list_node_init(n);
+}
+
 /**
  * list_del_from - delete an entry from a known linked list.
  * @h: the list_head the node is in.

diff --git a/ccan/ccan/list/test/run.c b/ccan/ccan/list/test/run.c
@@ -25,7 +25,7 @@ int main(int argc, char *argv[])
 	opaque_t *q, *nq;
 	struct list_head opaque_list = LIST_HEAD_INIT(opaque_list);
 
-	plan_tests(68);
+	plan_tests(70);
 	/* Test LIST_HEAD, LIST_HEAD_INIT, list_empty and check_list */
 	ok1(list_empty(&static_list));
 	ok1(list_check(&static_list, NULL));
@@ -155,6 +155,19 @@ int main(int argc, char *argv[])
 	ok1(i == 3);
 	ok1(list_empty(&parent.children));
 
+	/* Test list_node_init: safe to list_del after this. */
+	list_node_init(&c->list);
+	list_del(&c->list);
+
+	/* Test list_del_init */
+	list_add(&parent.children, &c->list);
+	ok1(!list_empty(&parent.children));
+	list_del_init(&c->list);
+	ok1(list_empty(&parent.children));
+	/* We can call this as many times as we like. */
+	list_del_init(&c->list);
+	list_del_init(&c->list);
+
 	/* Test list_for_each_off. */
 	list_add_tail(&opaque_list,
 		      (struct list_node *)create_opaque_blob());

diff --git a/ccan/ccan/tal/str/_info b/ccan/ccan/tal/str/_info
@@ -11,7 +11,7 @@
  *
  * Example:
  *	#include <ccan/tal/str/str.h>
- *	#include <ccan/grab_file/grab_file.h>
+ *	#include <ccan/tal/grab_file/grab_file.h>
  *	#include <err.h>
  *
  *	// Dumb demo program to double-linespace a file.
@@ -21,7 +21,7 @@
  *		char **lines;
  *
  *		// Grab lines in file.
- *		textfile = grab_file(NULL, argv[1], NULL);
+ *		textfile = grab_file(NULL, argv[1]);
  *		if (!textfile)
  *			err(1, "Failed reading %s", argv[1]);
  *		lines = tal_strsplit(textfile, textfile, "\n", STR_EMPTY_OK);