mirrors/core-lightning
1
0
Fork 0
mirror of https://github.com/ElementsProject/lightning.git synced 2025-01-18 05:12:45 +01:00
Code Issues Projects Releases Wiki Activity

state: set peer->state directly.

Browse Source 
Instead of new_state effect.

Signed-off-by: Rusty Russell <rusty@rustcorp.com.au>
This commit is contained in:
Rusty Russell 2016-01-22 06:41:46 +10:30
parent 4c9a9f8982
commit 9013a7d872
3 changed files with 167 additions and 157 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

240
state.c
View File

@ -25,13 +25,42 @@ static inline bool high_priority(enum state state)
#define BITS_TO_STATE(bits) (STATE_CLOSED + (bits)) #define BITS_TO_STATE(bits) (STATE_CLOSED + (bits))
#define STATE_TO_BITS(state) ((state) - STATE_CLOSED) #define STATE_TO_BITS(state) ((state) - STATE_CLOSED)
static enum command_status next_state(const tal_t *ctx, /* For the rare cases where state may not change */
enum command_status status, static enum command_status next_state_nocheck(struct peer *peer,
struct state_effect **effect, enum command_status cstatus,
const enum state state) const enum state state)
{ {
add_effect(effect, new_state, state); peer->state = state;
return status; return cstatus;
}
static enum command_status next_state(struct peer *peer,
enum command_status cstatus,
const enum state state)
{
assert(peer->state != state);
return next_state_nocheck(peer, cstatus, state);
}
/*
* Simple marker to note we don't update state.
*
* This happens in two cases:
* - We're ignoring packets while closing.
* - We stop watching an on-chain HTLC: we indicate that we want
* INPUT_NO_MORE_HTLCS when we get the last one.
*/
static enum command_status unchanged_state(enum command_status cstatus)
{
return cstatus;
}
/* This may not actually change the state. */
static enum command_status next_state_bits(struct peer *peer,
enum command_status cstatus,
unsigned int bits)
{
return next_state_nocheck(peer, cstatus, BITS_TO_STATE(bits));
} }
static void set_peer_cond(struct peer *peer, enum state_peercond cond) static void set_peer_cond(struct peer *peer, enum state_peercond cond)
@ -56,7 +85,6 @@ static void complete_cmd(struct peer *peer, enum command_status *statusp,
} }
enum command_status state(const tal_t *ctx, enum command_status state(const tal_t *ctx,
const enum state state,
struct peer *peer, struct peer *peer,
const enum state_input input, const enum state_input input,
const union input *idata, const union input *idata,
@ -72,7 +100,7 @@ enum command_status state(const tal_t *ctx,
/* NULL-terminated linked list. */ /* NULL-terminated linked list. */
*effect = NULL; *effect = NULL;
switch (state) { switch (peer->state) {
/* /*
* Initial channel opening states. * Initial channel opening states.
*/ */
@ -82,14 +110,14 @@ enum command_status state(const tal_t *ctx,
pkt_open(ctx, peer, pkt_open(ctx, peer,
OPEN_CHANNEL__ANCHOR_OFFER__WILL_CREATE_ANCHOR)); OPEN_CHANNEL__ANCHOR_OFFER__WILL_CREATE_ANCHOR));
change_peer_cond(peer, PEER_CMD_OK, PEER_BUSY); change_peer_cond(peer, PEER_CMD_OK, PEER_BUSY);
return next_state(ctx, cstatus, effect, return next_state(peer, cstatus,
STATE_OPEN_WAIT_FOR_OPEN_WITHANCHOR); STATE_OPEN_WAIT_FOR_OPEN_WITHANCHOR);
} else if (input_is(input, CMD_OPEN_WITHOUT_ANCHOR)) { } else if (input_is(input, CMD_OPEN_WITHOUT_ANCHOR)) {
change_peer_cond(peer, PEER_CMD_OK, PEER_BUSY); change_peer_cond(peer, PEER_CMD_OK, PEER_BUSY);
add_effect(effect, send_pkt, add_effect(effect, send_pkt,
pkt_open(ctx, peer, pkt_open(ctx, peer,
OPEN_CHANNEL__ANCHOR_OFFER__WONT_CREATE_ANCHOR)); OPEN_CHANNEL__ANCHOR_OFFER__WONT_CREATE_ANCHOR));
return next_state(ctx, cstatus, effect, return next_state(peer, cstatus,
STATE_OPEN_WAIT_FOR_OPEN_NOANCHOR); STATE_OPEN_WAIT_FOR_OPEN_NOANCHOR);
} }
break; break;
@ -100,7 +128,7 @@ enum command_status state(const tal_t *ctx,
complete_cmd(peer, &cstatus, CMD_FAIL); complete_cmd(peer, &cstatus, CMD_FAIL);
goto err_close_nocleanup; goto err_close_nocleanup;
} }
return next_state(ctx, cstatus, effect, STATE_OPEN_WAIT_FOR_ANCHOR); return next_state(peer, cstatus, STATE_OPEN_WAIT_FOR_ANCHOR);
} else if (input_is(input, CMD_CLOSE)) { } else if (input_is(input, CMD_CLOSE)) {
complete_cmd(peer, &cstatus, CMD_FAIL); complete_cmd(peer, &cstatus, CMD_FAIL);
goto instant_close; goto instant_close;
@ -117,7 +145,7 @@ enum command_status state(const tal_t *ctx,
goto err_close_nocleanup; goto err_close_nocleanup;
} }
add_effect(effect, send_pkt, pkt_anchor(ctx, peer)); add_effect(effect, send_pkt, pkt_anchor(ctx, peer));
return next_state(ctx, cstatus, effect, return next_state(peer, cstatus,
STATE_OPEN_WAIT_FOR_COMMIT_SIG); STATE_OPEN_WAIT_FOR_COMMIT_SIG);
} else if (input_is(input, CMD_CLOSE)) { } else if (input_is(input, CMD_CLOSE)) {
complete_cmd(peer, &cstatus, CMD_FAIL); complete_cmd(peer, &cstatus, CMD_FAIL);
@ -144,7 +172,7 @@ enum command_status state(const tal_t *ctx,
BITCOIN_ANCHOR_THEIRSPEND, BITCOIN_ANCHOR_THEIRSPEND,
BITCOIN_ANCHOR_OTHERSPEND)); BITCOIN_ANCHOR_OTHERSPEND));
return next_state(ctx, cstatus, effect, return next_state(peer, cstatus,
STATE_OPEN_WAITING_THEIRANCHOR); STATE_OPEN_WAITING_THEIRANCHOR);
} else if (input_is(input, CMD_CLOSE)) { } else if (input_is(input, CMD_CLOSE)) {
complete_cmd(peer, &cstatus, CMD_FAIL); complete_cmd(peer, &cstatus, CMD_FAIL);
@ -171,7 +199,7 @@ enum command_status state(const tal_t *ctx,
BITCOIN_ANCHOR_UNSPENT, BITCOIN_ANCHOR_UNSPENT,
BITCOIN_ANCHOR_THEIRSPEND, BITCOIN_ANCHOR_THEIRSPEND,
BITCOIN_ANCHOR_OTHERSPEND)); BITCOIN_ANCHOR_OTHERSPEND));
return next_state(ctx, cstatus, effect, return next_state(peer, cstatus,
STATE_OPEN_WAITING_OURANCHOR); STATE_OPEN_WAITING_OURANCHOR);
} else if (input_is(input, CMD_CLOSE)) { } else if (input_is(input, CMD_CLOSE)) {
complete_cmd(peer, &cstatus, CMD_FAIL); complete_cmd(peer, &cstatus, CMD_FAIL);
@ -183,7 +211,7 @@ enum command_status state(const tal_t *ctx,
break; break;
case STATE_OPEN_WAITING_OURANCHOR: case STATE_OPEN_WAITING_OURANCHOR:
if (input_is(input, PKT_OPEN_COMPLETE)) { if (input_is(input, PKT_OPEN_COMPLETE)) {
return next_state(ctx, cstatus, effect, return next_state(peer, cstatus,
STATE_OPEN_WAITING_OURANCHOR_THEYCOMPLETED); STATE_OPEN_WAITING_OURANCHOR_THEYCOMPLETED);
} }
/* Fall thru */ /* Fall thru */
@ -191,12 +219,12 @@ enum command_status state(const tal_t *ctx,
if (input_is(input, BITCOIN_ANCHOR_DEPTHOK)) { if (input_is(input, BITCOIN_ANCHOR_DEPTHOK)) {
add_effect(effect, send_pkt, add_effect(effect, send_pkt,
pkt_open_complete(ctx, peer)); pkt_open_complete(ctx, peer));
if (state == STATE_OPEN_WAITING_OURANCHOR_THEYCOMPLETED) { if (peer->state == STATE_OPEN_WAITING_OURANCHOR_THEYCOMPLETED) {
complete_cmd(peer, &cstatus, CMD_SUCCESS); complete_cmd(peer, &cstatus, CMD_SUCCESS);
return next_state(ctx, cstatus, effect, return next_state(peer, cstatus,
STATE_NORMAL_HIGHPRIO); STATE_NORMAL_HIGHPRIO);
} }
return next_state(ctx, cstatus, effect, return next_state(peer, cstatus,
STATE_OPEN_WAIT_FOR_COMPLETE_OURANCHOR); STATE_OPEN_WAIT_FOR_COMPLETE_OURANCHOR);
} else if (input_is(input, BITCOIN_ANCHOR_UNSPENT)) { } else if (input_is(input, BITCOIN_ANCHOR_UNSPENT)) {
complete_cmd(peer, &cstatus, CMD_FAIL); complete_cmd(peer, &cstatus, CMD_FAIL);
@ -211,7 +239,7 @@ enum command_status state(const tal_t *ctx,
goto them_unilateral; goto them_unilateral;
} else if (input_is(input, BITCOIN_ANCHOR_OTHERSPEND)) { } else if (input_is(input, BITCOIN_ANCHOR_OTHERSPEND)) {
/* This should be impossible. */ /* This should be impossible. */
return next_state(ctx, cstatus, effect, STATE_ERR_INFORMATION_LEAK); return next_state(peer, cstatus, STATE_ERR_INFORMATION_LEAK);
} else if (input_is(input, CMD_CLOSE)) { } else if (input_is(input, CMD_CLOSE)) {
/* We no longer care about anchor depth. */ /* We no longer care about anchor depth. */
add_effect(effect, unwatch, add_effect(effect, unwatch,
@ -240,7 +268,7 @@ enum command_status state(const tal_t *ctx,
break; break;
case STATE_OPEN_WAITING_THEIRANCHOR: case STATE_OPEN_WAITING_THEIRANCHOR:
if (input_is(input, PKT_OPEN_COMPLETE)) { if (input_is(input, PKT_OPEN_COMPLETE)) {
return next_state(ctx, cstatus, effect, return next_state(peer, cstatus,
STATE_OPEN_WAITING_THEIRANCHOR_THEYCOMPLETED); STATE_OPEN_WAITING_THEIRANCHOR_THEYCOMPLETED);
} }
/* Fall thru */ /* Fall thru */
@ -249,23 +277,23 @@ enum command_status state(const tal_t *ctx,
/* Anchor didn't reach blockchain in reasonable time. */ /* Anchor didn't reach blockchain in reasonable time. */
add_effect(effect, send_pkt, add_effect(effect, send_pkt,
pkt_err(ctx, "Anchor timed out")); pkt_err(ctx, "Anchor timed out"));
return next_state(ctx, cstatus, effect, STATE_ERR_ANCHOR_TIMEOUT); return next_state(peer, cstatus, STATE_ERR_ANCHOR_TIMEOUT);
} else if (input_is(input, BITCOIN_ANCHOR_DEPTHOK)) { } else if (input_is(input, BITCOIN_ANCHOR_DEPTHOK)) {
add_effect(effect, send_pkt, add_effect(effect, send_pkt,
pkt_open_complete(ctx, peer)); pkt_open_complete(ctx, peer));
if (state == STATE_OPEN_WAITING_THEIRANCHOR_THEYCOMPLETED) { if (peer->state == STATE_OPEN_WAITING_THEIRANCHOR_THEYCOMPLETED) {
complete_cmd(peer, &cstatus, CMD_SUCCESS); complete_cmd(peer, &cstatus, CMD_SUCCESS);
return next_state(ctx, cstatus, effect, return next_state(peer, cstatus,
STATE_NORMAL_LOWPRIO); STATE_NORMAL_LOWPRIO);
} }
return next_state(ctx, cstatus, effect, return next_state(peer, cstatus,
STATE_OPEN_WAIT_FOR_COMPLETE_THEIRANCHOR); STATE_OPEN_WAIT_FOR_COMPLETE_THEIRANCHOR);
} else if (input_is(input, BITCOIN_ANCHOR_UNSPENT)) { } else if (input_is(input, BITCOIN_ANCHOR_UNSPENT)) {
complete_cmd(peer, &cstatus, CMD_FAIL); complete_cmd(peer, &cstatus, CMD_FAIL);
goto anchor_unspent; goto anchor_unspent;
} else if (input_is(input, BITCOIN_ANCHOR_OTHERSPEND)) { } else if (input_is(input, BITCOIN_ANCHOR_OTHERSPEND)) {
/* This should be impossible. */ /* This should be impossible. */
return next_state(ctx, cstatus, effect, return next_state(peer, cstatus,
STATE_ERR_INFORMATION_LEAK); STATE_ERR_INFORMATION_LEAK);
} else if (input_is(input, BITCOIN_ANCHOR_THEIRSPEND)) { } else if (input_is(input, BITCOIN_ANCHOR_THEIRSPEND)) {
/* We no longer care about anchor depth. */ /* We no longer care about anchor depth. */
@ -305,13 +333,13 @@ enum command_status state(const tal_t *ctx,
case STATE_OPEN_WAIT_FOR_COMPLETE_THEIRANCHOR: case STATE_OPEN_WAIT_FOR_COMPLETE_THEIRANCHOR:
if (input_is(input, PKT_OPEN_COMPLETE)) { if (input_is(input, PKT_OPEN_COMPLETE)) {
/* Ready for business! Anchorer goes first. */ /* Ready for business! Anchorer goes first. */
if (state == STATE_OPEN_WAIT_FOR_COMPLETE_OURANCHOR) { if (peer->state == STATE_OPEN_WAIT_FOR_COMPLETE_OURANCHOR) {
complete_cmd(peer, &cstatus, CMD_SUCCESS); complete_cmd(peer, &cstatus, CMD_SUCCESS);
return next_state(ctx, cstatus, effect, return next_state(peer, cstatus,
STATE_NORMAL_HIGHPRIO); STATE_NORMAL_HIGHPRIO);
} else { } else {
complete_cmd(peer, &cstatus, CMD_SUCCESS); complete_cmd(peer, &cstatus, CMD_SUCCESS);
return next_state(ctx, cstatus, effect, return next_state(peer, cstatus,
STATE_NORMAL_LOWPRIO); STATE_NORMAL_LOWPRIO);
} }
} else if (input_is(input, BITCOIN_ANCHOR_UNSPENT)) { } else if (input_is(input, BITCOIN_ANCHOR_UNSPENT)) {
@ -320,7 +348,7 @@ enum command_status state(const tal_t *ctx,
/* Nobody should be able to spend anchor, except via the /* Nobody should be able to spend anchor, except via the
* commit txs. */ * commit txs. */
} else if (input_is(input, BITCOIN_ANCHOR_OTHERSPEND)) { } else if (input_is(input, BITCOIN_ANCHOR_OTHERSPEND)) {
return next_state(ctx, cstatus, effect, return next_state(peer, cstatus,
STATE_ERR_INFORMATION_LEAK); STATE_ERR_INFORMATION_LEAK);
} else if (input_is(input, BITCOIN_ANCHOR_THEIRSPEND)) { } else if (input_is(input, BITCOIN_ANCHOR_THEIRSPEND)) {
complete_cmd(peer, &cstatus, CMD_FAIL); complete_cmd(peer, &cstatus, CMD_FAIL);
@ -350,8 +378,8 @@ enum command_status state(const tal_t *ctx,
idata->htlc_prog)); idata->htlc_prog));
add_effect(effect, htlc_in_progress, idata->htlc_prog); add_effect(effect, htlc_in_progress, idata->htlc_prog);
change_peer_cond(peer, PEER_CMD_OK, PEER_BUSY); change_peer_cond(peer, PEER_CMD_OK, PEER_BUSY);
return next_state(ctx, cstatus, effect, return next_state(peer, cstatus,
prio(state, STATE_WAIT_FOR_HTLC_ACCEPT)); prio(peer->state, STATE_WAIT_FOR_HTLC_ACCEPT));
} else if (input_is(input, CMD_SEND_HTLC_FULFILL)) { } else if (input_is(input, CMD_SEND_HTLC_FULFILL)) {
/* We are to send an HTLC fulfill. */ /* We are to send an HTLC fulfill. */
/* This gives us the r value (FIXME: type!) */ /* This gives us the r value (FIXME: type!) */
@ -362,8 +390,8 @@ enum command_status state(const tal_t *ctx,
idata->htlc_prog)); idata->htlc_prog));
add_effect(effect, htlc_in_progress, idata->htlc_prog); add_effect(effect, htlc_in_progress, idata->htlc_prog);
change_peer_cond(peer, PEER_CMD_OK, PEER_BUSY); change_peer_cond(peer, PEER_CMD_OK, PEER_BUSY);
return next_state(ctx, cstatus, effect, return next_state(peer, cstatus,
prio(state, STATE_WAIT_FOR_UPDATE_ACCEPT)); prio(peer->state, STATE_WAIT_FOR_UPDATE_ACCEPT));
} else if (input_is(input, CMD_SEND_HTLC_TIMEDOUT)) { } else if (input_is(input, CMD_SEND_HTLC_TIMEDOUT)) {
/* We are to send an HTLC timedout. */ /* We are to send an HTLC timedout. */
add_effect(effect, send_pkt, add_effect(effect, send_pkt,
@ -371,8 +399,8 @@ enum command_status state(const tal_t *ctx,
idata->htlc_prog)); idata->htlc_prog));
add_effect(effect, htlc_in_progress, idata->htlc_prog); add_effect(effect, htlc_in_progress, idata->htlc_prog);
change_peer_cond(peer, PEER_CMD_OK, PEER_BUSY); change_peer_cond(peer, PEER_CMD_OK, PEER_BUSY);
return next_state(ctx, cstatus, effect, return next_state(peer, cstatus,
prio(state, STATE_WAIT_FOR_UPDATE_ACCEPT)); prio(peer->state, STATE_WAIT_FOR_UPDATE_ACCEPT));
} else if (input_is(input, CMD_SEND_HTLC_ROUTEFAIL)) { } else if (input_is(input, CMD_SEND_HTLC_ROUTEFAIL)) {
/* We are to send an HTLC routefail. */ /* We are to send an HTLC routefail. */
add_effect(effect, send_pkt, add_effect(effect, send_pkt,
@ -380,8 +408,8 @@ enum command_status state(const tal_t *ctx,
idata->htlc_prog)); idata->htlc_prog));
add_effect(effect, htlc_in_progress, idata->htlc_prog); add_effect(effect, htlc_in_progress, idata->htlc_prog);
change_peer_cond(peer, PEER_CMD_OK, PEER_BUSY); change_peer_cond(peer, PEER_CMD_OK, PEER_BUSY);
return next_state(ctx, cstatus, effect, return next_state(peer, cstatus,
prio(state, STATE_WAIT_FOR_UPDATE_ACCEPT)); prio(peer->state, STATE_WAIT_FOR_UPDATE_ACCEPT));
} else if (input_is(input, CMD_CLOSE)) { } else if (input_is(input, CMD_CLOSE)) {
goto start_closing; goto start_closing;
} else if (input_is(input, PKT_UPDATE_ADD_HTLC)) { } else if (input_is(input, PKT_UPDATE_ADD_HTLC)) {
@ -415,8 +443,8 @@ enum command_status state(const tal_t *ctx,
add_effect(effect, htlc_abandon, true); add_effect(effect, htlc_abandon, true);
complete_cmd(peer, &cstatus, CMD_FAIL); complete_cmd(peer, &cstatus, CMD_FAIL);
/* No update means no priority change. */ /* No update means no priority change. */
return next_state(ctx, cstatus, effect, return next_state(peer, cstatus,
prio(state, STATE_NORMAL)); prio(peer->state, STATE_NORMAL));
/* They can't close with an HTLC, so only possible here */ /* They can't close with an HTLC, so only possible here */
} else if (input_is(input, PKT_CLOSE)) { } else if (input_is(input, PKT_CLOSE)) {
complete_cmd(peer, &cstatus, CMD_FAIL); complete_cmd(peer, &cstatus, CMD_FAIL);
@ -428,7 +456,7 @@ enum command_status state(const tal_t *ctx,
case STATE_WAIT_FOR_UPDATE_ACCEPT_HIGHPRIO: case STATE_WAIT_FOR_UPDATE_ACCEPT_HIGHPRIO:
if (input_is(input, PKT_UPDATE_ADD_HTLC)) { if (input_is(input, PKT_UPDATE_ADD_HTLC)) {
/* If we're high priority, ignore their packet */ /* If we're high priority, ignore their packet */
if (high_priority(state)) if (high_priority(peer->state))
return cstatus; return cstatus;
/* Otherwise, process their request first: defer ours */ /* Otherwise, process their request first: defer ours */
@ -439,7 +467,7 @@ enum command_status state(const tal_t *ctx,
goto accept_htlc_update; goto accept_htlc_update;
} else if (input_is(input, PKT_UPDATE_FULFILL_HTLC)) { } else if (input_is(input, PKT_UPDATE_FULFILL_HTLC)) {
/* If we're high priority, ignore their packet */ /* If we're high priority, ignore their packet */
if (high_priority(state)) if (high_priority(peer->state))
return cstatus; return cstatus;
/* Otherwise, process their request first: defer ours */ /* Otherwise, process their request first: defer ours */
@ -450,7 +478,7 @@ enum command_status state(const tal_t *ctx,
goto accept_htlc_fulfill; goto accept_htlc_fulfill;
} else if (input_is(input, PKT_UPDATE_TIMEDOUT_HTLC)) { } else if (input_is(input, PKT_UPDATE_TIMEDOUT_HTLC)) {
/* If we're high priority, ignore their packet */ /* If we're high priority, ignore their packet */
if (high_priority(state)) if (high_priority(peer->state))
return cstatus; return cstatus;
/* Otherwise, process their request first: defer ours */ /* Otherwise, process their request first: defer ours */
@ -461,7 +489,7 @@ enum command_status state(const tal_t *ctx,
goto accept_htlc_timedout; goto accept_htlc_timedout;
} else if (input_is(input, PKT_UPDATE_ROUTEFAIL_HTLC)) { } else if (input_is(input, PKT_UPDATE_ROUTEFAIL_HTLC)) {
/* If we're high priority, ignore their packet */ /* If we're high priority, ignore their packet */
if (high_priority(state)) if (high_priority(peer->state))
return cstatus; return cstatus;
/* Otherwise, process their request first: defer ours */ /* Otherwise, process their request first: defer ours */
@ -484,8 +512,8 @@ enum command_status state(const tal_t *ctx,
pkt_update_signature(ctx, peer)); pkt_update_signature(ctx, peer));
/* HTLC is signed (though old tx not revoked yet!) */ /* HTLC is signed (though old tx not revoked yet!) */
add_effect(effect, htlc_fulfill, true); add_effect(effect, htlc_fulfill, true);
return next_state(ctx, cstatus, effect, return next_state(peer, cstatus,
prio(state, STATE_WAIT_FOR_UPDATE_COMPLETE)); prio(peer->state, STATE_WAIT_FOR_UPDATE_COMPLETE));
} else if (input_is(input, BITCOIN_ANCHOR_UNSPENT)) { } else if (input_is(input, BITCOIN_ANCHOR_UNSPENT)) {
complete_cmd(peer, &cstatus, CMD_FAIL); complete_cmd(peer, &cstatus, CMD_FAIL);
add_effect(effect, htlc_abandon, true); add_effect(effect, htlc_abandon, true);
@ -518,8 +546,8 @@ enum command_status state(const tal_t *ctx,
goto err_start_unilateral_close; goto err_start_unilateral_close;
} }
complete_cmd(peer, &cstatus, CMD_SUCCESS); complete_cmd(peer, &cstatus, CMD_SUCCESS);
return next_state(ctx, cstatus, effect, return next_state(peer, cstatus,
toggle_prio(state, STATE_NORMAL)); toggle_prio(peer->state, STATE_NORMAL));
} else if (input_is(input, BITCOIN_ANCHOR_UNSPENT)) { } else if (input_is(input, BITCOIN_ANCHOR_UNSPENT)) {
complete_cmd(peer, &cstatus, CMD_FAIL); complete_cmd(peer, &cstatus, CMD_FAIL);
goto anchor_unspent; goto anchor_unspent;
@ -556,8 +584,8 @@ enum command_status state(const tal_t *ctx,
add_effect(effect, htlc_fulfill, true); add_effect(effect, htlc_fulfill, true);
change_peer_cond(peer, PEER_BUSY, PEER_CMD_OK); change_peer_cond(peer, PEER_BUSY, PEER_CMD_OK);
/* Toggle between high and low priority states. */ /* Toggle between high and low priority states. */
return next_state(ctx, cstatus, effect, return next_state(peer, cstatus,
toggle_prio(state, STATE_NORMAL)); toggle_prio(peer->state, STATE_NORMAL));
} else if (input_is(input, BITCOIN_ANCHOR_UNSPENT)) { } else if (input_is(input, BITCOIN_ANCHOR_UNSPENT)) {
add_effect(effect, htlc_abandon, true); add_effect(effect, htlc_abandon, true);
goto anchor_unspent; goto anchor_unspent;
@ -590,7 +618,7 @@ enum command_status state(const tal_t *ctx,
add_effect(effect, broadcast_tx, add_effect(effect, broadcast_tx,
bitcoin_close(ctx, peer)); bitcoin_close(ctx, peer));
change_peer_cond(peer, PEER_CLOSING, PEER_CLOSED); change_peer_cond(peer, PEER_CLOSING, PEER_CLOSED);
return next_state(ctx, cstatus, effect, STATE_CLOSE_WAIT_CLOSE); return next_state(peer, cstatus, STATE_CLOSE_WAIT_CLOSE);
} else if (input_is(input, PKT_CLOSE)) { } else if (input_is(input, PKT_CLOSE)) {
/* We can use the sig just like CLOSE_COMPLETE */ /* We can use the sig just like CLOSE_COMPLETE */
err = accept_pkt_simultaneous_close(ctx, peer, err = accept_pkt_simultaneous_close(ctx, peer,
@ -603,15 +631,14 @@ enum command_status state(const tal_t *ctx,
add_effect(effect, broadcast_tx, add_effect(effect, broadcast_tx,
bitcoin_close(ctx, peer)); bitcoin_close(ctx, peer));
set_peer_cond(peer, PEER_CLOSED); set_peer_cond(peer, PEER_CLOSED);
return next_state(ctx, cstatus, effect, STATE_CLOSE_WAIT_CLOSE); return next_state(peer, cstatus, STATE_CLOSE_WAIT_CLOSE);
} else if (input_is(input, PKT_ERROR)) { } else if (input_is(input, PKT_ERROR)) {
add_effect(effect, in_error, add_effect(effect, in_error,
tal_steal(ctx, idata->pkt)); tal_steal(ctx, idata->pkt));
goto start_unilateral_close_already_closing; goto start_unilateral_close_already_closing;
} else if (input_is_pkt(input)) { } else if (input_is_pkt(input)) {
/* We ignore all other packets while closing. */ /* We ignore all other packets while closing. */
return next_state(ctx, cstatus, effect, return unchanged_state(cstatus);
STATE_WAIT_FOR_CLOSE_COMPLETE);
} else if (input_is(input, INPUT_CLOSE_COMPLETE_TIMEOUT)) { } else if (input_is(input, INPUT_CLOSE_COMPLETE_TIMEOUT)) {
/* They didn't respond in time. Unilateral close. */ /* They didn't respond in time. Unilateral close. */
err = pkt_err(ctx, "Close timed out"); err = pkt_err(ctx, "Close timed out");
@ -627,7 +654,7 @@ enum command_status state(const tal_t *ctx,
add_effect(effect, send_pkt, err); add_effect(effect, send_pkt, err);
set_peer_cond(peer, PEER_CLOSED); set_peer_cond(peer, PEER_CLOSED);
/* Just wait for close to happen now. */ /* Just wait for close to happen now. */
return next_state(ctx, cstatus, effect, STATE_CLOSE_WAIT_CLOSE); return next_state(peer, cstatus, STATE_CLOSE_WAIT_CLOSE);
} else if (input_is_pkt(input)) { } else if (input_is_pkt(input)) {
if (input_is(input, PKT_ERROR)) { if (input_is(input, PKT_ERROR)) {
add_effect(effect, in_error, add_effect(effect, in_error,
@ -638,11 +665,11 @@ enum command_status state(const tal_t *ctx,
} }
set_peer_cond(peer, PEER_CLOSED); set_peer_cond(peer, PEER_CLOSED);
/* Just wait for close to happen now. */ /* Just wait for close to happen now. */
return next_state(ctx, cstatus, effect, STATE_CLOSE_WAIT_CLOSE); return next_state(peer, cstatus, STATE_CLOSE_WAIT_CLOSE);
} else if (input_is(input, BITCOIN_CLOSE_DONE)) { } else if (input_is(input, BITCOIN_CLOSE_DONE)) {
/* They didn't ack, but we're closed, so stop. */ /* They didn't ack, but we're closed, so stop. */
set_peer_cond(peer, PEER_CLOSED); set_peer_cond(peer, PEER_CLOSED);
return next_state(ctx, cstatus, effect, STATE_CLOSED); return next_state(peer, cstatus, STATE_CLOSED);
} }
goto fail_during_close; goto fail_during_close;
@ -690,7 +717,7 @@ enum command_status state(const tal_t *ctx,
unsigned int bits; unsigned int bits;
enum state_input closed; enum state_input closed;
bits = STATE_TO_BITS(state); bits = STATE_TO_BITS(peer->state);
/* Once we see a steal or spend completely buried, we /* Once we see a steal or spend completely buried, we
* close unless we're still waiting for htlcs*/ * close unless we're still waiting for htlcs*/
@ -706,21 +733,21 @@ enum command_status state(const tal_t *ctx,
if (bits & STATE_CLOSE_HTLCS_BIT) if (bits & STATE_CLOSE_HTLCS_BIT)
add_effect(effect, unwatch_htlc, add_effect(effect, unwatch_htlc,
htlc_unwatch_all(ctx, peer)); htlc_unwatch_all(ctx, peer));
return next_state(ctx, cstatus, effect, STATE_CLOSED); return next_state(peer, cstatus, STATE_CLOSED);
} }
if ((bits & STATE_CLOSE_SPENDTHEM_BIT) if ((bits & STATE_CLOSE_SPENDTHEM_BIT)
&& input_is(input, BITCOIN_SPEND_THEIRS_DONE)) { && input_is(input, BITCOIN_SPEND_THEIRS_DONE)) {
BUILD_ASSERT(!(STATE_TO_BITS(STATE_CLOSE_WAIT_HTLCS) BUILD_ASSERT(!(STATE_TO_BITS(STATE_CLOSE_WAIT_HTLCS)
& STATE_CLOSE_SPENDTHEM_BIT)); & STATE_CLOSE_SPENDTHEM_BIT));
return next_state(ctx, cstatus, effect, closed); return next_state(peer, cstatus, closed);
} }
if ((bits & STATE_CLOSE_CLOSE_BIT) if ((bits & STATE_CLOSE_CLOSE_BIT)
&& input_is(input, BITCOIN_CLOSE_DONE)) { && input_is(input, BITCOIN_CLOSE_DONE)) {
BUILD_ASSERT(!(STATE_TO_BITS(STATE_CLOSE_WAIT_HTLCS) BUILD_ASSERT(!(STATE_TO_BITS(STATE_CLOSE_WAIT_HTLCS)
& STATE_CLOSE_CLOSE_BIT)); & STATE_CLOSE_CLOSE_BIT));
return next_state(ctx, cstatus, effect, closed); return next_state(peer, cstatus, closed);
} }
if ((bits & STATE_CLOSE_OURCOMMIT_BIT) if ((bits & STATE_CLOSE_OURCOMMIT_BIT)
@ -735,14 +762,14 @@ enum command_status state(const tal_t *ctx,
BITCOIN_SPEND_OURS_DONE)); BITCOIN_SPEND_OURS_DONE));
bits &= ~STATE_CLOSE_OURCOMMIT_BIT; bits &= ~STATE_CLOSE_OURCOMMIT_BIT;
bits |= STATE_CLOSE_SPENDOURS_BIT; bits |= STATE_CLOSE_SPENDOURS_BIT;
return next_state(ctx, cstatus, effect, BITS_TO_STATE(bits)); return next_state(peer, cstatus, BITS_TO_STATE(bits));
} }
if ((bits & STATE_CLOSE_SPENDOURS_BIT) if ((bits & STATE_CLOSE_SPENDOURS_BIT)
&& input_is(input, BITCOIN_SPEND_OURS_DONE)) { && input_is(input, BITCOIN_SPEND_OURS_DONE)) {
BUILD_ASSERT(!(STATE_TO_BITS(STATE_CLOSE_WAIT_HTLCS) BUILD_ASSERT(!(STATE_TO_BITS(STATE_CLOSE_WAIT_HTLCS)
& STATE_CLOSE_SPENDOURS_BIT)); & STATE_CLOSE_SPENDOURS_BIT));
return next_state(ctx, cstatus, effect, closed); return next_state(peer, cstatus, closed);
} }
/* If we have htlcs, we can get other inputs... */ /* If we have htlcs, we can get other inputs... */
@ -751,7 +778,7 @@ enum command_status state(const tal_t *ctx,
/* Clear bit, might lead to STATE_CLOSED. */ /* Clear bit, might lead to STATE_CLOSED. */
BUILD_ASSERT((BITS_TO_STATE(STATE_TO_BITS(STATE_CLOSE_WAIT_HTLCS) & ~STATE_CLOSE_HTLCS_BIT)) == STATE_CLOSED); BUILD_ASSERT((BITS_TO_STATE(STATE_TO_BITS(STATE_CLOSE_WAIT_HTLCS) & ~STATE_CLOSE_HTLCS_BIT)) == STATE_CLOSED);
bits &= ~STATE_CLOSE_HTLCS_BIT; bits &= ~STATE_CLOSE_HTLCS_BIT;
return next_state(ctx, cstatus, effect, return next_state(peer, cstatus,
BITS_TO_STATE(bits)); BITS_TO_STATE(bits));
} else if (input_is(input, BITCOIN_HTLC_TOTHEM_SPENT)) { } else if (input_is(input, BITCOIN_HTLC_TOTHEM_SPENT)) {
/* They revealed R value. */ /* They revealed R value. */
@ -761,7 +788,7 @@ enum command_status state(const tal_t *ctx,
add_effect(effect, unwatch_htlc, add_effect(effect, unwatch_htlc,
htlc_unwatch(ctx, idata->htlc, htlc_unwatch(ctx, idata->htlc,
INPUT_NO_MORE_HTLCS)); INPUT_NO_MORE_HTLCS));
return cstatus; return unchanged_state(cstatus);
} else if (input_is(input, BITCOIN_HTLC_TOTHEM_TIMEOUT)){ } else if (input_is(input, BITCOIN_HTLC_TOTHEM_TIMEOUT)){
tx = bitcoin_htlc_timeout(ctx, tx = bitcoin_htlc_timeout(ctx,
peer, peer,
@ -777,7 +804,7 @@ enum command_status state(const tal_t *ctx,
tx, tx,
idata->cmd, idata->cmd,
BITCOIN_HTLC_RETURN_SPEND_DONE)); BITCOIN_HTLC_RETURN_SPEND_DONE));
return cstatus; return unchanged_state(cstatus);
} else if (input_is(input, INPUT_RVALUE)) { } else if (input_is(input, INPUT_RVALUE)) {
tx = bitcoin_htlc_spend(ctx, peer, tx = bitcoin_htlc_spend(ctx, peer,
idata->htlc); idata->htlc);
@ -798,7 +825,7 @@ enum command_status state(const tal_t *ctx,
add_effect(effect, unwatch_htlc, add_effect(effect, unwatch_htlc,
htlc_unwatch(ctx, idata->htlc, htlc_unwatch(ctx, idata->htlc,
INPUT_NO_MORE_HTLCS)); INPUT_NO_MORE_HTLCS));
return cstatus; return unchanged_state(cstatus);
} else if (input_is(input, BITCOIN_HTLC_FULFILL_SPEND_DONE)) { } else if (input_is(input, BITCOIN_HTLC_FULFILL_SPEND_DONE)) {
/* Stop watching spend, send /* Stop watching spend, send
* INPUT_NO_MORE_HTLCS when done. */ * INPUT_NO_MORE_HTLCS when done. */
@ -806,7 +833,7 @@ enum command_status state(const tal_t *ctx,
htlc_spend_unwatch(ctx, htlc_spend_unwatch(ctx,
idata->htlc, idata->htlc,
INPUT_NO_MORE_HTLCS)); INPUT_NO_MORE_HTLCS));
return cstatus; return unchanged_state(cstatus);
} else if (input_is(input, BITCOIN_HTLC_RETURN_SPEND_DONE)) { } else if (input_is(input, BITCOIN_HTLC_RETURN_SPEND_DONE)) {
/* Stop watching spend, send /* Stop watching spend, send
* INPUT_NO_MORE_HTLCS when done. */ * INPUT_NO_MORE_HTLCS when done. */
@ -820,19 +847,19 @@ enum command_status state(const tal_t *ctx,
add_effect(effect, unwatch_htlc, add_effect(effect, unwatch_htlc,
htlc_unwatch(ctx, idata->htlc, htlc_unwatch(ctx, idata->htlc,
INPUT_NO_MORE_HTLCS)); INPUT_NO_MORE_HTLCS));
return cstatus; return unchanged_state(cstatus);
} else if (input_is(input, BITCOIN_HTLC_TOUS_TIMEOUT)) { } else if (input_is(input, BITCOIN_HTLC_TOUS_TIMEOUT)) {
/* They can spend, we no longer care /* They can spend, we no longer care
* about this HTLC. */ * about this HTLC. */
add_effect(effect, unwatch_htlc, add_effect(effect, unwatch_htlc,
htlc_unwatch(ctx, idata->htlc, htlc_unwatch(ctx, idata->htlc,
INPUT_NO_MORE_HTLCS)); INPUT_NO_MORE_HTLCS));
return cstatus; return unchanged_state(cstatus);
} }
} }
/* If we're just waiting for HTLCs, anything else is an error */ /* If we're just waiting for HTLCs, anything else is an error */
if (state == STATE_CLOSE_WAIT_HTLCS) if (peer->state == STATE_CLOSE_WAIT_HTLCS)
break; break;
/* /*
@ -856,21 +883,19 @@ enum command_status state(const tal_t *ctx,
bits |= STATE_CLOSE_HTLCS_BIT; bits |= STATE_CLOSE_HTLCS_BIT;
} }
bits |= STATE_CLOSE_SPENDTHEM_BIT; bits |= STATE_CLOSE_SPENDTHEM_BIT;
return next_state(ctx, cstatus, effect, return next_state_bits(peer, cstatus, bits);
BITS_TO_STATE(bits));
/* This can happen multiple times: need to steal ALL */ /* This can happen multiple times: need to steal ALL */
} else if (input_is(input, BITCOIN_ANCHOR_OTHERSPEND)) { } else if (input_is(input, BITCOIN_ANCHOR_OTHERSPEND)) {
tx = bitcoin_steal(ctx, peer, idata->btc); tx = bitcoin_steal(ctx, peer, idata->btc);
if (!tx) if (!tx)
return next_state(ctx, cstatus, effect, return next_state(peer, cstatus,
STATE_ERR_INFORMATION_LEAK); STATE_ERR_INFORMATION_LEAK);
add_effect(effect, broadcast_tx, tx); add_effect(effect, broadcast_tx, tx);
add_effect(effect, watch, add_effect(effect, watch,
bitcoin_watch(ctx, tx, bitcoin_watch(ctx, tx,
BITCOIN_STEAL_DONE)); BITCOIN_STEAL_DONE));
bits |= STATE_CLOSE_STEAL_BIT; bits |= STATE_CLOSE_STEAL_BIT;
return next_state(ctx, cstatus, effect, return next_state_bits(peer, cstatus, bits);
BITS_TO_STATE(bits));
} else if (input_is(input, BITCOIN_ANCHOR_UNSPENT)) } else if (input_is(input, BITCOIN_ANCHOR_UNSPENT))
goto anchor_unspent; goto anchor_unspent;
@ -891,11 +916,11 @@ enum command_status state(const tal_t *ctx,
case STATE_UNUSED_CLOSE_WAIT_STEAL_CLOSE_OURCOMMIT_WITH_HTLCS: case STATE_UNUSED_CLOSE_WAIT_STEAL_CLOSE_OURCOMMIT_WITH_HTLCS:
case STATE_UNUSED_CLOSE_WAIT_CLOSE_SPENDOURS_WITH_HTLCS: case STATE_UNUSED_CLOSE_WAIT_CLOSE_SPENDOURS_WITH_HTLCS:
case STATE_UNUSED_CLOSE_WAIT_STEAL_CLOSE_SPENDOURS_WITH_HTLCS: case STATE_UNUSED_CLOSE_WAIT_STEAL_CLOSE_SPENDOURS_WITH_HTLCS:
return next_state(ctx, cstatus, effect, STATE_ERR_INTERNAL); return next_state(peer, cstatus, STATE_ERR_INTERNAL);
} }
/* State machine should handle all possible states. */ /* State machine should handle all possible states. */
return next_state(ctx, cstatus, effect, STATE_ERR_INTERNAL); return next_state(peer, cstatus, STATE_ERR_INTERNAL);
unexpected_pkt: unexpected_pkt:
/* /*
@ -922,7 +947,7 @@ anchor_unspent:
* then we're malfunctioning. If they double-spent it, then they * then we're malfunctioning. If they double-spent it, then they
* managed to cheat us: post_to_reddit(); * managed to cheat us: post_to_reddit();
*/ */
return next_state(ctx, cstatus, effect, STATE_ERR_ANCHOR_LOST); return next_state(peer, cstatus, STATE_ERR_ANCHOR_LOST);
err_close_nocleanup: err_close_nocleanup:
/* /*
@ -931,7 +956,7 @@ err_close_nocleanup:
*/ */
add_effect(effect, send_pkt, err); add_effect(effect, send_pkt, err);
change_peer_cond(peer, PEER_CMD_OK, PEER_CLOSED); change_peer_cond(peer, PEER_CMD_OK, PEER_CLOSED);
return next_state(ctx, cstatus, effect, STATE_CLOSED); return next_state(peer, cstatus, STATE_CLOSED);
err_start_unilateral_close: err_start_unilateral_close:
/* /*
@ -958,10 +983,10 @@ start_unilateral_close:
BITCOIN_HTLC_TOTHEM_TIMEOUT); BITCOIN_HTLC_TOTHEM_TIMEOUT);
if (htlcs) { if (htlcs) {
add_effect(effect, watch_htlcs, htlcs); add_effect(effect, watch_htlcs, htlcs);
return next_state(ctx, cstatus, effect, return next_state(peer, cstatus,
STATE_CLOSE_WAIT_OURCOMMIT_WITH_HTLCS); STATE_CLOSE_WAIT_OURCOMMIT_WITH_HTLCS);
} }
return next_state(ctx, cstatus, effect, STATE_CLOSE_WAIT_OURCOMMIT); return next_state(peer, cstatus, STATE_CLOSE_WAIT_OURCOMMIT);
err_start_unilateral_close_already_closing: err_start_unilateral_close_already_closing:
/* /*
@ -983,9 +1008,9 @@ start_unilateral_close_already_closing:
/* We agreed to close: shouldn't have any HTLCs */ /* We agreed to close: shouldn't have any HTLCs */
if (committed_to_htlcs(peer)) if (committed_to_htlcs(peer))
return next_state(ctx, cstatus, effect, STATE_ERR_INTERNAL); return next_state(peer, cstatus, STATE_ERR_INTERNAL);
return next_state(ctx, cstatus, effect, STATE_CLOSE_WAIT_CLOSE_OURCOMMIT); return next_state(peer, cstatus, STATE_CLOSE_WAIT_CLOSE_OURCOMMIT);
them_unilateral: them_unilateral:
assert(input == BITCOIN_ANCHOR_THEIRSPEND); assert(input == BITCOIN_ANCHOR_THEIRSPEND);
@ -1011,10 +1036,10 @@ them_unilateral:
BITCOIN_HTLC_TOTHEM_TIMEOUT); BITCOIN_HTLC_TOTHEM_TIMEOUT);
if (htlcs) { if (htlcs) {
add_effect(effect, watch_htlcs, htlcs); add_effect(effect, watch_htlcs, htlcs);
return next_state(ctx, cstatus, effect, return next_state(peer, cstatus,
STATE_CLOSE_WAIT_SPENDTHEM_WITH_HTLCS); STATE_CLOSE_WAIT_SPENDTHEM_WITH_HTLCS);
} }
return next_state(ctx, cstatus, effect, STATE_CLOSE_WAIT_SPENDTHEM); return next_state(peer, cstatus, STATE_CLOSE_WAIT_SPENDTHEM);
accept_htlc_update: accept_htlc_update:
err = accept_pkt_htlc_update(ctx, peer, idata->pkt, &decline, &htlcprog, err = accept_pkt_htlc_update(ctx, peer, idata->pkt, &decline, &htlcprog,
@ -1025,13 +1050,14 @@ accept_htlc_update:
add_effect(effect, send_pkt, decline); add_effect(effect, send_pkt, decline);
/* No update means no priority change. */ /* No update means no priority change. */
change_peer_cond(peer, PEER_BUSY, PEER_CMD_OK); change_peer_cond(peer, PEER_BUSY, PEER_CMD_OK);
return next_state(ctx, cstatus, effect, /* We may already be in STATE_NORMAL */
prio(state, STATE_NORMAL)); return next_state_nocheck(peer, cstatus,
prio(peer->state, STATE_NORMAL));
} }
add_effect(effect, htlc_in_progress, htlcprog); add_effect(effect, htlc_in_progress, htlcprog);
add_effect(effect, send_pkt, pkt_update_accept(ctx, peer)); add_effect(effect, send_pkt, pkt_update_accept(ctx, peer));
return next_state(ctx, cstatus, effect, return next_state(peer, cstatus,
prio(state, STATE_WAIT_FOR_UPDATE_SIG)); prio(peer->state, STATE_WAIT_FOR_UPDATE_SIG));
accept_htlc_routefail: accept_htlc_routefail:
err = accept_pkt_htlc_routefail(ctx, peer, idata->pkt, &htlcprog, err = accept_pkt_htlc_routefail(ctx, peer, idata->pkt, &htlcprog,
@ -1040,8 +1066,8 @@ accept_htlc_routefail:
goto err_start_unilateral_close; goto err_start_unilateral_close;
add_effect(effect, htlc_in_progress, htlcprog); add_effect(effect, htlc_in_progress, htlcprog);
add_effect(effect, send_pkt, pkt_update_accept(ctx, peer)); add_effect(effect, send_pkt, pkt_update_accept(ctx, peer));
return next_state(ctx, cstatus, effect, return next_state(peer, cstatus,
prio(state, STATE_WAIT_FOR_UPDATE_SIG)); prio(peer->state, STATE_WAIT_FOR_UPDATE_SIG));
accept_htlc_timedout: accept_htlc_timedout:
err = accept_pkt_htlc_timedout(ctx, peer, idata->pkt, &htlcprog, err = accept_pkt_htlc_timedout(ctx, peer, idata->pkt, &htlcprog,
@ -1050,8 +1076,8 @@ accept_htlc_timedout:
goto err_start_unilateral_close; goto err_start_unilateral_close;
add_effect(effect, htlc_in_progress, htlcprog); add_effect(effect, htlc_in_progress, htlcprog);
add_effect(effect, send_pkt, pkt_update_accept(ctx, peer)); add_effect(effect, send_pkt, pkt_update_accept(ctx, peer));
return next_state(ctx, cstatus, effect, return next_state(peer, cstatus,
prio(state, STATE_WAIT_FOR_UPDATE_SIG)); prio(peer->state, STATE_WAIT_FOR_UPDATE_SIG));
accept_htlc_fulfill: accept_htlc_fulfill:
err = accept_pkt_htlc_fulfill(ctx, peer, idata->pkt, &htlcprog, err = accept_pkt_htlc_fulfill(ctx, peer, idata->pkt, &htlcprog,
@ -1061,8 +1087,8 @@ accept_htlc_fulfill:
add_effect(effect, htlc_in_progress, htlcprog); add_effect(effect, htlc_in_progress, htlcprog);
add_effect(effect, send_pkt, pkt_update_accept(ctx, peer)); add_effect(effect, send_pkt, pkt_update_accept(ctx, peer));
add_effect(effect, r_value, r_value_from_pkt(ctx, idata->pkt)); add_effect(effect, r_value, r_value_from_pkt(ctx, idata->pkt));
return next_state(ctx, cstatus, effect, return next_state(peer, cstatus,
prio(state, STATE_WAIT_FOR_UPDATE_SIG)); prio(peer->state, STATE_WAIT_FOR_UPDATE_SIG));
start_closing: start_closing:
/* /*
@ -1083,7 +1109,7 @@ start_closing:
/* As soon as we send packet, they could close. */ /* As soon as we send packet, they could close. */
add_effect(effect, send_pkt, pkt_close(ctx, peer)); add_effect(effect, send_pkt, pkt_close(ctx, peer));
return next_state(ctx, cstatus, effect, STATE_WAIT_FOR_CLOSE_COMPLETE); return next_state(peer, cstatus, STATE_WAIT_FOR_CLOSE_COMPLETE);
accept_closing: accept_closing:
err = accept_pkt_close(ctx, peer, idata->pkt, effect); err = accept_pkt_close(ctx, peer, idata->pkt, effect);
@ -1095,7 +1121,7 @@ accept_closing:
add_effect(effect, send_pkt, pkt_close_complete(ctx, peer)); add_effect(effect, send_pkt, pkt_close_complete(ctx, peer));
/* No more commands, we're already closing. */ /* No more commands, we're already closing. */
set_peer_cond(peer, PEER_CLOSING); set_peer_cond(peer, PEER_CLOSING);
return next_state(ctx, cstatus, effect, STATE_WAIT_FOR_CLOSE_ACK); return next_state(peer, cstatus, STATE_WAIT_FOR_CLOSE_ACK);
instant_close: instant_close:
/* /*
@ -1107,8 +1133,8 @@ instant_close:
/* We can't have any HTLCs, since we haven't started. */ /* We can't have any HTLCs, since we haven't started. */
if (committed_to_htlcs(peer)) if (committed_to_htlcs(peer))
return next_state(ctx, cstatus, effect, STATE_ERR_INTERNAL); return next_state(peer, cstatus, STATE_ERR_INTERNAL);
return next_state(ctx, cstatus, effect, STATE_CLOSED); return next_state(peer, cstatus, STATE_CLOSED);
fail_during_close: fail_during_close:
/* /*
@ -1119,7 +1145,7 @@ fail_during_close:
/* Once close tx is deep enough, we consider it done. */ /* Once close tx is deep enough, we consider it done. */
if (input_is(input, BITCOIN_CLOSE_DONE)) { if (input_is(input, BITCOIN_CLOSE_DONE)) {
return next_state(ctx, cstatus, effect, STATE_CLOSED); return next_state(peer, cstatus, STATE_CLOSED);
} else if (input_is(input, BITCOIN_ANCHOR_THEIRSPEND)) { } else if (input_is(input, BITCOIN_ANCHOR_THEIRSPEND)) {
/* A reorganization could make this happen. */ /* A reorganization could make this happen. */
tx = bitcoin_spend_theirs(ctx, peer, idata->btc); tx = bitcoin_spend_theirs(ctx, peer, idata->btc);
@ -1136,26 +1162,26 @@ fail_during_close:
/* FIXME: Make sure caller uses INPUT_RVAL /* FIXME: Make sure caller uses INPUT_RVAL
* if they were in the middle of FULFILL! */ * if they were in the middle of FULFILL! */
add_effect(effect, watch_htlcs, htlcs); add_effect(effect, watch_htlcs, htlcs);
return next_state(ctx, cstatus, effect, return next_state(peer, cstatus,
STATE_CLOSE_WAIT_SPENDTHEM_CLOSE_WITH_HTLCS); STATE_CLOSE_WAIT_SPENDTHEM_CLOSE_WITH_HTLCS);
} }
return next_state(ctx, cstatus, effect, return next_state(peer, cstatus,
STATE_CLOSE_WAIT_SPENDTHEM_CLOSE); STATE_CLOSE_WAIT_SPENDTHEM_CLOSE);
} else if (input_is(input, BITCOIN_ANCHOR_OTHERSPEND)) { } else if (input_is(input, BITCOIN_ANCHOR_OTHERSPEND)) {
tx = bitcoin_steal(ctx, peer, idata->btc); tx = bitcoin_steal(ctx, peer, idata->btc);
if (!tx) if (!tx)
return next_state(ctx, cstatus, effect, return next_state(peer, cstatus,
STATE_ERR_INFORMATION_LEAK); STATE_ERR_INFORMATION_LEAK);
add_effect(effect, broadcast_tx, tx); add_effect(effect, broadcast_tx, tx);
add_effect(effect, watch, add_effect(effect, watch,
bitcoin_watch(ctx, tx, BITCOIN_STEAL_DONE)); bitcoin_watch(ctx, tx, BITCOIN_STEAL_DONE));
/* Expect either close or steal to complete */ /* Expect either close or steal to complete */
return next_state(ctx, cstatus, effect, return next_state(peer, cstatus,
STATE_CLOSE_WAIT_STEAL_CLOSE); STATE_CLOSE_WAIT_STEAL_CLOSE);
} else if (input_is(input, BITCOIN_ANCHOR_UNSPENT)) { } else if (input_is(input, BITCOIN_ANCHOR_UNSPENT)) {
return next_state(ctx, cstatus, effect, STATE_ERR_ANCHOR_LOST); return next_state(peer, cstatus, STATE_ERR_ANCHOR_LOST);
} }
return next_state(ctx, cstatus, effect, STATE_ERR_INTERNAL); return next_state(peer, cstatus, STATE_ERR_INTERNAL);
old_commit_spotted: old_commit_spotted:
/* /*
@ -1169,10 +1195,10 @@ old_commit_spotted:
/* If we can't find it, we're lost. */ /* If we can't find it, we're lost. */
tx = bitcoin_steal(ctx, peer, idata->btc); tx = bitcoin_steal(ctx, peer, idata->btc);
if (!tx) if (!tx)
return next_state(ctx, cstatus, effect, return next_state(peer, cstatus,
STATE_ERR_INFORMATION_LEAK); STATE_ERR_INFORMATION_LEAK);
add_effect(effect, broadcast_tx, tx); add_effect(effect, broadcast_tx, tx);
add_effect(effect, watch, add_effect(effect, watch,
bitcoin_watch(ctx, tx, BITCOIN_STEAL_DONE)); bitcoin_watch(ctx, tx, BITCOIN_STEAL_DONE));
return next_state(ctx, cstatus, effect, STATE_CLOSE_WAIT_STEAL); return next_state(peer, cstatus, STATE_CLOSE_WAIT_STEAL);
} }

5
state.h
View File

@ -18,7 +18,6 @@ enum state_peercond {
}; };
enum state_effect_type { enum state_effect_type {
STATE_EFFECT_new_state,
STATE_EFFECT_in_error, STATE_EFFECT_in_error,
STATE_EFFECT_broadcast_tx, STATE_EFFECT_broadcast_tx,
STATE_EFFECT_send_pkt, STATE_EFFECT_send_pkt,
@ -49,9 +48,6 @@ struct state_effect {
enum state_effect_type etype; enum state_effect_type etype;
union { union {
/* New state to enter. */
enum state new_state;
/* Transaction to broadcast. */ /* Transaction to broadcast. */
struct bitcoin_tx *broadcast_tx; struct bitcoin_tx *broadcast_tx;
@ -131,7 +127,6 @@ enum command_status {
}; };
enum command_status state(const tal_t *ctx, enum command_status state(const tal_t *ctx,
const enum state state,
struct peer *peer, struct peer *peer,
const enum state_input input, const enum state_input input,
const union input *idata, const union input *idata,

79
test/test_state_coverage.c
View File

@ -87,13 +87,13 @@ struct core_state {
/* What bitcoin/timeout notifications are we subscribed to? */ /* What bitcoin/timeout notifications are we subscribed to? */
uint64_t event_notifies; uint64_t event_notifies;
enum state state;
enum state_input current_command; enum state_input current_command;
enum state_input outputs[MAX_OUTQ]; enum state_input outputs[MAX_OUTQ];
uint8_t num_outputs; uint8_t num_outputs;
/* Here down need to be generated from other fields */ /* Here down need to be generated from other fields */
uint8_t state;
uint8_t peercond; uint8_t peercond;
bool has_current_htlc; bool has_current_htlc;
@ -105,12 +105,13 @@ struct core_state {
uint8_t capped_live_htlcs_to_them; uint8_t capped_live_htlcs_to_them;
uint8_t capped_live_htlcs_to_us; uint8_t capped_live_htlcs_to_us;
bool valid; bool valid;
bool pad[2]; bool pad[5];
}; };
struct peer { struct peer {
struct core_state core; struct core_state core;
enum state state;
enum state_peercond cond; enum state_peercond cond;
/* To store HTLC numbers. */ /* To store HTLC numbers. */
@ -316,6 +317,8 @@ static void update_core(struct core_state *core, const struct peer *peer)
assert(core->outputs[i] == 0); assert(core->outputs[i] == 0);
core->has_current_htlc = peer->current_htlc.htlc.id != -1; core->has_current_htlc = peer->current_htlc.htlc.id != -1;
core->state = peer->state;
BUILD_ASSERT(STATE_MAX < 256);
core->peercond = peer->cond; core->peercond = peer->cond;
core->capped_htlcs_to_us = cap(peer->num_htlcs_to_us); core->capped_htlcs_to_us = cap(peer->num_htlcs_to_us);
core->capped_htlcs_to_them = cap(peer->num_htlcs_to_them); core->capped_htlcs_to_them = cap(peer->num_htlcs_to_them);
@ -1171,7 +1174,7 @@ static void peer_init(struct peer *peer,
const char *name) const char *name)
{ {
peer->cond = PEER_CMD_OK; peer->cond = PEER_CMD_OK;
peer->core.state = STATE_INIT; peer->state = STATE_INIT;
peer->core.num_outputs = 0; peer->core.num_outputs = 0;
peer->current_htlc.htlc.id = -1; peer->current_htlc.htlc.id = -1;
peer->num_htlcs_to_us = 0; peer->num_htlcs_to_us = 0;
@ -1245,8 +1248,8 @@ static void report_trail_rev(const struct trail *t)
fprintf(stderr, "%s: %s(%i) %s -> %s", fprintf(stderr, "%s: %s(%i) %s -> %s",
t->name, t->name,
input_name(t->input), t->htlc_id, input_name(t->input), t->htlc_id,
state_name(t->before->core.state), state_name(t->before->state),
t->after ? state_name(t->after->core.state) : "<unknown>"); t->after ? state_name(t->after->state) : "<unknown>");
if (t->after) { if (t->after) {
for (i = 0; i < t->after->core.num_outputs; i++) for (i = 0; i < t->after->core.num_outputs; i++)
fprintf(stderr, " >%s", fprintf(stderr, " >%s",
@ -1257,7 +1260,7 @@ static void report_trail_rev(const struct trail *t)
if (!t->after) if (!t->after)
goto pkt_sent; goto pkt_sent;
if (t->after->core.state >= STATE_CLOSED) { if (t->after->state >= STATE_CLOSED) {
if (t->after->num_live_htlcs_to_us if (t->after->num_live_htlcs_to_us
|| t->after->num_live_htlcs_to_them) { || t->after->num_live_htlcs_to_them) {
fprintf(stderr, " Live HTLCs:"); fprintf(stderr, " Live HTLCs:");
@ -1406,9 +1409,6 @@ static const char *apply_effects(struct peer *peer,
*effects |= (1ULL << effect->etype); *effects |= (1ULL << effect->etype);
switch (effect->etype) { switch (effect->etype) {
case STATE_EFFECT_new_state:
peer->core.state = effect->u.new_state;
break;
case STATE_EFFECT_in_error: case STATE_EFFECT_in_error:
break; break;
case STATE_EFFECT_broadcast_tx: case STATE_EFFECT_broadcast_tx:
@ -1660,7 +1660,7 @@ static const char *apply_all_effects(const struct peer *old,
assert(peer->core.current_command != INPUT_NONE); assert(peer->core.current_command != INPUT_NONE);
/* We should only requeue HTLCs if we're lowprio */ /* We should only requeue HTLCs if we're lowprio */
if (cstatus == CMD_REQUEUE) if (cstatus == CMD_REQUEUE)
assert(!high_priority(old->core.state) assert(!high_priority(old->state)
&& input_is(peer->core.current_command, && input_is(peer->core.current_command,
CMD_SEND_UPDATE_ANY)); CMD_SEND_UPDATE_ANY));
peer->core.current_command = INPUT_NONE; peer->core.current_command = INPUT_NONE;
@ -1872,15 +1872,6 @@ static struct state_effect *get_effect(const struct state_effect *effect,
return cast_const(struct state_effect *, effect); return cast_const(struct state_effect *, effect);
} }
static enum state get_state_effect(const struct state_effect *effect,
enum state current)
{
effect = get_effect(effect, STATE_EFFECT_new_state);
if (effect)
return effect->u.new_state;
return current;
}
static Pkt *get_send_pkt(const struct state_effect *effect) static Pkt *get_send_pkt(const struct state_effect *effect)
{ {
effect = get_effect(effect, STATE_EFFECT_send_pkt); effect = get_effect(effect, STATE_EFFECT_send_pkt);
@ -1898,7 +1889,6 @@ static void try_input(const struct peer *peer,
{ {
struct peer copy, other; struct peer copy, other;
struct trail t; struct trail t;
enum state newstate;
struct state_effect *effect; struct state_effect *effect;
const char *problem; const char *problem;
Pkt *output; Pkt *output;
@ -1912,27 +1902,25 @@ static void try_input(const struct peer *peer,
init_trail(&t, i, idata, peer, prev_trail); init_trail(&t, i, idata, peer, prev_trail);
copy.trail = &t; copy.trail = &t;
eliminate_input(&hist->inputs_per_state[copy.core.state], i); eliminate_input(&hist->inputs_per_state[copy.state], i);
cstatus = state(ctx, copy.core.state, &copy, i, idata, &effect); cstatus = state(ctx, &copy, i, idata, &effect);
newstate = get_state_effect(effect, peer->core.state); normalpath &= normal_path(i, peer->state, copy.state);
errorpath |= error_path(i, peer->state, copy.state);
normalpath &= normal_path(i, peer->core.state, newstate);
errorpath |= error_path(i, peer->core.state, newstate);
if (dot_enable if (dot_enable
&& (dot_include_abnormal || normalpath) && (dot_include_abnormal || normalpath)
&& (dot_include_errors || !errorpath) && (dot_include_errors || !errorpath)
&& (dot_include_abnormal || !too_cluttered(i, peer->core.state))) { && (dot_include_abnormal || !too_cluttered(i, peer->state))) {
const char *oldstr, *newstr; const char *oldstr, *newstr;
/* Simplify folds high and low prio, skip "STATE_" */ /* Simplify folds high and low prio, skip "STATE_" */
if (dot_simplify) { if (dot_simplify) {
oldstr = simplify_state(peer->core.state) + 6; oldstr = simplify_state(peer->state) + 6;
newstr = simplify_state(newstate) + 6; newstr = simplify_state(copy.state) + 6;
} else { } else {
oldstr = state_name(peer->core.state) + 6; oldstr = state_name(peer->state) + 6;
newstr = state_name(newstate) + 6; newstr = state_name(copy.state) + 6;
} }
if (newstr != oldstr || include_nops) if (newstr != oldstr || include_nops)
add_dot(&hist->edges, oldstr, newstr, i, add_dot(&hist->edges, oldstr, newstr, i,
@ -1944,9 +1932,9 @@ static void try_input(const struct peer *peer,
if (problem) if (problem)
report_trail(&t, problem); report_trail(&t, problem);
if (newstate == STATE_ERR_INTERNAL) if (copy.state == STATE_ERR_INTERNAL)
report_trail(&t, "Internal error"); report_trail(&t, "Internal error");
if (strstarts(state_name(newstate), "STATE_UNUSED")) if (strstarts(state_name(copy.state), "STATE_UNUSED"))
report_trail(&t, "Unused state"); report_trail(&t, "Unused state");
@ -1957,7 +1945,7 @@ static void try_input(const struct peer *peer,
} }
if (hist->state_dump) { if (hist->state_dump) {
record_state(&hist->state_dump[peer->core.state], i, newstate, record_state(&hist->state_dump[peer->state], i, copy.state,
(const char *)output); (const char *)output);
} }
@ -1973,8 +1961,8 @@ static void try_input(const struct peer *peer,
*/ */
if (quick if (quick
|| cstatus == CMD_REQUEUE || cstatus == CMD_REQUEUE
|| newstate == STATE_NORMAL_LOWPRIO || copy.state == STATE_NORMAL_LOWPRIO
|| newstate == STATE_NORMAL_HIGHPRIO || copy.state == STATE_NORMAL_HIGHPRIO
|| i == BITCOIN_ANCHOR_OTHERSPEND || i == BITCOIN_ANCHOR_OTHERSPEND
|| i == BITCOIN_ANCHOR_THEIRSPEND || i == BITCOIN_ANCHOR_THEIRSPEND
|| quick) { || quick) {
@ -1986,7 +1974,7 @@ static void try_input(const struct peer *peer,
} }
/* Don't continue if we reached a different error state. */ /* Don't continue if we reached a different error state. */
if (state_is_error(newstate)) { if (state_is_error(copy.state)) {
tal_free(ctx); tal_free(ctx);
return; return;
} }
@ -1996,12 +1984,12 @@ static void try_input(const struct peer *peer,
*/ */
if (copy.cond != PEER_CLOSED if (copy.cond != PEER_CLOSED
&& !has_packets(&copy) && !has_packets(&other) && !has_packets(&copy) && !has_packets(&other)
&& !waiting_statepair(copy.core.state, other.core.state)) { && !waiting_statepair(copy.state, other.state)) {
report_trail(&t, "Deadlock"); report_trail(&t, "Deadlock");
} }
/* Finished? */ /* Finished? */
if (newstate == STATE_CLOSED) { if (copy.state == STATE_CLOSED) {
if (copy.cond != PEER_CLOSED) if (copy.cond != PEER_CLOSED)
report_trail(&t, "CLOSED but cond not CLOSED"); report_trail(&t, "CLOSED but cond not CLOSED");
@ -2029,12 +2017,12 @@ static void try_input(const struct peer *peer,
static void sanity_check(const struct peer *peer) static void sanity_check(const struct peer *peer)
{ {
if (peer->core.state == STATE_NORMAL_LOWPRIO if (peer->state == STATE_NORMAL_LOWPRIO
|| peer->core.state == STATE_NORMAL_HIGHPRIO) { || peer->state == STATE_NORMAL_HIGHPRIO) {
/* Home state: expect commands to be finished. */ /* Home state: expect commands to be finished. */
if (peer->core.current_command != INPUT_NONE) if (peer->core.current_command != INPUT_NONE)
errx(1, "Unexpected command %u in state %u", errx(1, "Unexpected command %u in state %u",
peer->core.current_command, peer->core.state); peer->core.current_command, peer->state);
} }
} }
@ -2120,7 +2108,7 @@ static void run_peer(const struct peer *peer,
copy_peers(&copy, &other, peer); copy_peers(&copy, &other, peer);
/* If in init state, we can only send start command. */ /* If in init state, we can only send start command. */
if (peer->core.state == STATE_INIT) { if (peer->state == STATE_INIT) {
if (streq(peer->name, "A")) if (streq(peer->name, "A"))
copy.core.current_command = CMD_OPEN_WITH_ANCHOR; copy.core.current_command = CMD_OPEN_WITH_ANCHOR;
else else
@ -2148,7 +2136,7 @@ static void run_peer(const struct peer *peer,
/* We can send a close command even if already sending a /* We can send a close command even if already sending a
* (different) command. */ * (different) command. */
if (peer->core.state != STATE_INIT if (peer->state != STATE_INIT
&& (peer->cond == PEER_CMD_OK && (peer->cond == PEER_CMD_OK
|| peer->cond == PEER_BUSY)) { || peer->cond == PEER_BUSY)) {
try_input(&copy, CMD_CLOSE, idata, try_input(&copy, CMD_CLOSE, idata,
@ -2304,7 +2292,8 @@ static enum state_input **map_inputs(void)
struct peer dummy; struct peer dummy;
struct state_effect *effect; struct state_effect *effect;
memset(&dummy, 0, sizeof(dummy)); memset(&dummy, 0, sizeof(dummy));
state(ctx, i, &dummy, INPUT_NONE, NULL, &effect); dummy.state = i;
state(ctx, &dummy, INPUT_NONE, NULL, &effect);
} }
inps[i] = mapping_inputs; inps[i] = mapping_inputs;
} }