state_types: simplify open states.

The state now doesn't differentiate between who is funding.

Signed-off-by: Rusty Russell <rusty@rustcorp.com.au>

daemon/db.c

@@ -59,8 +59,8 @@ static const char *sqlite3_column_str(sqlite3_stmt *stmt, int iCol)
 #define SQL_RHASH(var)		stringify(var)" CHAR(32)"
 #define SQL_SHA256(var)		stringify(var)" CHAR(32)"
 #define SQL_R(var)		stringify(var)" CHAR(32)"
-/* STATE_OPEN_WAITING_THEIRANCHOR_THEYCOMPLETED == 44*/
+/* STATE_OPEN_WAIT_ANCHORDEPTH_AND_THEIRCOMPLETE == 45*/
-#define SQL_STATENAME(var)	stringify(var)" VARCHAR(44)"
+#define SQL_STATENAME(var)	stringify(var)" VARCHAR(45)"
 #define SQL_INVLABEL(var)	stringify(var)" VARCHAR("stringify(INVOICE_MAX_LABEL_LEN)")"
 
 /* 8 + 4 + (8 + 32) * (64 + 1) */
@@ -953,7 +953,7 @@ static void db_load_peers(struct lightningd_state *dstate)
 		load_peer_secrets(peer);
 		load_peer_closing(peer);
 		peer->anchor.min_depth = 0;
