vincenzopalazzo
/
rgb-cln
1
0
Fork 0
Code Issues 1 Pull Requests Packages Projects Releases Wiki Activity

subd: keep pointer to channel, not peer. 

This rolls through many other functions, making them take channel not peer.

Signed-off-by: Rusty Russell <rusty@rustcorp.com.au>
This commit is contained in:
Rusty Russell 2018-02-12 20:43:04 +10:30 committed by Christian Decker
parent b7680412e3
commit 409fef582d
10 changed files with 291 additions and 277 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

21
lightningd/channel.c
View File

@ -15,7 +15,7 @@ void channel_set_owner(struct channel *channel, struct subd *owner)
channel->owner = owner;
if (old_owner)
subd_release_peer(old_owner, channel2peer(channel));
subd_release_channel(old_owner, channel);
}
static void destroy_channel(struct channel *channel)
@ -112,6 +112,25 @@ struct channel *peer_active_channel(struct peer *peer)
return NULL;
}
void channel_set_state(struct channel *channel,
enum peer_state old_state,
enum peer_state state)
{
log_info(channel->log, "State changed from %s to %s",
channel_state_name(channel), peer_state_name(state));
if (channel->state != old_state)
fatal("channel state %s should be %s",
channel_state_name(channel), peer_state_name(old_state));
channel->state = state;
/* We only persist channels/peers that have reached the opening state */
if (channel_persists(channel)) {
/* TODO(cdecker) Selectively save updated fields to DB */
wallet_channel_save(channel->peer->ld->wallet, channel);
}
}
struct channel *peer2channel(const struct peer *peer)
{
return list_top(&peer->channels, struct channel, list);

4
lightningd/channel.h
View File

@ -105,6 +105,10 @@ void channel_fail_permanent(struct channel *channel, const char *fmt, ...);
/* Permanent error, but due to internal problems, not peer. */
void channel_internal_error(struct channel *channel, const char *fmt, ...);
void channel_set_state(struct channel *channel,
enum peer_state old_state,
enum peer_state state);
/* FIXME: Temporary mapping from peer to channel, while we only have one. */
struct channel *peer2channel(const struct peer *peer);
struct peer *channel2peer(const struct channel *channel);

300
lightningd/peer_control.c
View File

@ -75,7 +75,7 @@ static bool peer_start_channeld(struct peer *peer,
int peer_fd, int gossip_fd,
const u8 *funding_signed,
bool reconnected);
static void peer_start_closingd(struct peer *peer,
static void peer_start_closingd(struct channel *channel,
struct crypto_state *cs,
u64 gossip_index,
int peer_fd, int gossip_fd,
@ -146,6 +146,7 @@ struct peer *new_peer(struct lightningd *ld, u64 dbid,
/* Max 128k per peer. */
peer->log_book = new_log_book(peer, 128*1024,
get_log_level(ld->log_book));
/* FIXME: Use minimal unique pubkey prefix for logs! */
idname = type_to_string(peer, struct pubkey, id);
peer->log = new_log(peer, peer->log_book, "peer %s:", idname);
tal_free(idname);
@ -221,20 +222,7 @@ void peer_set_condition(struct peer *peer, enum peer_state old_state,
{
struct channel *channel = peer2channel(peer);
log_info(peer->log, "State changed from %s to %s",
channel_state_name(channel), peer_state_name(state));
if (channel->state != old_state)
fatal("peer state %s should be %s",
channel_state_name(channel), peer_state_name(old_state));
channel->state = state;
/* We only persist channels/peers that have reached the opening state */
if (peer_persists(peer)) {
assert(channel != NULL);
/* TODO(cdecker) Selectively save updated fields to DB */
wallet_channel_save(peer->ld->wallet, channel);
}
channel_set_state(channel, old_state, state);
}
static void destroy_connect(struct connect *c)
@ -429,7 +417,7 @@ void peer_connected(struct lightningd *ld, const u8 *msg,
peer_set_owner(peer, NULL);
peer->addr = addr;
peer_start_closingd(peer, &cs, gossip_index,
peer_start_closingd(channel, &cs, gossip_index,
peer_fd, gossip_fd,
true);
goto connected;
@ -889,17 +877,17 @@ static enum watch_result funding_announce_cb(struct peer *peer,
/* We dump all the known preimages when onchaind starts up. */
static void onchaind_tell_fulfill(struct peer *peer)
static void onchaind_tell_fulfill(struct channel *channel)
{
struct htlc_in_map_iter ini;
struct htlc_in *hin;
u8 *msg;
struct channel *channel = peer2channel(peer);
struct lightningd *ld = channel->peer->ld;
for (hin = htlc_in_map_first(&peer->ld->htlcs_in, &ini);
for (hin = htlc_in_map_first(&ld->htlcs_in, &ini);
hin;
hin = htlc_in_map_next(&peer->ld->htlcs_in, &ini)) {
if (hin->key.peer != peer)
hin = htlc_in_map_next(&ld->htlcs_in, &ini)) {
if (hin->key.peer != channel2peer(channel))
continue;
/* BOLT #5:
@ -918,15 +906,14 @@ static void onchaind_tell_fulfill(struct peer *peer)
if (!hin->preimage)
continue;
msg = towire_onchain_known_preimage(peer, hin->preimage);
msg = towire_onchain_known_preimage(channel, hin->preimage);
subd_send_msg(channel->owner, take(msg));
}
}
static void handle_onchain_init_reply(struct peer *peer, const u8 *msg)
static void handle_onchain_init_reply(struct channel *channel, const u8 *msg)
{
u8 state;
struct channel *channel = peer2channel(peer);
if (!fromwire_onchain_init_reply(msg, NULL, &state)) {
channel_internal_error(channel, "Invalid onchain_init_reply");
@ -940,10 +927,10 @@ static void handle_onchain_init_reply(struct peer *peer, const u8 *msg)
return;
}
peer_set_condition(peer, FUNDING_SPEND_SEEN, state);
channel_set_state(channel, FUNDING_SPEND_SEEN, state);
/* Tell it about any preimages we know. */
onchaind_tell_fulfill(peer);
onchaind_tell_fulfill(channel);
}
static enum watch_result onchain_tx_watched(struct peer *peer,
@ -1013,10 +1000,9 @@ static void watch_tx_and_outputs(struct peer *peer,
onchain_txo_watched, NULL);
}
static void handle_onchain_broadcast_tx(struct peer *peer, const u8 *msg)
static void handle_onchain_broadcast_tx(struct channel *channel, const u8 *msg)
{
struct bitcoin_tx *tx;
struct channel *channel = peer2channel(peer);
if (!fromwire_onchain_broadcast_tx(msg, msg, NULL, &tx)) {
channel_internal_error(channel, "Invalid onchain_broadcast_tx");
@ -1024,14 +1010,13 @@ static void handle_onchain_broadcast_tx(struct peer *peer, const u8 *msg)
}
/* We don't really care if it fails, we'll respond via watch. */
broadcast_tx(peer->ld->topology, peer, tx, NULL);
broadcast_tx(channel->peer->ld->topology, channel2peer(channel), tx, NULL);
}
static void handle_onchain_unwatch_tx(struct peer *peer, const u8 *msg)
static void handle_onchain_unwatch_tx(struct channel *channel, const u8 *msg)
{
struct bitcoin_txid txid;
struct txwatch *txw;
struct channel *channel = peer2channel(peer);
if (!fromwire_onchain_unwatch_tx(msg, NULL, &txid)) {
channel_internal_error(channel, "Invalid onchain_unwatch_tx");
@ -1039,30 +1024,28 @@ static void handle_onchain_unwatch_tx(struct peer *peer, const u8 *msg)
}
/* Frees the txo watches, too: see watch_tx_and_outputs() */
txw = find_txwatch(peer->ld->topology, &txid, peer);
txw = find_txwatch(channel->peer->ld->topology, &txid, channel2peer(channel));
if (!txw)
log_unusual(peer->log, "Can't unwatch txid %s",
log_unusual(channel->log, "Can't unwatch txid %s",
type_to_string(ltmp, struct bitcoin_txid, &txid));
tal_free(txw);
}
static void handle_extracted_preimage(struct peer *peer, const u8 *msg)
static void handle_extracted_preimage(struct channel *channel, const u8 *msg)
{
struct preimage preimage;
struct channel *channel = peer2channel(peer);
if (!fromwire_onchain_extracted_preimage(msg, NULL, &preimage)) {
channel_internal_error(channel, "Invalid extracted_preimage");
return;
}
onchain_fulfilled_htlc(peer, &preimage);
onchain_fulfilled_htlc(channel, &preimage);
}
static void handle_missing_htlc_output(struct peer *peer, const u8 *msg)
static void handle_missing_htlc_output(struct channel *channel, const u8 *msg)
{
struct htlc_stub htlc;
struct channel *channel = peer2channel(peer);
if (!fromwire_onchain_missing_htlc_output(msg, NULL, &htlc)) {
channel_internal_error(channel, "Invalid missing_htlc_output");
@ -1077,13 +1060,12 @@ static void handle_missing_htlc_output(struct peer *peer, const u8 *msg)
* reasonable depth, and MAY fail it sooner if no valid commitment
* transaction contains an output corresponding to the HTLC.
*/
onchain_failed_our_htlc(peer, &htlc, "missing in commitment tx");
onchain_failed_our_htlc(channel, &htlc, "missing in commitment tx");
}
static void handle_onchain_htlc_timeout(struct peer *peer, const u8 *msg)
static void handle_onchain_htlc_timeout(struct channel *channel, const u8 *msg)
{
struct htlc_stub htlc;
struct channel *channel = peer2channel(peer);
if (!fromwire_onchain_htlc_timeout(msg, NULL, &htlc)) {
channel_internal_error(channel, "Invalid onchain_htlc_timeout");
@ -1097,11 +1079,11 @@ static void handle_onchain_htlc_timeout(struct peer *peer, const u8 *msg)
* HTLC (if any) once the resolving transaction has reached reasonable
* depth.
*/
onchain_failed_our_htlc(peer, &htlc, "timed out");
onchain_failed_our_htlc(channel, &htlc, "timed out");
}
/* If peer is NULL, free them all (for shutdown) */
void free_htlcs(struct lightningd *ld, const struct peer *peer)
/* If channel is NULL, free them all (for shutdown) */
void free_htlcs(struct lightningd *ld, const struct channel *channel)
{
struct htlc_out_map_iter outi;
struct htlc_out *hout;
@ -1116,7 +1098,7 @@ void free_htlcs(struct lightningd *ld, const struct peer *peer)
for (hout = htlc_out_map_first(&ld->htlcs_out, &outi);
hout;
hout = htlc_out_map_next(&ld->htlcs_out, &outi)) {
if (peer && hout->key.peer != peer)
if (channel && hout->key.peer != channel2peer(channel))
continue;
tal_free(hout);
deleted = true;
@ -1125,7 +1107,7 @@ void free_htlcs(struct lightningd *ld, const struct peer *peer)
for (hin = htlc_in_map_first(&ld->htlcs_in, &ini);
hin;
hin = htlc_in_map_next(&ld->htlcs_in, &ini)) {
if (peer && hin->key.peer != peer)
if (channel && hin->key.peer != channel2peer(channel))
continue;
tal_free(hin);
deleted = true;
@ -1134,21 +1116,21 @@ void free_htlcs(struct lightningd *ld, const struct peer *peer)
} while (deleted);
}
static void handle_irrevocably_resolved(struct peer *peer, const u8 *msg)
static void handle_irrevocably_resolved(struct channel *channel, const u8 *msg)
{
/* FIXME: Implement check_htlcs to ensure no dangling hout->in ptrs! */
free_htlcs(peer->ld, peer);
free_htlcs(channel->peer->ld, channel);
log_info(peer->log, "onchaind complete, forgetting peer");
log_info(channel->log, "onchaind complete, forgetting peer");
/* This will also free onchaind. */
free_channel(peer2channel(peer), "onchaind complete, forgetting peer");
free_channel(channel, "onchaind complete, forgetting peer");
}
/**
* onchain_add_utxo -- onchaind is telling us about an UTXO we own
*/
static void onchain_add_utxo(struct peer *peer, const u8 *msg)
static void onchain_add_utxo(struct channel *channel, const u8 *msg)
{
struct utxo *u = tal(msg, struct utxo);
u->close_info = tal(u, struct unilateral_close_info);
@ -1156,8 +1138,8 @@ static void onchain_add_utxo(struct peer *peer, const u8 *msg)
u->is_p2sh = true;
u->keyindex = 0;
u->status = output_state_available;
u->close_info->channel_id = peer2channel(peer)->dbid;
u->close_info->peer_id = peer->id;
u->close_info->channel_id = channel->dbid;
u->close_info->peer_id = channel->peer->id;
if (!fromwire_onchain_add_utxo(msg, NULL, &u->txid, &u->outnum,
&u->close_info->commitment_point,
@ -1166,7 +1148,7 @@ static void onchain_add_utxo(struct peer *peer, const u8 *msg)
}
wallet_add_utxo(peer->ld->wallet, u, p2wpkh);
wallet_add_utxo(channel->peer->ld->wallet, u, p2wpkh);
}
static unsigned int onchain_msg(struct subd *sd, const u8 *msg, const int *fds)
@ -1175,35 +1157,35 @@ static unsigned int onchain_msg(struct subd *sd, const u8 *msg, const int *fds)
switch (t) {
case WIRE_ONCHAIN_INIT_REPLY:
handle_onchain_init_reply(sd->peer, msg);
handle_onchain_init_reply(sd->channel, msg);
break;
case WIRE_ONCHAIN_BROADCAST_TX:
handle_onchain_broadcast_tx(sd->peer, msg);
handle_onchain_broadcast_tx(sd->channel, msg);
break;
case WIRE_ONCHAIN_UNWATCH_TX:
handle_onchain_unwatch_tx(sd->peer, msg);
handle_onchain_unwatch_tx(sd->channel, msg);
break;
case WIRE_ONCHAIN_EXTRACTED_PREIMAGE:
handle_extracted_preimage(sd->peer, msg);
handle_extracted_preimage(sd->channel, msg);
break;
case WIRE_ONCHAIN_MISSING_HTLC_OUTPUT:
handle_missing_htlc_output(sd->peer, msg);
handle_missing_htlc_output(sd->channel, msg);
break;
case WIRE_ONCHAIN_HTLC_TIMEOUT:
handle_onchain_htlc_timeout(sd->peer, msg);
handle_onchain_htlc_timeout(sd->channel, msg);
break;
case WIRE_ONCHAIN_ALL_IRREVOCABLY_RESOLVED:
handle_irrevocably_resolved(sd->peer, msg);
handle_irrevocably_resolved(sd->channel, msg);
break;
case WIRE_ONCHAIN_ADD_UTXO:
onchain_add_utxo(sd->peer, msg);
onchain_add_utxo(sd->channel, msg);
break;
/* We send these, not receive them */
@ -1229,7 +1211,8 @@ static u8 *p2wpkh_for_keyidx(const tal_t *ctx, struct lightningd *ld, u64 keyidx
}
/* If we want to know if this HTLC is missing, return depth. */
static bool tell_if_missing(const struct peer *peer, struct htlc_stub *stub,
static bool tell_if_missing(const struct channel *channel,
struct htlc_stub *stub,
bool *tell_immediate)
{
struct htlc_out *hout;
@ -1238,7 +1221,7 @@ static bool tell_if_missing(const struct peer *peer, struct htlc_stub *stub,
*tell_immediate = false;
/* Is it a current HTLC? */
hout = find_htlc_out_by_ripemd(peer, &stub->ripemd);
hout = find_htlc_out_by_ripemd(channel, &stub->ripemd);
if (!hout)
return false;
@ -1254,7 +1237,8 @@ static bool tell_if_missing(const struct peer *peer, struct htlc_stub *stub,
&& hout->hstate < SENT_REMOVE_REVOCATION)
*tell_immediate = true;
log_debug(peer->log, "We want to know if htlc %"PRIu64" is missing (%s)",
log_debug(channel->log,
"We want to know if htlc %"PRIu64" is missing (%s)",
hout->key.id, *tell_immediate ? "immediate" : "later");
return true;
}
@ -1274,28 +1258,30 @@ static enum watch_result funding_spent(struct peer *peer,
struct htlc_stub *stubs;
const tal_t *tmpctx = tal_tmpctx(peer);
struct channel *channel = peer2channel(peer);
struct lightningd *ld = channel->peer->ld;
channel_fail_permanent(channel, "Funding transaction spent");
/* We could come from almost any state. */
peer_set_condition(peer, channel->state, FUNDING_SPEND_SEEN);
channel_set_state(channel, channel->state, FUNDING_SPEND_SEEN);
peer_set_owner(peer, new_peer_subd(peer->ld,
"lightning_onchaind", peer,
onchain_wire_type_name,
onchain_msg,
NULL));
channel_set_owner(channel, new_channel_subd(ld,
"lightning_onchaind",
channel,
onchain_wire_type_name,
onchain_msg,
NULL));
if (!channel->owner) {
log_broken(peer->log, "Could not subdaemon onchain: %s",
log_broken(channel->log, "Could not subdaemon onchain: %s",
strerror(errno));
tal_free(tmpctx);
return KEEP_WATCHING;
}
stubs = wallet_htlc_stubs(tmpctx, peer->ld->wallet, channel);
stubs = wallet_htlc_stubs(tmpctx, ld->wallet, channel);
if (!stubs) {
log_broken(peer->log, "Could not load htlc_stubs");
log_broken(channel->log, "Could not load htlc_stubs");
tal_free(tmpctx);
return KEEP_WATCHING;
}
@ -1304,14 +1290,14 @@ static enum watch_result funding_spent(struct peer *peer,
if (channel->local_shutdown_idx >= 0)
keyindex = channel->local_shutdown_idx;
else {
keyindex = wallet_get_newindex(peer->ld);
keyindex = wallet_get_newindex(ld);
if (keyindex < 0) {
log_broken(peer->log, "Could not get keyindex");
log_broken(channel->log, "Could not get keyindex");
tal_free(tmpctx);
return KEEP_WATCHING;
}
}
scriptpubkey = p2wpkh_for_keyidx(tmpctx, peer->ld, keyindex);
scriptpubkey = p2wpkh_for_keyidx(tmpctx, ld, keyindex);
if (!scriptpubkey) {
channel_internal_error(channel,
"Can't get shutdown script %"PRIu64,
@ -1319,9 +1305,9 @@ static enum watch_result funding_spent(struct peer *peer,
tal_free(tmpctx);
return DELETE_WATCH;
}
txfilter_add_scriptpubkey(peer->ld->owned_txfilter, scriptpubkey);
txfilter_add_scriptpubkey(ld->owned_txfilter, scriptpubkey);
if (!bip32_pubkey(peer->ld->wallet->bip32_base, &ourkey, keyindex)) {
if (!bip32_pubkey(ld->wallet->bip32_base, &ourkey, keyindex)) {
channel_internal_error(channel,
"Can't get shutdown key %"PRIu64,
keyindex);
@ -1332,7 +1318,7 @@ static enum watch_result funding_spent(struct peer *peer,
/* This could be a mutual close, but it doesn't matter. */
bitcoin_txid(channel->last_tx, &our_last_txid);
msg = towire_onchain_init(peer,
msg = towire_onchain_init(channel,
&channel->seed, &channel->their_shachain.chain,
channel->funding_satoshi,
&channel->channel_info->old_remote_per_commit,
@ -1345,8 +1331,7 @@ static enum watch_result funding_spent(struct peer *peer,
* we specify theirs. */
channel->channel_info->their_config.to_self_delay,
channel->our_config.to_self_delay,
get_feerate(peer->ld->topology,
FEERATE_NORMAL),
get_feerate(ld->topology, FEERATE_NORMAL),
channel->our_config.dust_limit_satoshis,
&channel->channel_info->theirbase.revocation,
&our_last_txid,
@ -1368,8 +1353,8 @@ static enum watch_result funding_spent(struct peer *peer,
/* FIXME: Don't queue all at once, use an empty cb... */
for (size_t i = 0; i < tal_count(stubs); i++) {
bool tell_immediate;
bool tell = tell_if_missing(peer, &stubs[i], &tell_immediate);
msg = towire_onchain_htlc(peer, &stubs[i],
bool tell = tell_if_missing(channel, &stubs[i], &tell_immediate);
msg = towire_onchain_htlc(channel, &stubs[i],
tell, tell_immediate);
subd_send_msg(channel->owner, take(msg));
}
@ -1499,10 +1484,9 @@ static void opening_got_hsm_funding_sig(struct funding_channel *fc,
* first step is to build the provisional announcement and ask the HSM
* to sign it. */
static void peer_got_funding_locked(struct peer *peer, const u8 *msg)
static void peer_got_funding_locked(struct channel *channel, const u8 *msg)
{
struct pubkey next_per_commitment_point;
struct channel *channel = peer2channel(peer);
if (!fromwire_channel_got_funding_locked(msg, NULL,
&next_per_commitment_point)) {
@ -1517,18 +1501,18 @@ static void peer_got_funding_locked(struct peer *peer, const u8 *msg)
"channel_got_funding_locked twice");
return;
}
update_per_commit_point(peer, &next_per_commitment_point);
update_per_commit_point(channel2peer(channel), &next_per_commitment_point);
log_debug(peer->log, "Got funding_locked");
log_debug(channel->log, "Got funding_locked");
channel->remote_funding_locked = true;
}
static void peer_got_shutdown(struct peer *peer, const u8 *msg)
static void peer_got_shutdown(struct channel *channel, const u8 *msg)
{
u8 *scriptpubkey;
struct channel *channel = peer2channel(peer);
struct lightningd *ld = channel->peer->ld;
if (!fromwire_channel_got_shutdown(peer, msg, NULL, &scriptpubkey)) {
if (!fromwire_channel_got_shutdown(channel, msg, NULL, &scriptpubkey)) {
channel_internal_error(channel, "bad channel_got_shutdown %s",
tal_hex(msg, msg));
return;
@ -1560,14 +1544,15 @@ static void peer_got_shutdown(struct peer *peer, const u8 *msg)
if (channel->local_shutdown_idx == -1) {
u8 *scriptpubkey;
channel->local_shutdown_idx = wallet_get_newindex(peer->ld);
channel->local_shutdown_idx = wallet_get_newindex(ld);
if (channel->local_shutdown_idx == -1) {
channel_internal_error(channel,
"Can't get local shutdown index");
return;
}
peer_set_condition(peer, CHANNELD_NORMAL, CHANNELD_SHUTTING_DOWN);
channel_set_state(channel,
CHANNELD_NORMAL, CHANNELD_SHUTTING_DOWN);
/* BOLT #2:
*
@ -1576,7 +1561,7 @@ static void peer_got_shutdown(struct peer *peer, const u8 *msg)
*
* ...3. `OP_0` `20` 20-bytes (version 0 pay to witness pubkey),
*/
scriptpubkey = p2wpkh_for_keyidx(msg, peer->ld,
scriptpubkey = p2wpkh_for_keyidx(msg, ld,
channel->local_shutdown_idx);
if (!scriptpubkey) {
channel_internal_error(channel,
@ -1585,7 +1570,7 @@ static void peer_got_shutdown(struct peer *peer, const u8 *msg)
return;
}
txfilter_add_scriptpubkey(peer->ld->owned_txfilter, scriptpubkey);
txfilter_add_scriptpubkey(ld->owned_txfilter, scriptpubkey);
/* BOLT #2:
*
@ -1594,12 +1579,12 @@ static void peer_got_shutdown(struct peer *peer, const u8 *msg)
* peer, unless it has already sent a `shutdown`.
*/
subd_send_msg(channel->owner,
take(towire_channel_send_shutdown(peer,
take(towire_channel_send_shutdown(channel,
scriptpubkey)));
}
/* TODO(cdecker) Selectively save updated fields to DB */
wallet_channel_save(peer->ld->wallet, channel);
wallet_channel_save(ld->wallet, channel);
}
void peer_last_tx(struct peer *peer, struct bitcoin_tx *tx,
@ -1667,11 +1652,12 @@ static bool better_closing_fee(struct lightningd *ld,
return new_diff <= old_diff;
}
static void peer_received_closing_signature(struct peer *peer, const u8 *msg)
static void peer_received_closing_signature(struct channel *channel,
const u8 *msg)
{
secp256k1_ecdsa_signature sig;
struct bitcoin_tx *tx;
struct channel *channel = peer2channel(peer);
struct lightningd *ld = channel->peer->ld;
if (!fromwire_closing_received_signature(msg, msg, NULL, &sig, &tx)) {
channel_internal_error(channel, "Bad closing_received_signature %s",
@ -1680,20 +1666,19 @@ static void peer_received_closing_signature(struct peer *peer, const u8 *msg)
}
/* FIXME: Make sure signature is correct! */
if (better_closing_fee(peer->ld, channel, tx)) {
peer_last_tx(peer, tx, &sig);
if (better_closing_fee(ld, channel, tx)) {
peer_last_tx(channel2peer(channel), tx, &sig);
/* TODO(cdecker) Selectively save updated fields to DB */
wallet_channel_save(peer->ld->wallet, channel);
wallet_channel_save(ld->wallet, channel);
}
/* OK, you can continue now. */
subd_send_msg(peer2channel(peer)->owner,
take(towire_closing_received_signature_reply(peer)));
subd_send_msg(channel->owner,
take(towire_closing_received_signature_reply(channel)));
}
static void peer_closing_complete(struct peer *peer, const u8 *msg)
static void peer_closing_complete(struct channel *channel, const u8 *msg)
{
struct channel *channel = peer2channel(peer);
/* FIXME: We should save this, to return to gossipd */
u64 gossip_index;
@ -1704,11 +1689,11 @@ static void peer_closing_complete(struct peer *peer, const u8 *msg)
}
/* Retransmission only, ignore closing. */
if (peer2channel(peer)->state == CLOSINGD_COMPLETE)
if (channel->state == CLOSINGD_COMPLETE)
return;
drop_to_chain(peer->ld, channel);
peer_set_condition(peer, CLOSINGD_SIGEXCHANGE, CLOSINGD_COMPLETE);
drop_to_chain(channel->peer->ld, channel);
channel_set_state(channel, CLOSINGD_SIGEXCHANGE, CLOSINGD_COMPLETE);
}
static unsigned closing_msg(struct subd *sd, const u8 *msg, const int *fds)
@ -1717,11 +1702,11 @@ static unsigned closing_msg(struct subd *sd, const u8 *msg, const int *fds)
switch (t) {
case WIRE_CLOSING_RECEIVED_SIGNATURE:
peer_received_closing_signature(sd->peer, msg);
peer_received_closing_signature(sd->channel, msg);
break;
case WIRE_CLOSING_COMPLETE:
peer_closing_complete(sd->peer, msg);
peer_closing_complete(sd->channel, msg);
break;
/* We send these, not receive them */
@ -1733,18 +1718,18 @@ static unsigned closing_msg(struct subd *sd, const u8 *msg, const int *fds)
return 0;
}
static void peer_start_closingd(struct peer *peer,
static void peer_start_closingd(struct channel *channel,
struct crypto_state *cs,
u64 gossip_index,
int peer_fd, int gossip_fd,
bool reconnected)
{
const tal_t *tmpctx = tal_tmpctx(peer);
const tal_t *tmpctx = tal_tmpctx(channel);
u8 *initmsg, *local_scriptpubkey;
u64 minfee, startfee, feelimit;
u64 num_revocations;
u64 funding_msatoshi, our_msatoshi, their_msatoshi;
struct channel *channel = peer2channel(peer);
struct lightningd *ld = channel->peer->ld;
if (channel->local_shutdown_idx == -1
|| !channel->remote_shutdown_scriptpubkey) {
@ -1758,20 +1743,20 @@ static void peer_start_closingd(struct peer *peer,
return;
}
peer_set_owner(peer, new_peer_subd(peer->ld,
"lightning_closingd", peer,
channel_set_owner(channel, new_channel_subd(ld,
"lightning_closingd", channel,
closing_wire_type_name, closing_msg,
take(&peer_fd), take(&gossip_fd),
NULL));
if (!channel->owner) {
log_unusual(peer->log, "Could not subdaemon closing: %s",
log_unusual(channel->log, "Could not subdaemon closing: %s",
strerror(errno));
channel_fail_transient(channel, "Failed to subdaemon closing");
tal_free(tmpctx);
return;
}
local_scriptpubkey = p2wpkh_for_keyidx(tmpctx, peer->ld,
local_scriptpubkey = p2wpkh_for_keyidx(tmpctx, ld,
channel->local_shutdown_idx);
if (!local_scriptpubkey) {
channel_internal_error(channel,
@ -1790,10 +1775,9 @@ static void peer_start_closingd(struct peer *peer,
feelimit = commit_tx_base_fee(channel->channel_info->feerate_per_kw[LOCAL],
0);
minfee = commit_tx_base_fee(get_feerate(peer->ld->topology,
FEERATE_SLOW), 0);
startfee = commit_tx_base_fee(get_feerate(peer->ld->topology,
FEERATE_NORMAL), 0);
minfee = commit_tx_base_fee(get_feerate(ld->topology, FEERATE_SLOW), 0);
startfee = commit_tx_base_fee(get_feerate(ld->topology, FEERATE_NORMAL),
0);
if (startfee > feelimit)
startfee = feelimit;
@ -1839,10 +1823,10 @@ static void peer_start_closingd(struct peer *peer,
tal_free(tmpctx);
}
static void peer_start_closingd_after_shutdown(struct peer *peer, const u8 *msg,
static void peer_start_closingd_after_shutdown(struct channel *channel,
const u8 *msg,
const int *fds)
{
struct channel *channel = peer2channel(peer);
struct crypto_state cs;
u64 gossip_index;
@ -1851,13 +1835,13 @@ static void peer_start_closingd_after_shutdown(struct peer *peer, const u8 *msg,
if (!fromwire_channel_shutdown_complete(msg, NULL, &cs, &gossip_index)) {
channel_internal_error(channel, "bad shutdown_complete: %s",
tal_hex(peer, msg));
tal_hex(msg, msg));
return;
}
/* This sets peer->owner, closes down channeld. */
peer_start_closingd(peer, &cs, gossip_index, fds[0], fds[1], false);
peer_set_condition(peer, CHANNELD_SHUTTING_DOWN, CLOSINGD_SIGEXCHANGE);
/* This sets channel->owner, closes down channeld. */
peer_start_closingd(channel, &cs, gossip_index, fds[0], fds[1], false);
channel_set_state(channel, CHANNELD_SHUTTING_DOWN, CLOSINGD_SIGEXCHANGE);
}
static unsigned channel_msg(struct subd *sd, const u8 *msg, const int *fds)
@ -1866,29 +1850,29 @@ static unsigned channel_msg(struct subd *sd, const u8 *msg, const int *fds)
switch (t) {
case WIRE_CHANNEL_NORMAL_OPERATION:
peer_set_condition(sd->peer,
CHANNELD_AWAITING_LOCKIN, CHANNELD_NORMAL);
channel_set_state(sd->channel,
CHANNELD_AWAITING_LOCKIN, CHANNELD_NORMAL);
break;
case WIRE_CHANNEL_SENDING_COMMITSIG:
peer_sending_commitsig(sd->peer, msg);
peer_sending_commitsig(sd->channel, msg);
break;
case WIRE_CHANNEL_GOT_COMMITSIG:
peer_got_commitsig(sd->peer, msg);
peer_got_commitsig(sd->channel, msg);
break;
case WIRE_CHANNEL_GOT_REVOKE:
peer_got_revoke(sd->peer, msg);
peer_got_revoke(sd->channel, msg);
break;
case WIRE_CHANNEL_GOT_FUNDING_LOCKED:
peer_got_funding_locked(sd->peer, msg);
peer_got_funding_locked(sd->channel, msg);
break;
case WIRE_CHANNEL_GOT_SHUTDOWN:
peer_got_shutdown(sd->peer, msg);
peer_got_shutdown(sd->channel, msg);
break;
case WIRE_CHANNEL_SHUTDOWN_COMPLETE:
/* We expect 2 fds. */
if (!fds)
return 2;
peer_start_closingd_after_shutdown(sd->peer, msg, fds);
peer_start_closingd_after_shutdown(sd->channel, msg, fds);
break;
/* And we never get these from channeld. */
@ -1959,6 +1943,7 @@ static bool peer_start_channeld(struct peer *peer,
const u8 *shutdown_scriptpubkey;
u64 num_revocations;
struct channel *channel = peer2channel(peer);
struct lightningd *ld = channel->peer->ld;
/* Now we can consider balance set. */
if (!reconnected) {
@ -1984,8 +1969,8 @@ static bool peer_start_channeld(struct peer *peer,
if (hsmfd < 0)
fatal("Could not read fd from HSM: %s", strerror(errno));
peer_set_owner(peer, new_peer_subd(peer->ld,
"lightning_channeld", peer,
channel_set_owner(channel, new_channel_subd(ld,
"lightning_channeld", channel,
channel_wire_type_name,
channel_msg,
take(&peer_fd),
@ -2300,8 +2285,7 @@ static unsigned int opening_negotiation_failed(struct subd *openingd,
{
struct crypto_state cs;
u64 gossip_index;
struct peer *peer = openingd->peer;
struct channel *channel = peer2channel(peer);
struct channel *channel = openingd->channel;
char *why;
/* We need the peer fd and gossip fd. */
@ -2316,16 +2300,18 @@ static unsigned int opening_negotiation_failed(struct subd *openingd,
return 0;
}
msg = towire_gossipctl_hand_back_peer(msg, &peer->id, &cs, gossip_index,
msg = towire_gossipctl_hand_back_peer(msg,
&channel->peer->id, &cs,
gossip_index,
NULL);
subd_send_msg(openingd->ld->gossip, take(msg));
subd_send_fd(openingd->ld->gossip, fds[0]);
subd_send_fd(openingd->ld->gossip, fds[1]);
log_unusual(peer->log, "Opening negotiation failed: %s", why);
log_unusual(channel->log, "Opening negotiation failed: %s", why);
/* This will free openingd, since that's peer->owner */
free_channel(peer2channel(peer), why);
free_channel(channel, why);
return 0;
}
@ -2356,12 +2342,13 @@ static void peer_accept_channel(struct lightningd *ld,
assert(channel == peer2channel(peer));
assert(peer == channel2peer(channel));
peer_set_condition(peer, UNINITIALIZED, OPENINGD);
peer_set_owner(peer,
new_peer_subd(ld, "lightning_openingd", peer,
opening_wire_type_name,
opening_negotiation_failed,
take(&peer_fd), take(&gossip_fd), NULL));
channel_set_state(channel, UNINITIALIZED, OPENINGD);
channel_set_owner(channel,
new_channel_subd(ld, "lightning_openingd", channel,
opening_wire_type_name,
opening_negotiation_failed,
take(&peer_fd), take(&gossip_fd),
NULL));
if (!channel->owner) {
channel_fail_transient(channel,
"Failed to subdaemon opening: %s",
@ -2436,13 +2423,14 @@ static void peer_offer_channel(struct lightningd *ld,
channel->funding_satoshi = fc->funding_satoshi;
channel->push_msat = fc->push_msat;
peer_set_condition(fc->peer, UNINITIALIZED, OPENINGD);
peer_set_owner(fc->peer,
new_peer_subd(ld,
"lightning_openingd", fc->peer,
opening_wire_type_name,
opening_negotiation_failed,
take(&peer_fd), take(&gossip_fd), NULL));
channel_set_state(channel, UNINITIALIZED, OPENINGD);
channel_set_owner(channel,
new_channel_subd(ld,
"lightning_openingd", channel,
opening_wire_type_name,
opening_negotiation_failed,
take(&peer_fd), take(&gossip_fd),
NULL));
if (!channel->owner) {
fc->peer = tal_free(fc->peer);
command_fail(fc->cmd,

2
lightningd/peer_control.h
View File

@ -103,7 +103,7 @@ void activate_peers(struct lightningd *ld);
void drop_to_chain(struct lightningd *ld, struct channel *channel);
void free_htlcs(struct lightningd *ld, const struct peer *peer);
void free_htlcs(struct lightningd *ld, const struct channel *channel);
/* Get range of feerates to insist other side abide by for normal channels. */
u32 feerate_min(struct lightningd *ld);

95
lightningd/peer_htlcs.c
View File

@ -334,7 +334,7 @@ static void rcvd_htlc_reply(struct subd *subd, const u8 *msg, const int *fds,
&hout->key.id,
&failure_code,
&failurestr)) {
channel_internal_error(peer2channel(subd->peer),
channel_internal_error(subd->channel,
"Bad channel_offer_htlc_reply");
tal_free(hout);
return;
@ -359,7 +359,7 @@ static void rcvd_htlc_reply(struct subd *subd, const u8 *msg, const int *fds,
if (find_htlc_out(&subd->ld->htlcs_out, hout->key.peer, hout->key.id)
|| hout->key.id == HTLC_INVALID_ID) {
channel_internal_error(peer2channel(subd->peer),
channel_internal_error(subd->channel,
"Bad offer_htlc_reply HTLC id %"PRIu64
" is a duplicate",
hout->key.id);
@ -688,19 +688,21 @@ static bool peer_fulfilled_our_htlc(struct channel *channel,
return true;
}
void onchain_fulfilled_htlc(struct peer *peer, const struct preimage *preimage)
void onchain_fulfilled_htlc(struct channel *channel,
const struct preimage *preimage)
{
struct htlc_out_map_iter outi;
struct htlc_out *hout;
struct sha256 payment_hash;
struct lightningd *ld = channel->peer->ld;
sha256(&payment_hash, preimage, sizeof(*preimage));
/* FIXME: use db to look this up! */
for (hout = htlc_out_map_first(&peer->ld->htlcs_out, &outi);
for (hout = htlc_out_map_first(&ld->htlcs_out, &outi);
hout;
hout = htlc_out_map_next(&peer->ld->htlcs_out, &outi)) {
if (hout->key.peer != peer)
hout = htlc_out_map_next(&ld->htlcs_out, &outi)) {
if (hout->key.peer != channel2peer(channel))
continue;
if (!structeq(&hout->payment_hash, &payment_hash))
@ -709,7 +711,7 @@ void onchain_fulfilled_htlc(struct peer *peer, const struct preimage *preimage)
/* We may have already fulfilled before going onchain, or
* we can fulfill onchain multiple times. */
if (!hout->preimage)
fulfill_our_htlc_out(peer, hout, preimage);
fulfill_our_htlc_out(channel2peer(channel), hout, preimage);
/* We keep going: this is something of a leak, but onchain
* we have no real way of distinguishing HTLCs anyway */
@ -748,18 +750,19 @@ static bool peer_failed_our_htlc(struct channel *channel,
}
/* FIXME: Crazy slow! */
struct htlc_out *find_htlc_out_by_ripemd(const struct peer *peer,
struct htlc_out *find_htlc_out_by_ripemd(const struct channel *channel,
const struct ripemd160 *ripemd)
{
struct htlc_out_map_iter outi;
struct htlc_out *hout;
struct lightningd *ld = channel->peer->ld;
for (hout = htlc_out_map_first(&peer->ld->htlcs_out, &outi);
for (hout = htlc_out_map_first(&ld->htlcs_out, &outi);
hout;
hout = htlc_out_map_next(&peer->ld->htlcs_out, &outi)) {
hout = htlc_out_map_next(&ld->htlcs_out, &outi)) {
struct ripemd160 hash;
if (hout->key.peer != peer)
if (hout->key.peer != channel2peer(channel))
continue;
ripemd160(&hash,
@ -770,11 +773,11 @@ struct htlc_out *find_htlc_out_by_ripemd(const struct peer *peer,
return NULL;
}
void onchain_failed_our_htlc(const struct peer *peer,
void onchain_failed_our_htlc(const struct channel *channel,
const struct htlc_stub *htlc,
const char *why)
{
struct htlc_out *hout = find_htlc_out_by_ripemd(peer, &htlc->ripemd);
struct htlc_out *hout = find_htlc_out_by_ripemd(channel, &htlc->ripemd);
/* Don't fail twice! */
if (hout->failuremsg || hout->failcode)
@ -783,7 +786,7 @@ void onchain_failed_our_htlc(const struct peer *peer,
hout->failcode = WIRE_PERMANENT_CHANNEL_FAILURE;
if (!hout->in) {
char *localfail = tal_fmt(peer, "%s: %s",
char *localfail = tal_fmt(channel, "%s: %s",
onion_type_name(WIRE_PERMANENT_CHANNEL_FAILURE),
why);
payment_failed(hout->key.peer->ld, hout, localfail);
@ -943,7 +946,7 @@ static bool peer_save_commitsig_sent(struct peer *peer, u64 commitnum)
return true;
}
void peer_sending_commitsig(struct peer *peer, const u8 *msg)
void peer_sending_commitsig(struct channel *channel, const u8 *msg)
{
u64 commitnum;
u32 feerate;
@ -951,7 +954,7 @@ void peer_sending_commitsig(struct peer *peer, const u8 *msg)
size_t i, maxid = 0, num_local_added = 0;
secp256k1_ecdsa_signature commit_sig;
secp256k1_ecdsa_signature *htlc_sigs;
struct channel *channel = peer2channel(peer);
struct lightningd *ld = channel->peer->ld;
if (!fromwire_channel_sending_commitsig(msg, msg, NULL,
&commitnum,
@ -959,12 +962,12 @@ void peer_sending_commitsig(struct peer *peer, const u8 *msg)
&changed_htlcs,
&commit_sig, &htlc_sigs)) {
channel_internal_error(channel, "bad channel_sending_commitsig %s",
tal_hex(peer, msg));
tal_hex(channel, msg));
return;
}
for (i = 0; i < tal_count(changed_htlcs); i++) {
if (!changed_htlc(peer, changed_htlcs + i)) {
if (!changed_htlc(channel2peer(channel), changed_htlcs + i)) {
channel_internal_error(channel,
"channel_sending_commitsig: update failed");
return;
@ -980,31 +983,31 @@ void peer_sending_commitsig(struct peer *peer, const u8 *msg)
}
if (num_local_added != 0) {
if (maxid != peer2channel(peer)->next_htlc_id + num_local_added - 1) {
if (maxid != channel->next_htlc_id + num_local_added - 1) {
channel_internal_error(channel,
"channel_sending_commitsig:"
" Added %"PRIu64", maxid now %"PRIu64
" from %"PRIu64,
num_local_added, maxid, peer2channel(peer)->next_htlc_id);
num_local_added, maxid, channel->next_htlc_id);
return;
}
peer2channel(peer)->next_htlc_id += num_local_added;
channel->next_htlc_id += num_local_added;
}
/* Update their feerate. */
peer2channel(peer)->channel_info->feerate_per_kw[REMOTE] = feerate;
channel->channel_info->feerate_per_kw[REMOTE] = feerate;
if (!peer_save_commitsig_sent(peer, commitnum))
if (!peer_save_commitsig_sent(channel2peer(channel), commitnum))
return;
/* Last was commit. */
peer2channel(peer)->last_was_revoke = false;
tal_free(peer2channel(peer)->last_sent_commit);
peer2channel(peer)->last_sent_commit = tal_steal(peer, changed_htlcs);
wallet_channel_save(peer->ld->wallet, peer2channel(peer));
channel->last_was_revoke = false;
tal_free(channel->last_sent_commit);
channel->last_sent_commit = tal_steal(channel, changed_htlcs);
wallet_channel_save(ld->wallet, channel);
/* Tell it we've got it, and to go ahead with commitment_signed. */
subd_send_msg(peer2channel(peer)->owner,
subd_send_msg(channel->owner,
take(towire_channel_sending_commitsig_reply(msg)));
}
@ -1084,7 +1087,7 @@ static bool peer_sending_revocation(struct channel *channel,
}
/* This also implies we're sending revocation */
void peer_got_commitsig(struct peer *peer, const u8 *msg)
void peer_got_commitsig(struct channel *channel, const u8 *msg)
{
u64 commitnum;
u32 feerate;
@ -1097,7 +1100,7 @@ void peer_got_commitsig(struct peer *peer, const u8 *msg)
struct changed_htlc *changed;
struct bitcoin_tx *tx;
size_t i;
struct channel *channel = peer2channel(peer);
struct lightningd *ld = channel->peer->ld;
if (!fromwire_channel_got_commitsig(msg, msg, NULL,
&commitnum,
@ -1112,11 +1115,11 @@ void peer_got_commitsig(struct peer *peer, const u8 *msg)
&tx)) {
channel_internal_error(channel,
"bad fromwire_channel_got_commitsig %s",
tal_hex(peer, msg));
tal_hex(channel, msg));
return;
}
log_debug(peer->log,
log_debug(channel->log,
"got commitsig %"PRIu64
": feerate %u, %zu added, %zu fulfilled, %zu failed, %zu changed",
commitnum, feerate, tal_count(added), tal_count(fulfilled),
@ -1140,7 +1143,7 @@ void peer_got_commitsig(struct peer *peer, const u8 *msg)
}
for (i = 0; i < tal_count(changed); i++) {
if (!changed_htlc(peer, &changed[i])) {
if (!changed_htlc(channel2peer(channel), &changed[i])) {
channel_internal_error(channel,
"got_commitsig: update failed");
return;
@ -1157,14 +1160,14 @@ void peer_got_commitsig(struct peer *peer, const u8 *msg)
if (!peer_sending_revocation(channel, added, fulfilled, failed, changed))
return;
if (!peer_save_commitsig_received(peer, commitnum, tx, &commit_sig))
if (!peer_save_commitsig_received(channel2peer(channel), commitnum, tx, &commit_sig))
return;
wallet_channel_save(peer->ld->wallet, channel);
wallet_channel_save(ld->wallet, channel);
tal_free(channel->last_htlc_sigs);
channel->last_htlc_sigs = tal_steal(channel, htlc_sigs);
wallet_htlc_sigs_save(peer->ld->wallet, channel->dbid,
wallet_htlc_sigs_save(ld->wallet, channel->dbid,
channel->last_htlc_sigs);
/* Tell it we've committed, and to go ahead with revoke. */
@ -1181,26 +1184,26 @@ void update_per_commit_point(struct peer *peer,
ci->remote_per_commit = *per_commitment_point;
}
void peer_got_revoke(struct peer *peer, const u8 *msg)
void peer_got_revoke(struct channel *channel, const u8 *msg)
{
u64 revokenum;
struct sha256 per_commitment_secret;
struct pubkey next_per_commitment_point;
struct changed_htlc *changed;
enum onion_type *failcodes;
struct channel *channel = peer2channel(peer);
size_t i;
struct lightningd *ld = channel->peer->ld;
if (!fromwire_channel_got_revoke(msg, msg, NULL,
&revokenum, &per_commitment_secret,
&next_per_commitment_point,
&changed)) {
channel_internal_error(channel, "bad fromwire_channel_got_revoke %s",
tal_hex(peer, msg));
tal_hex(channel, msg));
return;
}
log_debug(peer->log,
log_debug(channel->log,
"got revoke %"PRIu64": %zu changed",
revokenum, tal_count(changed));
@ -1209,11 +1212,11 @@ void peer_got_revoke(struct peer *peer, const u8 *msg)
for (i = 0; i < tal_count(changed); i++) {
/* If we're doing final accept, we need to forward */
if (changed[i].newstate == RCVD_ADD_ACK_REVOCATION) {
if (!peer_accepted_htlc(peer, changed[i].id,
if (!peer_accepted_htlc(channel2peer(channel), changed[i].id,
&failcodes[i]))
return;
} else {
if (!changed_htlc(peer, &changed[i])) {
if (!changed_htlc(channel2peer(channel), &changed[i])) {
channel_internal_error(channel,
"got_revoke: update failed");
return;
@ -1239,7 +1242,7 @@ void peer_got_revoke(struct peer *peer, const u8 *msg)
* A receiving node MAY fail if the `per_commitment_secret` was not
* generated by the protocol in [BOLT #3]
*/
if (!wallet_shachain_add_hash(peer->ld->wallet,
if (!wallet_shachain_add_hash(ld->wallet,
&channel->their_shachain,
shachain_index(revokenum),
&per_commitment_secret)) {
@ -1252,7 +1255,7 @@ void peer_got_revoke(struct peer *peer, const u8 *msg)
}
/* FIXME: Check per_commitment_secret -> per_commit_point */
update_per_commit_point(peer, &next_per_commitment_point);
update_per_commit_point(channel2peer(channel), &next_per_commitment_point);
/* Tell it we've committed, and to go ahead with revoke. */
msg = towire_channel_got_revoke_reply(msg);
@ -1268,10 +1271,10 @@ void peer_got_revoke(struct peer *peer, const u8 *msg)
/* These are all errors before finding next hop. */
assert(!(failcodes[i] & UPDATE));
hin = find_htlc_in(&peer->ld->htlcs_in, peer, changed[i].id);
hin = find_htlc_in(&ld->htlcs_in, channel2peer(channel), changed[i].id);
local_fail_htlc(hin, failcodes[i], NULL);
}
wallet_channel_save(peer->ld->wallet, channel);
wallet_channel_save(ld->wallet, channel);
}
static void *tal_arr_append_(void **p, size_t size)

13
lightningd/peer_htlcs.h
View File

@ -28,9 +28,9 @@ void peer_htlcs(const tal_t *ctx,
const struct failed_htlc ***failed_htlcs,
enum side **failed_sides);
void peer_sending_commitsig(struct peer *peer, const u8 *msg);
void peer_got_commitsig(struct peer *peer, const u8 *msg);
void peer_got_revoke(struct peer *peer, const u8 *msg);
void peer_sending_commitsig(struct channel *channel, const u8 *msg);
void peer_got_commitsig(struct channel *channel, const u8 *msg);
void peer_got_revoke(struct channel *channel, const u8 *msg);
void update_per_commit_point(struct peer *peer,
const struct pubkey *per_commitment_point);
@ -41,10 +41,11 @@ enum onion_type send_htlc_out(struct peer *out, u64 amount, u32 cltv,
struct htlc_in *in,
struct htlc_out **houtp);
struct htlc_out *find_htlc_out_by_ripemd(const struct peer *peer,
struct htlc_out *find_htlc_out_by_ripemd(const struct channel *channel,
const struct ripemd160 *ripemd160);
void onchain_failed_our_htlc(const struct peer *peer,
void onchain_failed_our_htlc(const struct channel *channel,
const struct htlc_stub *htlc,
const char *why);
void onchain_fulfilled_htlc(struct peer *peer, const struct preimage *preimage);
void onchain_fulfilled_htlc(struct channel *channel,
const struct preimage *preimage);
#endif /* LIGHTNING_LIGHTNINGD_PEER_HTLCS_H */

62
lightningd/subd.c
View File

@ -10,6 +10,7 @@
#include <common/gen_status_wire.h>
#include <errno.h>
#include <fcntl.h>
#include <lightningd/channel.h>
#include <lightningd/lightningd.h>
#include <lightningd/log.h>
#include <lightningd/log_status.h>
@ -388,7 +389,7 @@ static bool log_status_fail(struct subd *sd, const u8 *msg)
static bool handle_received_errmsg(struct subd *sd, const u8 *msg)
{
struct peer *peer = sd->peer;
struct channel *channel = sd->channel;
struct channel_id channel_id;
char *desc;
@ -398,16 +399,16 @@ static bool handle_received_errmsg(struct subd *sd, const u8 *msg)
/* FIXME: if not all channels failed, hand back to gossipd! */
/* Don't free sd; we're may be about to free peer. */
sd->peer = NULL;
channel_fail_permanent(peer2channel(peer),
/* Don't free sd; we're may be about to free channel. */
sd->channel = NULL;
channel_fail_permanent(channel,
"%s: received ERROR %s", sd->name, desc);
return true;
}
static bool handle_sent_errmsg(struct subd *sd, const u8 *msg)
{
struct peer *peer = sd->peer;
struct channel *channel = sd->channel;
struct channel_id channel_id;
char *desc;
u8 *errmsg;
@ -417,12 +418,12 @@ static bool handle_sent_errmsg(struct subd *sd, const u8 *msg)
return false;
/* FIXME: if not all channels failed, hand back to gossipd! */
if (!peer2channel(sd->peer)->error)
peer2channel(sd->peer)->error = tal_steal(sd->peer, errmsg);
if (!channel->error)
channel->error = tal_steal(channel, errmsg);
/* Don't free sd; we're may be about to free peer. */
sd->peer = NULL;
channel_fail_permanent(peer2channel(peer),
/* Don't free sd; we're may be about to free channel. */
sd->channel = NULL;
channel_fail_permanent(channel,
"%s: sent ERROR %s", sd->name, desc);
return true;
}
@ -470,18 +471,18 @@ static struct io_plan *sd_msg_read(struct io_conn *conn, struct subd *sd)
goto malformed;
goto close;
case WIRE_STATUS_PEER_CONNECTION_LOST:
if (!sd->peer)
if (!sd->channel)
goto malformed;
log_info(sd->log, "Peer connection lost");
goto close;
case WIRE_STATUS_RECEIVED_ERRMSG:
if (!sd->peer)
if (!sd->channel)
goto malformed;
if (!handle_received_errmsg(sd, sd->msg_in))
goto malformed;
goto close;
case WIRE_STATUS_SENT_ERRMSG:
if (!sd->peer)
if (!sd->channel)
goto malformed;
if (!handle_sent_errmsg(sd, sd->msg_in))
goto malformed;
@ -570,19 +571,19 @@ static void destroy_subd(struct subd *sd)
sd->conn = tal_free(sd->conn);
/* Peer still attached? */
if (sd->peer) {
if (sd->channel) {
/* Don't loop back when we fail it. */
struct peer *peer = sd->peer;
struct channel *channel = sd->channel;
struct db *db = sd->ld->wallet->db;
bool outer_transaction;
sd->peer = NULL;
sd->channel = NULL;
/* We can be freed both inside msg handling, or spontaneously. */
outer_transaction = db->in_transaction;
if (!outer_transaction)
db_begin_transaction(db);
channel_fail_transient(peer2channel(peer),
channel_fail_transient(channel,
"Owning subdaemon %s died (%i)",
sd->name, status);
if (!outer_transaction)
@ -624,7 +625,7 @@ static struct io_plan *msg_setup(struct io_conn *conn, struct subd *sd)
static struct subd *new_subd(struct lightningd *ld,
const char *name,
struct peer *peer,
struct channel *channel,
const char *(*msgname)(int msgtype),
unsigned int (*msgcb)(struct subd *,
const u8 *, const int *fds),
@ -648,12 +649,9 @@ static struct subd *new_subd(struct lightningd *ld,
return tal_free(sd);
}
sd->ld = ld;
if (peer) {
/* FIXME: Use minimal unique pubkey prefix for logs! */
const char *idstr = type_to_string(peer, struct pubkey,
&peer->id);
sd->log = new_log(sd, peer->log_book, "%s(%s):", name, idstr);
tal_free(idstr);
if (channel) {
sd->log = new_log(sd, channel->peer->log_book, "%s-%s", name,
log_prefix(channel->log));
} else {
sd->log = new_log(sd, ld->log_book, "%s(%u):", name, sd->pid);
}
@ -666,7 +664,7 @@ static struct subd *new_subd(struct lightningd *ld,
msg_queue_init(&sd->outq, sd);
tal_add_destructor(sd, destroy_subd);
list_head_init(&sd->reqs);
sd->peer = peer;
sd->channel = channel;
/* conn actually owns daemon: we die when it does. */
sd->conn = io_new_conn(ld, msg_fd, msg_setup, sd);
@ -695,9 +693,9 @@ struct subd *new_global_subd(struct lightningd *ld,
return sd;
}
struct subd *new_peer_subd(struct lightningd *ld,
struct subd *new_channel_subd(struct lightningd *ld,
const char *name,
struct peer *peer,
struct channel *channel,
const char *(*msgname)(int msgtype),
unsigned int (*msgcb)(struct subd *, const u8 *,
const int *fds), ...)
@ -706,7 +704,7 @@ struct subd *new_peer_subd(struct lightningd *ld,
struct subd *sd;
va_start(ap, msgcb);
sd = new_subd(ld, name, peer, msgname, msgcb, &ap);
sd = new_subd(ld, name, channel, msgname, msgcb, &ap);
va_end(ap);
return sd;
}
@ -766,12 +764,12 @@ void subd_shutdown(struct subd *sd, unsigned int seconds)
tal_free(sd);
}
void subd_release_peer(struct subd *owner, struct peer *peer)
void subd_release_channel(struct subd *owner, struct channel *channel)
{
/* If owner is a per-peer-daemon, and not already freeing itself... */
if (owner->peer) {
assert(owner->peer == peer);
owner->peer = NULL;
if (owner->channel) {
assert(owner->channel == channel);
owner->channel = NULL;
tal_free(owner);
}
}

32
lightningd/subd.h
View File

@ -25,8 +25,8 @@ struct subd {
/* Connection. */
struct io_conn *conn;
/* If we are associated with a single peer, this points to it. */
struct peer *peer;
/* If we are associated with a single channel, this points to it. */
struct channel *channel;
/* For logging */
struct log *log;
@ -73,10 +73,10 @@ struct subd *new_global_subd(struct lightningd *ld,
...);
/**
* new_peer_subd - create a new subdaemon for a specific peer.
* new_channel_subd - create a new subdaemon for a specific channel.
* @ld: global state
* @name: basename of daemon
* @peer: peer to associate.
* @channel: channel to associate.
* @msgname: function to get name from messages
* @msgcb: function to call (inside db transaction) when non-fatal message received (or NULL)
* @...: NULL-terminated list of pointers to fds to hand as fd 3, 4...
@ -86,13 +86,13 @@ struct subd *new_global_subd(struct lightningd *ld,
* that many @fds are received before calling again. If it returns -1, the
* subdaemon is shutdown.
*/
struct subd *new_peer_subd(struct lightningd *ld,
const char *name,
struct peer *peer,
const char *(*msgname)(int msgtype),
unsigned int (*msgcb)(struct subd *, const u8 *,
const int *fds),
...);
struct subd *new_channel_subd(struct lightningd *ld,
const char *name,
struct channel *channel,
const char *(*msgname)(int msgtype),
unsigned int (*msgcb)(struct subd *, const u8 *,
const int *fds),
...);
/**
* subd_raw - raw interface to get a subdaemon on an fd (for HSM)
@ -144,14 +144,14 @@ void subd_req_(const tal_t *ctx,
void *replycb_data);
/**
* subd_release_peer - shut down a subdaemon which no longer owns the peer.
* @owner: subd which owned peer.
* @peer: peer to release.
* subd_release_channel - shut down a subdaemon which no longer owns the channel.
* @owner: subd which owned channel.
* @channel: channel to release.
*
* If the subdaemon is not already shutting down, and it is a per-peer
* If the subdaemon is not already shutting down, and it is a per-channel
* subdaemon, this shuts it down.
*/
void subd_release_peer(struct subd *owner, struct peer *peer);
void subd_release_channel(struct subd *owner, struct channel *channel);
/**
* subd_shutdown - try to politely shut down a subdaemon.

2
lightningd/test/run-find_my_path.c
View File

@ -29,7 +29,7 @@ int debug_poll(struct pollfd *fds UNNEEDED, nfds_t nfds UNNEEDED, int timeout UN
void fatal(const char *fmt UNNEEDED, ...)
{ fprintf(stderr, "fatal called!\n"); abort(); }
/* Generated stub for free_htlcs */
void free_htlcs(struct lightningd *ld UNNEEDED, const struct peer *peer UNNEEDED)
void free_htlcs(struct lightningd *ld UNNEEDED, const struct channel *channel UNNEEDED)
{ fprintf(stderr, "free_htlcs called!\n"); abort(); }
/* Generated stub for gossip_init */
void gossip_init(struct lightningd *ld UNNEEDED)

37
wallet/test/run-wallet.c
View File

@ -80,7 +80,7 @@ bool derive_basepoints(const struct privkey *seed UNNEEDED,
bool extract_channel_id(const u8 *in_pkt UNNEEDED, struct channel_id *channel_id UNNEEDED)
{ fprintf(stderr, "extract_channel_id called!\n"); abort(); }
/* Generated stub for find_htlc_out_by_ripemd */
struct htlc_out *find_htlc_out_by_ripemd(const struct peer *peer UNNEEDED,
struct htlc_out *find_htlc_out_by_ripemd(const struct channel *channel UNNEEDED,
const struct ripemd160 *ripemd160 UNNEEDED)
{ fprintf(stderr, "find_htlc_out_by_ripemd called!\n"); abort(); }
/* Generated stub for find_txwatch */
@ -321,28 +321,29 @@ void log_io(struct log *log UNNEEDED, enum log_level dir UNNEEDED, const char *c
/* Generated stub for logv_add */
void logv_add(struct log *log UNNEEDED, const char *fmt UNNEEDED, va_list ap UNNEEDED)
{ fprintf(stderr, "logv_add called!\n"); abort(); }
/* Generated stub for new_channel_subd */
struct subd *new_channel_subd(struct lightningd *ld UNNEEDED,
const char *name UNNEEDED,
struct channel *channel UNNEEDED,
const char *(*msgname)(int msgtype) UNNEEDED,
unsigned int (*msgcb)(struct subd * UNNEEDED, const u8 * UNNEEDED,
const int *fds) UNNEEDED,
...)
{ fprintf(stderr, "new_channel_subd called!\n"); abort(); }
/* Generated stub for new_json_result */
struct json_result *new_json_result(const tal_t *ctx UNNEEDED)
{ fprintf(stderr, "new_json_result called!\n"); abort(); }
/* Generated stub for new_peer_subd */
struct subd *new_peer_subd(struct lightningd *ld UNNEEDED,
const char *name UNNEEDED,
struct peer *peer UNNEEDED,
const char *(*msgname)(int msgtype) UNNEEDED,
unsigned int (*msgcb)(struct subd * UNNEEDED, const u8 * UNNEEDED,
const int *fds) UNNEEDED,
...)
{ fprintf(stderr, "new_peer_subd called!\n"); abort(); }
/* Generated stub for null_response */
struct json_result *null_response(const tal_t *ctx UNNEEDED)
{ fprintf(stderr, "null_response called!\n"); abort(); }
/* Generated stub for onchain_failed_our_htlc */
void onchain_failed_our_htlc(const struct peer *peer UNNEEDED,
void onchain_failed_our_htlc(const struct channel *channel UNNEEDED,
const struct htlc_stub *htlc UNNEEDED,
const char *why UNNEEDED)
{ fprintf(stderr, "onchain_failed_our_htlc called!\n"); abort(); }
/* Generated stub for onchain_fulfilled_htlc */
void onchain_fulfilled_htlc(struct peer *peer UNNEEDED, const struct preimage *preimage UNNEEDED)
void onchain_fulfilled_htlc(struct channel *channel UNNEEDED,
const struct preimage *preimage UNNEEDED)
{ fprintf(stderr, "onchain_fulfilled_htlc called!\n"); abort(); }
/* Generated stub for onchain_wire_type_name */
const char *onchain_wire_type_name(int e UNNEEDED)
@ -351,10 +352,10 @@ const char *onchain_wire_type_name(int e UNNEEDED)
const char *opening_wire_type_name(int e UNNEEDED)
{ fprintf(stderr, "opening_wire_type_name called!\n"); abort(); }
/* Generated stub for peer_got_commitsig */
void peer_got_commitsig(struct peer *peer UNNEEDED, const u8 *msg UNNEEDED)
void peer_got_commitsig(struct channel *channel UNNEEDED, const u8 *msg UNNEEDED)
{ fprintf(stderr, "peer_got_commitsig called!\n"); abort(); }
/* Generated stub for peer_got_revoke */
void peer_got_revoke(struct peer *peer UNNEEDED, const u8 *msg UNNEEDED)
void peer_got_revoke(struct channel *channel UNNEEDED, const u8 *msg UNNEEDED)
{ fprintf(stderr, "peer_got_revoke called!\n"); abort(); }
/* Generated stub for peer_htlcs */
void peer_htlcs(const tal_t *ctx UNNEEDED,
@ -367,15 +368,15 @@ void peer_htlcs(const tal_t *ctx UNNEEDED,
enum side **failed_sides UNNEEDED)
{ fprintf(stderr, "peer_htlcs called!\n"); abort(); }
/* Generated stub for peer_sending_commitsig */
void peer_sending_commitsig(struct peer *peer UNNEEDED, const u8 *msg UNNEEDED)
void peer_sending_commitsig(struct channel *channel UNNEEDED, const u8 *msg UNNEEDED)
{ fprintf(stderr, "peer_sending_commitsig called!\n"); abort(); }
/* Generated stub for sanitize_error */
char *sanitize_error(const tal_t *ctx UNNEEDED, const u8 *errmsg UNNEEDED,
struct channel_id *channel_id UNNEEDED)
{ fprintf(stderr, "sanitize_error called!\n"); abort(); }
/* Generated stub for subd_release_peer */
void subd_release_peer(struct subd *owner UNNEEDED, struct peer *peer UNNEEDED)
{ fprintf(stderr, "subd_release_peer called!\n"); abort(); }
/* Generated stub for subd_release_channel */
void subd_release_channel(struct subd *owner UNNEEDED, struct channel *channel UNNEEDED)
{ fprintf(stderr, "subd_release_channel called!\n"); abort(); }
/* Generated stub for subd_req_ */
void subd_req_(const tal_t *ctx UNNEEDED,
struct subd *sd UNNEEDED,