-		if (peer->state >= STATE_OPEN_WAITING_OURANCHOR
+		if (peer->state >= STATE_OPEN_WAIT_ANCHORDEPTH_AND_THEIRCOMPLETE
 		    && !state_is_error(peer->state)) {
 			load_peer_anchor(peer);
 			load_peer_visible_state(peer);

daemon/peer.c

@@ -558,7 +558,6 @@ static bool open_pkt_in(struct peer *peer, const Pkt *pkt)
 
 	assert(peer->state == STATE_OPEN_WAIT_FOR_OPENPKT);
 
-	/* FIXME: Handle PKT_SHUTDOWN? */
 	if (pkt->pkt_case != PKT__PKT_OPEN)
 		return peer_received_unexpected_pkt(peer, pkt, __func__);
 
@@ -595,7 +594,7 @@ static bool open_pkt_in(struct peer *peer, const Pkt *pkt)
 			err = pkt_err(peer, "Own anchor has insufficient funds");
 			return peer_comms_err(peer, err);
 		}
-		set_peer_state(peer,  STATE_OPEN_WAIT_FOR_COMMIT_SIG,
+		set_peer_state(peer,  STATE_OPEN_WAIT_FOR_COMMIT_SIGPKT,
 			       __func__, false);
 		if (db_commit_transaction(peer) != NULL) {
 			err = pkt_err(peer, "database error");
@@ -604,7 +603,7 @@ static bool open_pkt_in(struct peer *peer, const Pkt *pkt)
 		queue_pkt_anchor(peer);
 		return true;
 	} else {
-		set_peer_state(peer,  STATE_OPEN_WAIT_FOR_ANCHOR,
+		set_peer_state(peer,  STATE_OPEN_WAIT_FOR_ANCHORPKT,
 			       __func__, false);
 		if (db_commit_transaction(peer) != NULL) {
 			err = pkt_err(peer, "database error");
@@ -630,18 +629,6 @@ static bool open_ouranchor_pkt_in(struct peer *peer, const Pkt *pkt)
 {
 	Pkt *err;
 
-	if (pkt->pkt_case == PKT__PKT_CLOSE_SHUTDOWN) {
-		err = accept_pkt_close_shutdown(peer, pkt);
-		if (err)
-			return peer_comms_err(peer, err);
-
-		set_peer_state(peer, STATE_SHUTDOWN, __func__, false);
-		peer_breakdown(peer);
-		return false;
-	}
-
-	switch (peer->state) {
-	case STATE_OPEN_WAIT_FOR_COMMIT_SIG:
 	if (pkt->pkt_case != PKT__PKT_OPEN_COMMIT_SIG)
 		return peer_received_unexpected_pkt(peer, pkt, __func__);
 
@@ -659,8 +646,7 @@ static bool open_ouranchor_pkt_in(struct peer *peer, const Pkt *pkt)
 		err = pkt_err(peer, "Bad signature");
 
 	if (err) {
-			peer->local.commit->sig
+		peer->local.commit->sig = tal_free(peer->local.commit->sig);
-				= tal_free(peer->local.commit->sig);
 		return peer_comms_err(peer, err);
 	}
 
@@ -669,7 +655,8 @@ static bool open_ouranchor_pkt_in(struct peer *peer, const Pkt *pkt)
 	db_start_transaction(peer);
 	db_set_anchor(peer);
 	db_new_commit_info(peer, LOCAL, NULL);
-		set_peer_state(peer,  STATE_OPEN_WAITING_OURANCHOR,
+	set_peer_state(peer,
+		       STATE_OPEN_WAIT_ANCHORDEPTH_AND_THEIRCOMPLETE,
 		       __func__, false);
 	if (db_commit_transaction(peer) != NULL) {
 		err = pkt_err(peer, "database error");
@@ -678,61 +665,14 @@ static bool open_ouranchor_pkt_in(struct peer *peer, const Pkt *pkt)
 	broadcast_tx(peer, peer->anchor.tx, funding_tx_failed);
 	peer_watch_anchor(peer, peer->local.mindepth);
 	return true;
-
-	case STATE_OPEN_WAITING_OURANCHOR:
-	case STATE_OPEN_WAIT_FOR_COMPLETE_OURANCHOR:
-		if (pkt->pkt_case == PKT__PKT_OPEN_COMPLETE) {
-			err = accept_pkt_open_complete(peer, pkt);
-			if (err)
-				return peer_comms_err(peer, err);
-
-			db_start_transaction(peer);
-			/* We've already noticed anchor reach depth? */
-			if (peer->state == STATE_OPEN_WAIT_FOR_COMPLETE_OURANCHOR) {
-				peer_open_complete(peer, NULL);
-				set_peer_state(peer, STATE_NORMAL,
-					       __func__, true);
-			} else {
-				set_peer_state(peer,
-					       STATE_OPEN_WAITING_OURANCHOR_THEYCOMPLETED,
-					       __func__, false);
 }
-			if (db_commit_transaction(peer) != NULL) {
-				err = pkt_err(peer, "database error");
-				return peer_comms_err(peer, err);
-			}
-			return true;
-		}
-	/* Fall thru */
-	case STATE_OPEN_WAITING_OURANCHOR_THEYCOMPLETED:
-		return peer_received_unexpected_pkt(peer, pkt, __func__);
 
-	default:
-		log_unusual(peer->log,
-			    "%s: unexpected state %s",
-			    __func__, state_name(peer->state));
-		peer_fail(peer, __func__);
-		return false;
-	}
-}
 
 static bool open_theiranchor_pkt_in(struct peer *peer, const Pkt *pkt)
 {
 	Pkt *err;
 	const char *db_err;
 
-	if (pkt->pkt_case == PKT__PKT_CLOSE_SHUTDOWN) {
-		err = accept_pkt_close_shutdown(peer, pkt);
-		if (err)
-			return peer_comms_err(peer, err);
-
-		set_peer_state(peer, STATE_SHUTDOWN, __func__, false);
-		peer_breakdown(peer);
-		return false;
-	}
-
-	switch (peer->state) {
-	case STATE_OPEN_WAIT_FOR_ANCHOR:
 	if (pkt->pkt_case != PKT__PKT_OPEN_ANCHOR)
 		return peer_received_unexpected_pkt(peer, pkt, __func__);
 
@@ -768,8 +708,8 @@ static bool open_theiranchor_pkt_in(struct peer *peer, const Pkt *pkt)
 	peer_add_their_commit(peer,
 			      &peer->remote.commit->txid,
 			      peer->remote.commit->commit_num);
-		set_peer_state(peer, STATE_OPEN_WAITING_THEIRANCHOR, __func__,
+	set_peer_state(peer, STATE_OPEN_WAIT_ANCHORDEPTH_AND_THEIRCOMPLETE,
-			       false);
+		       __func__, false);
 	db_err = db_commit_transaction(peer);
 	if (db_err) {
 		err = pkt_err(peer, "database error");
@@ -780,10 +720,36 @@ static bool open_theiranchor_pkt_in(struct peer *peer, const Pkt *pkt)
 	queue_pkt_open_commit_sig(peer);
 	peer_watch_anchor(peer, peer->local.mindepth);
 	return true;
+}
+
+static bool open_wait_pkt_in(struct peer *peer, const Pkt *pkt)
+{
+	Pkt *err;
+	const char *db_err;
+
+	/* If they want to shutdown during this, we do mutual close dance. */
+	if (pkt->pkt_case == PKT__PKT_CLOSE_SHUTDOWN) {
+		err = accept_pkt_close_shutdown(peer, pkt);
+		if (err)
+			return peer_comms_err(peer, err);
+
+		/* FIXME: All in one transaction! */
+		if (!db_set_their_closing_script(peer))
+			err = pkt_err(peer, "database error");
+		else
+			err = start_closing(peer);
+
+		if (err)
+			return peer_comms_err(peer, err);
+		return false;
+	}
+
+	switch (peer->state) {
+	case STATE_OPEN_WAIT_ANCHORDEPTH_AND_THEIRCOMPLETE:
+	case STATE_OPEN_WAIT_THEIRCOMPLETE:
+		if (pkt->pkt_case != PKT__PKT_OPEN_COMPLETE)
+			return peer_received_unexpected_pkt(peer, pkt, __func__);
 			
-	case STATE_OPEN_WAITING_THEIRANCHOR:
-	case STATE_OPEN_WAIT_FOR_COMPLETE_THEIRANCHOR:
-		if (pkt->pkt_case == PKT__PKT_OPEN_COMPLETE) {
 		err = accept_pkt_open_complete(peer, pkt);
 		if (err) {
 			peer_open_complete(peer, err->error->problem);
@@ -791,14 +757,12 @@ static bool open_theiranchor_pkt_in(struct peer *peer, const Pkt *pkt)
 		}
 
 		db_start_transaction(peer);
-			if (peer->state == STATE_OPEN_WAITING_THEIRANCHOR) {
+		if (peer->state == STATE_OPEN_WAIT_THEIRCOMPLETE) {
-				set_peer_state(peer,
-					       STATE_OPEN_WAITING_THEIRANCHOR_THEYCOMPLETED,
-					       __func__, false);
-			} else {
 			peer_open_complete(peer, NULL);
-				set_peer_state(peer, STATE_NORMAL,
+			set_peer_state(peer, STATE_NORMAL, __func__, true);
-					       __func__, true);
+		} else {
+			set_peer_state(peer, STATE_OPEN_WAIT_ANCHORDEPTH,
+				       __func__, false);
 		}
 
 		db_err = db_commit_transaction(peer);
@@ -808,9 +772,8 @@ static bool open_theiranchor_pkt_in(struct peer *peer, const Pkt *pkt)
 			return peer_comms_err(peer, err);
 		}
 		return true;
-		}
+
-	/* Fall thru */
+	case STATE_OPEN_WAIT_ANCHORDEPTH:
-	case STATE_OPEN_WAITING_THEIRANCHOR_THEYCOMPLETED:
 		return peer_received_unexpected_pkt(peer, pkt, __func__);
 
 	default:
@@ -2229,12 +2192,13 @@ static struct io_plan *pkt_in(struct io_conn *conn, struct peer *peer)
 		keep_going = closing_pkt_in(peer, peer->inpkt);
 	else if (peer->state == STATE_OPEN_WAIT_FOR_OPENPKT)
 		keep_going = open_pkt_in(peer, peer->inpkt);
-	else if (state_is_opening(peer->state)) {
+	else if (peer->state == STATE_OPEN_WAIT_FOR_COMMIT_SIGPKT)
-		if (peer->local.offer_anchor)
 		keep_going = open_ouranchor_pkt_in(peer, peer->inpkt);
-		else
+	else if (peer->state == STATE_OPEN_WAIT_FOR_ANCHORPKT)
 		keep_going = open_theiranchor_pkt_in(peer, peer->inpkt);
-	} else {
+	else if (state_is_openwait(peer->state))
+		keep_going = open_wait_pkt_in(peer, peer->inpkt);
+	else {
 		log_unusual(peer->log,
 			    "Unexpected state %s", state_name(peer->state));
 		keep_going = false;
@@ -3305,16 +3269,11 @@ static void peer_depth_ok(struct peer *peer)
 	db_start_transaction(peer);
 	
 	switch (peer->state) {
-	case STATE_OPEN_WAITING_OURANCHOR:
+	case STATE_OPEN_WAIT_ANCHORDEPTH_AND_THEIRCOMPLETE:
-		set_peer_state(peer, STATE_OPEN_WAIT_FOR_COMPLETE_OURANCHOR,
+		set_peer_state(peer, STATE_OPEN_WAIT_THEIRCOMPLETE,
-			       __func__, false);
-		break;
-	case STATE_OPEN_WAITING_THEIRANCHOR:
-		set_peer_state(peer, STATE_OPEN_WAIT_FOR_COMPLETE_THEIRANCHOR,
 			       __func__, false);
 		break;
-	case STATE_OPEN_WAITING_OURANCHOR_THEYCOMPLETED:
+	case STATE_OPEN_WAIT_ANCHORDEPTH:
-	case STATE_OPEN_WAITING_THEIRANCHOR_THEYCOMPLETED:
 		peer_open_complete(peer, NULL);
 		set_peer_state(peer, STATE_NORMAL, __func__, true);
 		break;

daemon/test/test.sh

@@ -475,9 +475,9 @@ $CLI generate 1
 
 lcli1 connect localhost $PORT2 $TX &
 
-# Expect them to be waiting for anchor.
+# Expect them to be waiting for anchor, and ack from other side.
-check_peerstate lcli1 STATE_OPEN_WAITING_OURANCHOR
+check_peerstate lcli1 STATE_OPEN_WAIT_ANCHORDEPTH_AND_THEIRCOMPLETE
-check_peerstate lcli2 STATE_OPEN_WAITING_THEIRANCHOR
+check_peerstate lcli2 STATE_OPEN_WAIT_ANCHORDEPTH_AND_THEIRCOMPLETE
 
 DO_RECONNECT=$RECONNECT
 

state.h

@@ -35,17 +35,22 @@ static inline bool state_is_normal(enum state s)
 	return s == STATE_NORMAL || s == STATE_NORMAL_COMMITTING;
 }
 
-static inline bool state_is_opening(enum state s)
+static inline bool state_is_waiting_for_anchor(enum state s)
 {
-	return s < STATE_NORMAL;
+	return s == STATE_OPEN_WAIT_ANCHORDEPTH_AND_THEIRCOMPLETE
+		|| s == STATE_OPEN_WAIT_ANCHORDEPTH;
 }
 
-static inline bool state_is_waiting_for_anchor(enum state s)
+static inline bool state_is_openwait(enum state s)
+{
+	return s == STATE_OPEN_WAIT_ANCHORDEPTH_AND_THEIRCOMPLETE
+		|| s == STATE_OPEN_WAIT_ANCHORDEPTH
+		|| s == STATE_OPEN_WAIT_THEIRCOMPLETE;
+}
+
+static inline bool state_is_opening(enum state s)
 {
-	return s == STATE_OPEN_WAITING_OURANCHOR
+	return s <= STATE_OPEN_WAIT_THEIRCOMPLETE;
-		|| s == STATE_OPEN_WAITING_OURANCHOR_THEYCOMPLETED
-		|| s == STATE_OPEN_WAITING_THEIRANCHOR
-		|| s == STATE_OPEN_WAITING_THEIRANCHOR_THEYCOMPLETED;
 }
 
 static inline bool state_can_io(enum state s)

state_types.h

@@ -11,14 +11,15 @@ enum state {
 	 * Opening.
 	 */
 	STATE_OPEN_WAIT_FOR_OPENPKT,
-	STATE_OPEN_WAIT_FOR_ANCHOR,
+	STATE_OPEN_WAIT_FOR_ANCHORPKT,
-	STATE_OPEN_WAIT_FOR_COMMIT_SIG,
+	STATE_OPEN_WAIT_FOR_COMMIT_SIGPKT,
-	STATE_OPEN_WAITING_OURANCHOR,
+
-	STATE_OPEN_WAITING_THEIRANCHOR,
+	/* We're waiting for depth+their complete. */
-	STATE_OPEN_WAITING_OURANCHOR_THEYCOMPLETED,
+	STATE_OPEN_WAIT_ANCHORDEPTH_AND_THEIRCOMPLETE,
-	STATE_OPEN_WAITING_THEIRANCHOR_THEYCOMPLETED,
+	/* Got their pkt_complete. */
-	STATE_OPEN_WAIT_FOR_COMPLETE_OURANCHOR,
+	STATE_OPEN_WAIT_ANCHORDEPTH,
-	STATE_OPEN_WAIT_FOR_COMPLETE_THEIRANCHOR,
+	/* Got anchor depth. */
+	STATE_OPEN_WAIT_THEIRCOMPLETE,
 
 	/*
 	 * Normal state.