#include "config.h" #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include static void destroy_peer(struct peer *peer) { peer_node_id_map_del(peer->ld->peers, peer); if (peer->dbid) peer_dbid_map_del(peer->ld->peers_by_dbid, peer); } void peer_set_dbid(struct peer *peer, u64 dbid) { assert(!peer->dbid); assert(dbid); peer->dbid = dbid; peer_dbid_map_add(peer->ld->peers_by_dbid, peer); } struct peer *new_peer(struct lightningd *ld, u64 dbid, const struct node_id *id, const struct wireaddr_internal *addr, const u8 *their_features, bool connected_incoming) { /* We are owned by our channels, and freed manually by destroy_channel */ struct peer *peer = tal(NULL, struct peer); peer->ld = ld; peer->dbid = dbid; peer->id = *id; peer->uncommitted_channel = NULL; peer->addr = *addr; peer->connected_incoming = connected_incoming; peer->remote_addr = NULL; list_head_init(&peer->channels); peer->direction = node_id_idx(&peer->ld->id, &peer->id); peer->connected = PEER_DISCONNECTED; peer->last_connect_attempt.ts.tv_sec = peer->last_connect_attempt.ts.tv_nsec = 0; if (their_features) peer->their_features = tal_dup_talarr(peer, u8, their_features); else peer->their_features = NULL; peer->dev_ignore_htlcs = false; peer_node_id_map_add(ld->peers, peer); if (dbid) peer_dbid_map_add(ld->peers_by_dbid, peer); tal_add_destructor(peer, destroy_peer); return peer; } static void delete_peer(struct peer *peer) { assert(list_empty(&peer->channels)); assert(!peer->uncommitted_channel); /* If it only ever existed because of uncommitted channel, it won't * be in the database */ if (peer->dbid != 0) wallet_delete_peer_if_unused(peer->ld->wallet, peer->dbid); tal_free(peer); } /* Last one out deletes peer. */ void maybe_delete_peer(struct peer *peer) { if (!list_empty(&peer->channels)) return; if (peer->uncommitted_channel) { /* This isn't sufficient to keep it in db! */ if (peer->dbid != 0) { wallet_delete_peer_if_unused(peer->ld->wallet, peer->dbid); peer_dbid_map_del(peer->ld->peers_by_dbid, peer); peer->dbid = 0; } return; } /* Maybe it's reconnected / reconnecting? */ if (peer->connected != PEER_DISCONNECTED) return; delete_peer(peer); } static void peer_channels_cleanup(struct lightningd *ld, const struct node_id *id) { struct peer *peer; struct channel *c, **channels; peer = peer_by_id(ld, id); if (!peer) return; /* Freeing channels can free peer, so gather first. */ channels = tal_arr(tmpctx, struct channel *, 0); list_for_each(&peer->channels, c, list) tal_arr_expand(&channels, c); if (peer->uncommitted_channel) { /* Frees peer if no channels */ kill_uncommitted_channel(peer->uncommitted_channel, "Disconnected"); } else if (tal_count(channels) == 0) /* Was completely idle. */ tal_free(peer); for (size_t i = 0; i < tal_count(channels); i++) { c = channels[i]; if (channel_state_wants_peercomms(c->state)) { channel_cleanup_commands(c, "Disconnected"); channel_fail_transient(c, true, "Disconnected"); } else if (channel_state_uncommitted(c->state)) { channel_unsaved_close_conn(c, "Disconnected"); } } } struct peer *find_peer_by_dbid(struct lightningd *ld, u64 dbid) { return peer_dbid_map_get(ld->peers_by_dbid, dbid); } struct peer *peer_by_id(struct lightningd *ld, const struct node_id *id) { return peer_node_id_map_get(ld->peers, id); } struct peer *peer_from_json(struct lightningd *ld, const char *buffer, const jsmntok_t *peeridtok) { struct node_id peerid; if (!json_to_node_id(buffer, peeridtok, &peerid)) return NULL; return peer_by_id(ld, &peerid); } u8 *p2wpkh_for_keyidx(const tal_t *ctx, struct lightningd *ld, u64 keyidx) { struct pubkey shutdownkey; bip32_pubkey(ld, &shutdownkey, keyidx); return scriptpubkey_p2wpkh(ctx, &shutdownkey); } u8 *p2tr_for_keyidx(const tal_t *ctx, struct lightningd *ld, u64 keyidx) { struct pubkey shutdownkey; bip32_pubkey(ld, &shutdownkey, keyidx); return scriptpubkey_p2tr(ctx, &shutdownkey); } static struct bitcoin_tx *sign_last_tx(const tal_t *ctx, const struct channel *channel, const struct bitcoin_tx *last_tx, const struct bitcoin_signature *last_sig) { struct lightningd *ld = channel->peer->ld; struct bitcoin_signature sig; const u8 *msg; u8 **witness; u64 commit_index = channel->next_index[LOCAL] - 1; struct bitcoin_tx *tx = clone_bitcoin_tx(ctx, last_tx); assert(!tx->wtx->inputs[0].witness); msg = towire_hsmd_sign_commitment_tx(NULL, &channel->peer->id, channel->dbid, tx, &channel->channel_info .remote_fundingkey, commit_index); msg = hsm_sync_req(tmpctx, ld, take(msg)); if (!fromwire_hsmd_sign_commitment_tx_reply(msg, &sig)) fatal("HSM gave bad sign_commitment_tx_reply %s", tal_hex(tmpctx, msg)); witness = bitcoin_witness_2of2(tx, last_sig, &sig, &channel->channel_info.remote_fundingkey, &channel->local_funding_pubkey); bitcoin_tx_input_set_witness(tx, 0, take(witness)); return tx; } bool invalid_last_tx(const struct bitcoin_tx *tx) { /* This problem goes back further, but was discovered just before the * 0.7.1 release. */ #ifdef COMPAT_V070 /* Old bug had commitment txs with no outputs; bitcoin_txid asserts. */ return !tx || !tx->wtx || tx->wtx->num_outputs == 0; #else return false; #endif } static bool commit_tx_send_finished(struct channel *channel, const struct bitcoin_tx *tx, bool success, const char *err, struct anchor_details *adet) { struct bitcoin_txid txid; bitcoin_txid(tx, &txid); /* If it's already mined, stop retransmitting, stop boosting. */ if (wallet_transaction_height(channel->peer->ld->wallet, &txid) != 0) { tal_free(adet); return true; } /* Boost (if possible), and keep trying! */ commit_tx_boost(channel, adet, success); return false; } static struct bitcoin_tx *sign_and_send_last(const tal_t *ctx, struct lightningd *ld, struct channel *channel, const char *cmd_id, const struct bitcoin_tx *last_tx, const struct bitcoin_signature *last_sig) { struct bitcoin_txid txid; struct anchor_details *adet; struct bitcoin_tx *tx; tx = sign_last_tx(ctx, channel, last_tx, last_sig); bitcoin_txid(tx, &txid); wallet_transaction_add(ld->wallet, tx->wtx, 0, 0); wallet_extract_owned_outputs(ld->wallet, tx->wtx, false, NULL, NULL); /* Remember anchor information for commit_tx_boost */ adet = create_anchor_details(NULL, channel, tx); /* Keep broadcasting until we say stop (can fail due to dup, * if they beat us to the broadcast). */ broadcast_tx(channel, ld->topology, channel, tx, cmd_id, false, 0, commit_tx_send_finished, NULL, take(adet)); return tx; } /* FIXME: reorder! */ static enum watch_result funding_spent(struct channel *channel, const struct bitcoin_tx *tx, size_t inputnum UNUSED, const struct block *block); /* We coop-closed channel: if another inflight confirms, force close */ static enum watch_result closed_inflight_depth_cb(struct lightningd *ld, const struct bitcoin_txid *txid, const struct bitcoin_tx *tx, unsigned int depth, struct channel_inflight *inflight) { if (depth == 0) return KEEP_WATCHING; /* This is now the main tx. */ update_channel_from_inflight(ld, inflight->channel, inflight); channel_fail_permanent(inflight->channel, REASON_UNKNOWN, "Inflight tx %s confirmed after mutual close", type_to_string(tmpctx, struct bitcoin_txid, txid)); return DELETE_WATCH; } void drop_to_chain(struct lightningd *ld, struct channel *channel, bool cooperative) { struct channel_inflight *inflight; const char *cmd_id; /* If we're not already (e.g. close before channel fully open), * make sure we're watching for the funding spend */ if (!channel->funding_spend_watch) { log_debug(channel->log, "Adding funding_spend_watch"); channel->funding_spend_watch = watch_txo(channel, ld->topology, channel, &channel->funding, funding_spent); } /* If this was triggered by a close command, get a copy of the cmd id */ cmd_id = cmd_id_from_close_command(tmpctx, ld, channel); /* BOLT #2: * * - if `next_revocation_number` is greater than expected * above, AND `your_last_per_commitment_secret` is correct for that * `next_revocation_number` minus 1: * - MUST NOT broadcast its commitment transaction. */ if (channel->future_per_commitment_point && !cooperative) { log_broken(channel->log, "Cannot broadcast our commitment tx:" " they have a future one"); } else if (channel_state_open_uncommitted(channel->state)) { /* There's no commitment transaction, we can * safely forget this channel */ log_info(channel->log, "Initialized channel (v2) received error" ", we're deleting the channel"); } else if (invalid_last_tx(channel->last_tx)) { log_broken(channel->log, "Cannot broadcast our commitment tx:" " it's invalid! (ancient channel?)"); } else { struct bitcoin_tx *tx COMPILER_WANTS_INIT("gcc 12.3.0"); /* We need to drop *every* commitment transaction to chain */ if (!cooperative && !list_empty(&channel->inflights)) { list_for_each(&channel->inflights, inflight, list) { if (!inflight->last_tx) continue; tx = sign_and_send_last(tmpctx, ld, channel, cmd_id, inflight->last_tx, &inflight->last_sig); } } else tx = sign_and_send_last(tmpctx, ld, channel, cmd_id, channel->last_tx, &channel->last_sig); resolve_close_command(ld, channel, cooperative, tx); } /* In cooperative mode, we're assuming that we closed the right one: * this might not happen if we're splicing, or dual-funding still * opening. So, if we get any unexpected inflight confirming, we * force close. */ if (cooperative) { list_for_each(&channel->inflights, inflight, list) { if (bitcoin_outpoint_eq(&inflight->funding->outpoint, &channel->funding)) { continue; } watch_txid(inflight, ld->topology, &inflight->funding->outpoint.txid, closed_inflight_depth_cb, inflight); } } } void resend_closing_transactions(struct lightningd *ld) { struct peer *peer; struct channel *channel; struct peer_node_id_map_iter it; for (peer = peer_node_id_map_first(ld->peers, &it); peer; peer = peer_node_id_map_next(ld->peers, &it)) { list_for_each(&peer->channels, channel, list) { switch (channel->state) { case CHANNELD_AWAITING_LOCKIN: case CHANNELD_NORMAL: case DUALOPEND_OPEN_INIT: case DUALOPEND_OPEN_COMMIT_READY: case DUALOPEND_OPEN_COMMITTED: case DUALOPEND_AWAITING_LOCKIN: case CHANNELD_AWAITING_SPLICE: case CHANNELD_SHUTTING_DOWN: case CLOSINGD_SIGEXCHANGE: case FUNDING_SPEND_SEEN: case ONCHAIN: case CLOSED: continue; case CLOSINGD_COMPLETE: drop_to_chain(ld, channel, true); continue; case AWAITING_UNILATERAL: drop_to_chain(ld, channel, false); continue; } abort(); } } } void channel_errmsg(struct channel *channel, struct peer_fd *peer_fd, const char *desc, const u8 *err_for_them, bool disconnect, bool warning) { /* Clean up any in-progress open attempts */ channel_cleanup_commands(channel, desc); if (channel_state_uncommitted(channel->state)) { log_info(channel->log, "%s", "Unsaved peer failed." " Deleting channel."); delete_channel(channel); return; } /* No peer_fd means a subd crash or disconnection. */ if (!peer_fd) { /* If the channel is unsaved, we forget it */ channel_fail_transient(channel, disconnect, "%s: %s", channel->owner->name, desc); return; } /* Do we have an error to send? */ if (err_for_them && !channel->error && !warning) channel->error = tal_dup_talarr(channel, u8, err_for_them); /* LND sends "internal error" and we close the channel. But * prior to 0.11 we would turn this into a warning, and they * would recover after a reconnect. So we downgrade, but snark * about it in the logs. */ if (!err_for_them && strends(desc, "internal error")) { channel_fail_transient(channel, disconnect, "%s: %s", channel->owner->name, "lnd sent 'internal error':" " let's give it some space"); return; } /* This is us, sending a warning. */ if (warning) { channel_fail_transient(channel, disconnect, "%s sent %s", channel->owner->name, desc); return; } /* BOLT #1: * * A sending node: *... * - when sending `error`: * - MUST fail the channel(s) referred to by the error message. * - MAY set `channel_id` to all zero to indicate all channels. */ /* FIXME: Close if it's an all-channels error sent or rcvd */ /* BOLT #1: * * A sending node: *... * - when sending `error`: * - MUST fail the channel(s) referred to by the error message. * - MAY set `channel_id` to all zero to indicate all channels. *... * The receiving node: * - upon receiving `error`: * - if `channel_id` is all zero: * - MUST fail all channels with the sending node. * - otherwise: * - MUST fail the channel referred to by `channel_id`, if that channel is with the * sending node. */ /* FIXME: We don't close all channels */ /* We should immediately forget the channel if we receive error during * CHANNELD_AWAITING_LOCKIN if we are fundee. */ if (!err_for_them && channel->opener == REMOTE && channel->state == CHANNELD_AWAITING_LOCKIN) channel_fail_forget(channel, "%s: %s %s", channel->owner->name, err_for_them ? "sent" : "received", desc); else channel_fail_permanent(channel, err_for_them ? REASON_LOCAL : REASON_PROTOCOL, "%s: %s %s", channel->owner->name, err_for_them ? "sent" : "received", desc); } static void json_add_htlcs(struct lightningd *ld, struct json_stream *response, const struct channel *channel) { /* FIXME: make per-channel htlc maps! */ const struct htlc_in *hin; struct htlc_in_map_iter ini; const struct htlc_out *hout; struct htlc_out_map_iter outi; u32 local_feerate = get_feerate(channel->fee_states, channel->opener, LOCAL); /* FIXME: Add more fields. */ json_array_start(response, "htlcs"); for (hin = htlc_in_map_first(ld->htlcs_in, &ini); hin; hin = htlc_in_map_next(ld->htlcs_in, &ini)) { if (hin->key.channel != channel) continue; json_object_start(response, NULL); json_add_string(response, "direction", "in"); json_add_u64(response, "id", hin->key.id); json_add_amount_msat(response, "amount_msat", hin->msat); json_add_u32(response, "expiry", hin->cltv_expiry); json_add_sha256(response, "payment_hash", &hin->payment_hash); json_add_string(response, "state", htlc_state_name(hin->hstate)); if (htlc_is_trimmed(REMOTE, hin->msat, local_feerate, channel->our_config.dust_limit, LOCAL, channel_has(channel, OPT_ANCHOR_OUTPUTS), channel_has(channel, OPT_ANCHORS_ZERO_FEE_HTLC_TX))) json_add_bool(response, "local_trimmed", true); if (hin->status != NULL) json_add_string(response, "status", hin->status); json_object_end(response); } for (hout = htlc_out_map_first(ld->htlcs_out, &outi); hout; hout = htlc_out_map_next(ld->htlcs_out, &outi)) { if (hout->key.channel != channel) continue; json_object_start(response, NULL); json_add_string(response, "direction", "out"); json_add_u64(response, "id", hout->key.id); json_add_amount_msat(response, "amount_msat", hout->msat); json_add_u64(response, "expiry", hout->cltv_expiry); json_add_sha256(response, "payment_hash", &hout->payment_hash); json_add_string(response, "state", htlc_state_name(hout->hstate)); if (htlc_is_trimmed(LOCAL, hout->msat, local_feerate, channel->our_config.dust_limit, LOCAL, channel_has(channel, OPT_ANCHOR_OUTPUTS), channel_has(channel, OPT_ANCHORS_ZERO_FEE_HTLC_TX))) json_add_bool(response, "local_trimmed", true); json_object_end(response); } json_array_end(response); } /* Fee a commitment transaction would currently cost */ static struct amount_sat commit_txfee(const struct channel *channel, struct amount_msat amount, enum side side) { /* FIXME: make per-channel htlc maps! */ const struct htlc_in *hin; struct htlc_in_map_iter ini; const struct htlc_out *hout; struct htlc_out_map_iter outi; struct lightningd *ld = channel->peer->ld; size_t num_untrimmed_htlcs = 0; u32 feerate = get_feerate(channel->fee_states, channel->opener, side); struct amount_sat dust_limit; struct amount_sat fee; bool option_anchor_outputs = channel_has(channel, OPT_ANCHOR_OUTPUTS); bool option_anchors_zero_fee_htlc_tx = channel_has(channel, OPT_ANCHORS_ZERO_FEE_HTLC_TX); if (side == LOCAL) dust_limit = channel->our_config.dust_limit; if (side == REMOTE) dust_limit = channel->channel_info.their_config.dust_limit; /* Assume we tried to add "amount" */ if (!htlc_is_trimmed(side, amount, feerate, dust_limit, side, option_anchor_outputs, option_anchors_zero_fee_htlc_tx)) num_untrimmed_htlcs++; for (hin = htlc_in_map_first(ld->htlcs_in, &ini); hin; hin = htlc_in_map_next(ld->htlcs_in, &ini)) { if (hin->key.channel != channel) continue; if (!htlc_is_trimmed(!side, hin->msat, feerate, dust_limit, side, option_anchor_outputs, option_anchors_zero_fee_htlc_tx)) num_untrimmed_htlcs++; } for (hout = htlc_out_map_first(ld->htlcs_out, &outi); hout; hout = htlc_out_map_next(ld->htlcs_out, &outi)) { if (hout->key.channel != channel) continue; if (!htlc_is_trimmed(side, hout->msat, feerate, dust_limit, side, option_anchor_outputs, option_anchors_zero_fee_htlc_tx)) num_untrimmed_htlcs++; } /* * BOLT #2: * A sending node: *... * - SHOULD NOT offer `amount_msat` if, after adding that HTLC to its * commitment transaction, its remaining balance doesn't allow it to * pay the commitment transaction fee when receiving or sending a * future additional non-dust HTLC while maintaining its channel * reserve. It is recommended that this "fee spike buffer" can * handle twice the current `feerate_per_kw` to ensure * predictability between implementations. */ fee = commit_tx_base_fee(2 * feerate, num_untrimmed_htlcs + 1, option_anchor_outputs, option_anchors_zero_fee_htlc_tx); if (option_anchor_outputs || option_anchors_zero_fee_htlc_tx) { /* BOLT #3: * If `option_anchors` applies to the commitment * transaction, also subtract two times the fixed anchor size * of 330 sats from the funder (either `to_local` or * `to_remote`). */ if (!amount_sat_add(&fee, fee, AMOUNT_SAT(660))) ; /* fee is somehow astronomical already.... */ } return fee; } static void subtract_offered_htlcs(const struct channel *channel, struct amount_msat *amount) { const struct htlc_out *hout; struct htlc_out_map_iter outi; struct lightningd *ld = channel->peer->ld; for (hout = htlc_out_map_first(ld->htlcs_out, &outi); hout; hout = htlc_out_map_next(ld->htlcs_out, &outi)) { if (hout->key.channel != channel) continue; if (!amount_msat_sub(amount, *amount, hout->msat)) *amount = AMOUNT_MSAT(0); } } static void subtract_received_htlcs(const struct channel *channel, struct amount_msat *amount) { const struct htlc_in *hin; struct htlc_in_map_iter ini; struct lightningd *ld = channel->peer->ld; for (hin = htlc_in_map_first(ld->htlcs_in, &ini); hin; hin = htlc_in_map_next(ld->htlcs_in, &ini)) { if (hin->key.channel != channel) continue; if (!amount_msat_sub(amount, *amount, hin->msat)) *amount = AMOUNT_MSAT(0); } } struct amount_msat channel_amount_spendable(const struct channel *channel) { struct amount_msat spendable; bool wumbo; /* Compute how much we can send via this channel in one payment. */ if (!amount_msat_sub_sat(&spendable, channel->our_msat, channel->channel_info.their_config.channel_reserve)) return AMOUNT_MSAT(0); /* Take away any currently-offered HTLCs. */ subtract_offered_htlcs(channel, &spendable); /* If we're opener, subtract txfees we'll need to spend this */ if (channel->opener == LOCAL) { if (!amount_msat_sub_sat(&spendable, spendable, commit_txfee(channel, spendable, LOCAL))) return AMOUNT_MSAT(0); } /* We can't offer an HTLC less than the other side will accept. */ if (amount_msat_less(spendable, channel->channel_info.their_config.htlc_minimum)) return AMOUNT_MSAT(0); wumbo = feature_negotiated(channel->peer->ld->our_features, channel->peer->their_features, OPT_LARGE_CHANNELS); /* We can't offer an HTLC over the max payment threshold either. */ if (amount_msat_greater(spendable, chainparams->max_payment) && !wumbo) { spendable = chainparams->max_payment; } return spendable; } struct amount_msat channel_amount_receivable(const struct channel *channel) { struct amount_msat their_msat, receivable; bool wumbo; /* Compute how much we can receive via this channel in one payment */ if (!amount_sat_sub_msat(&their_msat, channel->funding_sats, channel->our_msat)) their_msat = AMOUNT_MSAT(0); if (!amount_msat_sub_sat(&receivable, their_msat, channel->our_config.channel_reserve)) return AMOUNT_MSAT(0); /* Take away any currently-offered HTLCs. */ subtract_received_htlcs(channel, &receivable); /* If they're opener, subtract txfees they'll need to spend this */ if (channel->opener == REMOTE) { if (!amount_msat_sub_sat(&receivable, receivable, commit_txfee(channel, receivable, REMOTE))) return AMOUNT_MSAT(0); } /* They can't offer an HTLC less than what we will accept. */ if (amount_msat_less(receivable, channel->our_config.htlc_minimum)) return AMOUNT_MSAT(0); wumbo = feature_negotiated(channel->peer->ld->our_features, channel->peer->their_features, OPT_LARGE_CHANNELS); /* They can't offer an HTLC over the max payment threshold either. */ if (amount_msat_greater(receivable, chainparams->max_payment) && !wumbo) { receivable = chainparams->max_payment; } return receivable; } static void json_add_channel(struct lightningd *ld, struct json_stream *response, const char *key, const struct channel *channel, /* Only set for listpeerchannels */ const struct peer *peer) { struct channel_stats channel_stats; struct amount_msat funding_msat; struct amount_sat peer_funded_sats; struct state_change_entry *state_changes; const struct peer_update *peer_update; u32 feerate; json_object_start(response, key); if (peer) { json_add_node_id(response, "peer_id", &peer->id); json_add_bool(response, "peer_connected", peer->connected == PEER_CONNECTED); if (peer->connected == PEER_CONNECTED) { json_add_bool(response, "reestablished", channel->reestablished); } json_add_channel_type(response, "channel_type", channel->type); if (channel->ignore_fee_limits) { json_add_bool(response, "ignore_fee_limits", channel->ignore_fee_limits); } /* This reflects current gossip */ json_object_start(response, "updates"); json_object_start(response, "local"); json_add_amount_msat(response, "htlc_minimum_msat", channel->htlc_minimum_msat); json_add_amount_msat(response, "htlc_maximum_msat", channel->htlc_maximum_msat); json_add_u32(response, "cltv_expiry_delta", ld->config.cltv_expiry_delta); json_add_amount_msat(response, "fee_base_msat", amount_msat(channel->feerate_base)); json_add_u32(response, "fee_proportional_millionths", channel->feerate_ppm); json_object_end(response); peer_update = channel_gossip_get_remote_update(channel); if (peer_update) { json_object_start(response, "remote"); json_add_amount_msat(response, "htlc_minimum_msat", peer_update->htlc_minimum_msat); json_add_amount_msat(response, "htlc_maximum_msat", peer_update->htlc_maximum_msat); json_add_u32(response, "cltv_expiry_delta", peer_update->cltv_delta); json_add_amount_msat(response, "fee_base_msat", amount_msat(peer_update->fee_base)); json_add_u32(response, "fee_proportional_millionths", peer_update->fee_ppm); json_object_end(response); } json_object_end(response); if (channel->last_stable_connection != 0) { json_add_u64(response, "last_stable_connection", channel->last_stable_connection); } } json_add_string(response, "state", channel_state_name(channel)); if (channel->last_tx && !invalid_last_tx(channel->last_tx)) { struct bitcoin_txid txid; bitcoin_txid(channel->last_tx, &txid); json_add_txid(response, "scratch_txid", &txid); json_add_amount_sat_msat(response, "last_tx_fee_msat", bitcoin_tx_compute_fee(channel->last_tx)); } json_object_start(response, "feerate"); feerate = get_feerate(channel->fee_states, channel->opener, LOCAL); json_add_u32(response, feerate_style_name(FEERATE_PER_KSIPA), feerate); json_add_u32(response, feerate_style_name(FEERATE_PER_KBYTE), feerate_to_style(feerate, FEERATE_PER_KBYTE)); json_object_end(response); if (channel->owner) json_add_string(response, "owner", channel->owner->name); if (channel->scid) json_add_short_channel_id(response, "short_channel_id", channel->scid); /* If there is any way we can use the channel we'd better have * a direction attached. Technically we could always add it, * as it's just the lexicographic order between node_ids, but * why bother if we can't use it? */ if (channel->scid || channel->alias[LOCAL] || channel->alias[REMOTE]) json_add_num(response, "direction", node_id_idx(&ld->id, &channel->peer->id)); json_add_string(response, "channel_id", type_to_string(tmpctx, struct channel_id, &channel->cid)); json_add_txid(response, "funding_txid", &channel->funding.txid); json_add_num(response, "funding_outnum", channel->funding.n); if (!list_empty(&channel->inflights)) { struct channel_inflight *initial, *inflight; u32 last_feerate, next_feerate; initial = list_top(&channel->inflights, struct channel_inflight, list); json_add_string(response, "initial_feerate", tal_fmt(tmpctx, "%d%s", initial->funding->feerate, feerate_style_name(FEERATE_PER_KSIPA))); last_feerate = channel_last_funding_feerate(channel); assert(last_feerate > 0); json_add_string(response, "last_feerate", tal_fmt(tmpctx, "%d%s", last_feerate, feerate_style_name(FEERATE_PER_KSIPA))); /* BOLT-9e7723387c8859b511e178485605a0b9133b9869 #2: * - MUST set `funding_feerate_perkw` greater than or equal to * 65/64 times the last sent `funding_feerate_perkw` * rounded down. */ next_feerate = last_feerate * 65 / 64; assert(next_feerate > last_feerate); json_add_string(response, "next_feerate", tal_fmt(tmpctx, "%d%s", next_feerate, feerate_style_name(FEERATE_PER_KSIPA))); /* List the inflights */ json_array_start(response, "inflight"); list_for_each(&channel->inflights, inflight, list) { struct bitcoin_txid txid; json_object_start(response, NULL); json_add_txid(response, "funding_txid", &inflight->funding->outpoint.txid); json_add_num(response, "funding_outnum", inflight->funding->outpoint.n); json_add_string(response, "feerate", tal_fmt(tmpctx, "%d%s", inflight->funding->feerate, feerate_style_name( FEERATE_PER_KSIPA))); json_add_amount_sat_msat(response, "total_funding_msat", inflight->funding->total_funds); json_add_amount_sat_msat(response, "our_funding_msat", inflight->funding->our_funds); json_add_s64(response, "splice_amount", inflight->funding->splice_amnt); /* Add the expected commitment tx id also */ if (inflight->last_tx) { bitcoin_txid(inflight->last_tx, &txid); json_add_txid(response, "scratch_txid", &txid); } json_object_end(response); } json_array_end(response); } if (channel->shutdown_scriptpubkey[LOCAL]) { char *addr = encode_scriptpubkey_to_addr(tmpctx, chainparams, channel->shutdown_scriptpubkey[LOCAL]); if (addr) json_add_string(response, "close_to_addr", addr); json_add_hex_talarr(response, "close_to", channel->shutdown_scriptpubkey[LOCAL]); } json_add_bool( response, "private", !(channel->channel_flags & CHANNEL_FLAGS_ANNOUNCE_CHANNEL)); /* opener and closer */ assert(channel->opener != NUM_SIDES); json_add_string(response, "opener", channel->opener == LOCAL ? "local" : "remote"); if (channel->closer != NUM_SIDES) json_add_string(response, "closer", channel->closer == LOCAL ? "local" : "remote"); if (channel->alias[LOCAL] || channel->alias[REMOTE]) { json_object_start(response, "alias"); if (channel->alias[LOCAL]) json_add_short_channel_id(response, "local", channel->alias[LOCAL]); if (channel->alias[REMOTE]) json_add_short_channel_id(response, "remote", channel->alias[REMOTE]); json_object_end(response); } json_array_start(response, "features"); if (channel_has(channel, OPT_STATIC_REMOTEKEY)) json_add_string(response, NULL, "option_static_remotekey"); if (channel_has(channel, OPT_ANCHOR_OUTPUTS)) json_add_string(response, NULL, "option_anchor_outputs"); if (channel_has(channel, OPT_ANCHORS_ZERO_FEE_HTLC_TX)) json_add_string(response, NULL, "option_anchors_zero_fee_htlc_tx"); if (channel_has(channel, OPT_ZEROCONF)) json_add_string(response, NULL, "option_zeroconf"); if (channel_has(channel, OPT_SCID_ALIAS)) json_add_string(response, NULL, "option_scid_alias"); json_array_end(response); if (!amount_sat_sub(&peer_funded_sats, channel->funding_sats, channel->our_funds)) { log_broken(channel->log, "Overflow subtracing funding %s, our funds %s", type_to_string(tmpctx, struct amount_sat, &channel->funding_sats), type_to_string(tmpctx, struct amount_sat, &channel->our_funds)); peer_funded_sats = AMOUNT_SAT(0); } json_object_start(response, "funding"); if (channel->lease_commit_sig) { struct amount_sat funds, total; if (!amount_msat_to_sat(&funds, channel->push)) { log_broken(channel->log, "Can't convert channel->push %s to sats" " (lease fees?)", type_to_string(tmpctx, struct amount_msat, &channel->push)); funds = AMOUNT_SAT(0); } if (channel->opener == LOCAL) { if (!amount_sat_add(&total, funds, channel->our_funds)) { log_broken(channel->log, "Overflow adding our_funds to push"); total = channel->our_funds; } json_add_amount_sat_msat(response, "local_funds_msat", total); if (!amount_sat_sub(&total, peer_funded_sats, funds)) { log_broken(channel->log, "Underflow sub'ing push from" " peer's funds"); total = peer_funded_sats; } json_add_amount_sat_msat(response, "remote_funds_msat", total); json_add_amount_msat(response, "fee_paid_msat", channel->push); } else { if (!amount_sat_add(&total, peer_funded_sats, funds)) { log_broken(channel->log, "Overflow adding peer funds to push"); total = peer_funded_sats; } json_add_amount_sat_msat(response, "remote_funds_msat", total); if (!amount_sat_sub(&total, channel->our_funds, funds)) { log_broken(channel->log, "Underflow sub'ing push from" " our_funds"); total = channel->our_funds; } json_add_amount_sat_msat(response, "local_funds_msat", total); json_add_amount_msat(response, "fee_rcvd_msat", channel->push); } } else { json_add_amount_sat_msat(response, "local_funds_msat", channel->our_funds); json_add_amount_sat_msat(response, "remote_funds_msat", peer_funded_sats); json_add_amount_msat(response, "pushed_msat", channel->push); } json_object_end(response); if (!amount_sat_to_msat(&funding_msat, channel->funding_sats)) { log_broken(channel->log, "Overflow converting funding %s", type_to_string(tmpctx, struct amount_sat, &channel->funding_sats)); funding_msat = AMOUNT_MSAT(0); } json_add_amount_msat(response, "to_us_msat", channel->our_msat); json_add_amount_msat(response, "min_to_us_msat", channel->msat_to_us_min); json_add_amount_msat(response, "max_to_us_msat", channel->msat_to_us_max); json_add_amount_msat(response, "total_msat", funding_msat); /* routing fees */ json_add_amount_msat(response, "fee_base_msat", amount_msat(channel->feerate_base)); json_add_u32(response, "fee_proportional_millionths", channel->feerate_ppm); /* channel config */ json_add_amount_sat_msat(response, "dust_limit_msat", channel->our_config.dust_limit); json_add_amount_msat(response, "max_total_htlc_in_msat", channel->our_config.max_htlc_value_in_flight); /* The `channel_reserve_satoshis` is imposed on * the *other* side (see `channel_reserve_msat` * function in, it uses `!side` to flip sides). * So our configuration `channel_reserve_satoshis` * is imposed on their side, while their * configuration `channel_reserve_satoshis` is * imposed on ours. */ json_add_amount_sat_msat(response, "their_reserve_msat", channel->our_config.channel_reserve); json_add_amount_sat_msat(response, "our_reserve_msat", channel->channel_info.their_config.channel_reserve); /* append spendable to JSON output */ json_add_amount_msat(response, "spendable_msat", channel_amount_spendable(channel)); /* append receivable to JSON output */ json_add_amount_msat(response, "receivable_msat", channel_amount_receivable(channel)); json_add_amount_msat(response, "minimum_htlc_in_msat", channel->our_config.htlc_minimum); json_add_amount_msat(response, "minimum_htlc_out_msat", channel->htlc_minimum_msat); json_add_amount_msat(response, "maximum_htlc_out_msat", channel->htlc_maximum_msat); /* The `to_self_delay` is imposed on the *other* * side, so our configuration `to_self_delay` is * imposed on their side, while their configuration * `to_self_delay` is imposed on ours. */ json_add_num(response, "their_to_self_delay", channel->our_config.to_self_delay); json_add_num(response, "our_to_self_delay", channel->channel_info.their_config.to_self_delay); json_add_num(response, "max_accepted_htlcs", channel->our_config.max_accepted_htlcs); state_changes = wallet_state_change_get(ld->wallet, tmpctx, channel->dbid); json_array_start(response, "state_changes"); for (size_t i = 0; i < tal_count(state_changes); i++) { json_object_start(response, NULL); json_add_timeiso(response, "timestamp", state_changes[i].timestamp); json_add_string(response, "old_state", channel_state_str(state_changes[i].old_state)); json_add_string(response, "new_state", channel_state_str(state_changes[i].new_state)); json_add_string(response, "cause", channel_change_state_reason_str(state_changes[i].cause)); json_add_string(response, "message", state_changes[i].message); json_object_end(response); } json_array_end(response); json_array_start(response, "status"); for (size_t i = 0; i < ARRAY_SIZE(channel->billboard.permanent); i++) { if (!channel->billboard.permanent[i]) continue; json_add_string(response, NULL, channel->billboard.permanent[i]); } if (channel->billboard.transient) json_add_string(response, NULL, channel->billboard.transient); json_array_end(response); /* Provide channel statistics */ wallet_channel_stats_load(ld->wallet, channel->dbid, &channel_stats); json_add_u64(response, "in_payments_offered", channel_stats.in_payments_offered); json_add_amount_msat(response, "in_offered_msat", channel_stats.in_msatoshi_offered); json_add_u64(response, "in_payments_fulfilled", channel_stats.in_payments_fulfilled); json_add_amount_msat(response, "in_fulfilled_msat", channel_stats.in_msatoshi_fulfilled); json_add_u64(response, "out_payments_offered", channel_stats.out_payments_offered); json_add_amount_msat(response, "out_offered_msat", channel_stats.out_msatoshi_offered); json_add_u64(response, "out_payments_fulfilled", channel_stats.out_payments_fulfilled); json_add_amount_msat(response, "out_fulfilled_msat", channel_stats.out_msatoshi_fulfilled); json_add_htlcs(ld, response, channel); json_object_end(response); } struct peer_connected_hook_payload { struct lightningd *ld; struct wireaddr_internal addr; struct wireaddr *remote_addr; bool incoming; /* We don't keep a pointer to peer: it might be freed! */ struct node_id peer_id; u8 *error; }; static void peer_connected_serialize(struct peer_connected_hook_payload *payload, struct json_stream *stream, struct plugin *plugin) { json_object_start(stream, "peer"); json_add_node_id(stream, "id", &payload->peer_id); json_add_string(stream, "direction", payload->incoming ? "in" : "out"); json_add_string( stream, "addr", type_to_string(stream, struct wireaddr_internal, &payload->addr)); if (payload->remote_addr) json_add_string( stream, "remote_addr", type_to_string(stream, struct wireaddr, payload->remote_addr)); /* Since this is start of hook, peer is always in table! */ json_add_hex_talarr(stream, "features", peer_by_id(payload->ld, &payload->peer_id) ->their_features); json_object_end(stream); /* .peer */ } /* Talk to connectd about an active channel */ static void connect_activate_subd(struct lightningd *ld, struct channel *channel) { const u8 *error; int fds[2]; /* If we have a canned error for this channel, send it now */ if (channel->error) { error = channel->error; goto send_error; } switch (channel->state) { case ONCHAIN: case FUNDING_SPEND_SEEN: case CLOSINGD_COMPLETE: case CLOSED: case DUALOPEND_OPEN_INIT: /* Channel is active */ abort(); case AWAITING_UNILATERAL: /* channel->error is not saved in db, so this can * happen if we restart. */ error = towire_errorfmt(tmpctx, &channel->cid, "Awaiting unilateral close"); goto send_error; case DUALOPEND_OPEN_COMMIT_READY: case DUALOPEND_OPEN_COMMITTED: case DUALOPEND_AWAITING_LOCKIN: assert(!channel->owner); if (socketpair(AF_LOCAL, SOCK_STREAM, 0, fds) != 0) { log_broken(channel->log, "Failed to create socketpair: %s", strerror(errno)); error = towire_warningfmt(tmpctx, &channel->cid, "Trouble in paradise?"); goto send_error; } if (peer_restart_dualopend(channel->peer, new_peer_fd(tmpctx, fds[0]), channel, false)) goto tell_connectd; close(fds[1]); return; case CHANNELD_AWAITING_LOCKIN: case CHANNELD_NORMAL: case CHANNELD_AWAITING_SPLICE: case CHANNELD_SHUTTING_DOWN: case CLOSINGD_SIGEXCHANGE: assert(!channel->owner); if (socketpair(AF_LOCAL, SOCK_STREAM, 0, fds) != 0) { log_broken(channel->log, "Failed to create socketpair: %s", strerror(errno)); error = towire_warningfmt(tmpctx, &channel->cid, "Trouble in paradise?"); goto send_error; } if (peer_start_channeld(channel, new_peer_fd(tmpctx, fds[0]), NULL, true, NULL)) { goto tell_connectd; } close(fds[1]); return; } abort(); tell_connectd: subd_send_msg(ld->connectd, take(towire_connectd_peer_connect_subd(NULL, &channel->peer->id, channel->peer->connectd_counter, &channel->cid))); subd_send_fd(ld->connectd, fds[1]); return; send_error: log_debug(channel->log, "Telling connectd to send error %s", tal_hex(tmpctx, error)); /* Get connectd to send error and close. */ subd_send_msg(ld->connectd, take(towire_connectd_peer_send_msg(NULL, &channel->peer->id, channel->peer->connectd_counter, error))); subd_send_msg(ld->connectd, take(towire_connectd_discard_peer(NULL, &channel->peer->id, channel->peer->connectd_counter))); } static void peer_connected_hook_final(struct peer_connected_hook_payload *payload STEALS) { struct lightningd *ld = payload->ld; struct channel *channel; struct wireaddr_internal addr = payload->addr; struct peer *peer; u8 *error; /* Whatever happens, we free payload (it's currently a child * of the peer, which may be freed if we fail to start * subd). */ tal_steal(tmpctx, payload); /* Peer might have gone away while we were waiting for plugin! */ peer = peer_by_id(ld, &payload->peer_id); if (!peer) return; /* If we disconnected in the meantime, forget about it. * (disconnect will have failed any connect commands). * And if it has reconnected, and we're the second time the * hook has been called, it'll be PEER_CONNECTED. */ if (peer->connected != PEER_CONNECTING) return; /* Check for specific errors of a hook */ if (payload->error) { error = payload->error; goto send_error; } /* Now we finally consider ourselves connected! */ assert(peer->connected == PEER_CONNECTING); peer->connected = PEER_CONNECTED; /* Succeed any connect() commands */ connect_succeeded(ld, peer, payload->incoming, &payload->addr); /* Notify anyone who cares */ notify_connect(ld, &peer->id, payload->incoming, &addr); /* Developer hack to fail all channels on permfail line. */ if (dev_disconnect_permanent(ld)) { list_for_each(&peer->channels, channel, list) { subd_send_msg(ld->connectd, take(towire_connectd_peer_send_msg(NULL, &peer->id, peer->connectd_counter, channel->error))); subd_send_msg(ld->connectd, take(towire_connectd_discard_peer(NULL, &peer->id, peer->connectd_counter))); channel_fail_permanent(channel, REASON_LOCAL, "dev_disconnect permfail"); } return; } /* connect appropriate subds for all (active) channels! */ list_for_each(&peer->channels, channel, list) { /* FIXME: It can race by opening a channel before this! */ if (channel_state_wants_peercomms(channel->state) && !channel->owner) { log_debug(channel->log, "Peer has reconnected, state %s: connecting subd", channel_state_name(channel)); connect_activate_subd(ld, channel); } } return; send_error: log_peer_debug(ld->log, &peer->id, "Telling connectd to send error %s", tal_hex(tmpctx, error)); /* Get connectd to send error and close. */ subd_send_msg(ld->connectd, take(towire_connectd_peer_send_msg(NULL, &peer->id, peer->connectd_counter, error))); subd_send_msg(ld->connectd, take(towire_connectd_discard_peer(NULL, &peer->id, peer->connectd_counter))); } static bool peer_connected_hook_deserialize(struct peer_connected_hook_payload *payload, const char *buffer, const jsmntok_t *toks) { struct lightningd *ld = payload->ld; /* already rejected by prior plugin hook in the chain */ if (payload->error != NULL) return true; if (!toks || !buffer) return true; /* If we had a hook, interpret result. */ const jsmntok_t *t_res = json_get_member(buffer, toks, "result"); const jsmntok_t *t_err = json_get_member(buffer, toks, "error_message"); /* fail */ if (!t_res) fatal("Plugin returned an invalid response to the " "peer_connected hook: %s", buffer); /* reject */ if (json_tok_streq(buffer, t_res, "disconnect")) { payload->error = (u8*)""; if (t_err) { payload->error = towire_warningfmt(tmpctx, NULL, "%.*s", t_err->end - t_err->start, buffer + t_err->start); } log_debug(ld->log, "peer_connected hook rejects and says '%s'", payload->error); /* At this point we suppress other plugins in the chain and * directly move to final */ peer_connected_hook_final(payload); return false; } else if (!json_tok_streq(buffer, t_res, "continue")) fatal("Plugin returned an invalid response to the " "peer_connected hook: %s", buffer); /* call next hook */ return true; } /* Have they/we committed funds to the channel? */ static bool channel_state_relationship(enum channel_state state) { switch (state) { case DUALOPEND_OPEN_INIT: case DUALOPEND_OPEN_COMMIT_READY: case DUALOPEND_OPEN_COMMITTED: case DUALOPEND_AWAITING_LOCKIN: case CHANNELD_AWAITING_LOCKIN: return false; case CLOSINGD_COMPLETE: case AWAITING_UNILATERAL: case FUNDING_SPEND_SEEN: case ONCHAIN: case CLOSED: case CHANNELD_NORMAL: case CHANNELD_AWAITING_SPLICE: case CLOSINGD_SIGEXCHANGE: case CHANNELD_SHUTTING_DOWN: return true; } abort(); } /* We choose the most popular address we've given (if at least 2 give * it), prefering peers which have a channel with us */ struct discovered_addr { bool preferred; /* Port is uniformly set to our configured port in here. */ struct wireaddr addr; }; static int daddr_cmp(const struct discovered_addr *a, const struct discovered_addr *b, void *unused) { return wireaddr_cmp_type(&a->addr, &b->addr, NULL); } static const struct wireaddr *best_remote_addr(const tal_t *ctx, struct lightningd *ld, enum wire_addr_type atype) { struct peer *peer; struct peer_node_id_map_iter it; struct discovered_addr *daddrs; const struct wireaddr *best, *prev; size_t best_score, cur_score, preferred_bonus; daddrs = tal_arr(tmpctx, struct discovered_addr, 0); for (peer = peer_node_id_map_first(ld->peers, &it); peer; peer = peer_node_id_map_next(ld->peers, &it)) { struct discovered_addr daddr; if (!peer->remote_addr) continue; if (peer->remote_addr->type != atype) continue; daddr.preferred = peer_any_channel(peer, channel_state_relationship, NULL); daddr.addr = *peer->remote_addr; daddr.addr.port = ld->config.ip_discovery_port; log_debug(ld->log, "best_remote_addr: peer %s gave addr %s (%s)", type_to_string(tmpctx, struct node_id, &peer->id), fmt_wireaddr(tmpctx, &daddr.addr), daddr.preferred ? "preferred" : "no chan"); tal_arr_expand(&daddrs, daddr); } /* Sort into matching addresses */ asort(daddrs, tal_count(daddrs), daddr_cmp, NULL); /* All the non-preferred peers cannot outvote 1 preferred peer */ preferred_bonus = tal_count(daddrs); best_score = cur_score = 0; best = prev = NULL; for (size_t i = 0; i < tal_count(daddrs); i++) { if (prev && !wireaddr_eq(prev, &daddrs[i].addr)) { if (cur_score > best_score) { best_score = cur_score; best = prev; } cur_score = 0; } cur_score += daddrs[i].preferred ? preferred_bonus : 1; prev = &daddrs[i].addr; } if (cur_score > best_score) { best_score = cur_score; best = prev; } if (!best) { log_debug(ld->log, "node_address: no peers gave remote addresses"); return NULL; } /* Does it agree with what we already know? */ if (wireaddr_arr_contains(ld->announceable, best)) { log_debug(ld->log, "node_address: best address already being announced"); return NULL; } /* This means we got it from one preferred peer and at least one other */ if (best_score > preferred_bonus) { log_debug(ld->log, "node_address: %zu peers gave remote addresses," " best score %zu (preferred)", tal_count(daddrs), best_score); return tal_dup(ctx, struct wireaddr, best); } /* No preferred peers gave us addresses? Use > 1 untrusted */ if (best_score < preferred_bonus && best_score > 1) { log_debug(ld->log, "node_address: %zu peers gave remote addresses," " best score %zu (no preferred)", tal_count(daddrs), best_score); return tal_dup(ctx, struct wireaddr, best); } log_debug(ld->log, "node_address: %zu peers gave remote addresses," " best score %zu: not using", tal_count(daddrs), best_score); return NULL; } /* Consider `remote_addr` from peer: if it could change things, reconsider * what our discoverd IP is. Returns new address, or NULL. */ static const struct wireaddr *update_remote_addr(struct lightningd *ld, const struct wireaddr *remote_addr) { /* failsafe to prevent privacy leakage. */ if (ld->always_use_proxy || ld->config.ip_discovery == OPT_AUTOBOOL_FALSE) return NULL; switch (remote_addr->type) { case ADDR_TYPE_IPV4: /* If it's telling us what we already know, don't reevaluate */ if (!ld->discovered_ip_v4 || !wireaddr_eq(ld->discovered_ip_v4, remote_addr)) { ld->discovered_ip_v4 = tal_free(ld->discovered_ip_v4); ld->discovered_ip_v4 = best_remote_addr(ld, ld, ADDR_TYPE_IPV4); return ld->discovered_ip_v4; } return NULL; case ADDR_TYPE_IPV6: /* If it's telling us what we already know, don't reevaluate */ if (!ld->discovered_ip_v6 || !wireaddr_eq(ld->discovered_ip_v6, remote_addr)) { ld->discovered_ip_v6 = tal_free(ld->discovered_ip_v6); ld->discovered_ip_v6 = best_remote_addr(ld, ld, ADDR_TYPE_IPV6); return ld->discovered_ip_v6; } return NULL; /* ignore all other cases */ case ADDR_TYPE_TOR_V2_REMOVED: case ADDR_TYPE_TOR_V3: case ADDR_TYPE_DNS: return NULL; } abort(); } REGISTER_PLUGIN_HOOK(peer_connected, peer_connected_hook_deserialize, peer_connected_hook_final, peer_connected_serialize, struct peer_connected_hook_payload *); /* Connectd tells us a peer has connected: it never hands us duplicates, since * it holds them until we say peer_disconnected. */ void peer_connected(struct lightningd *ld, const u8 *msg) { struct node_id id; u8 *their_features; struct peer *peer; struct peer_connected_hook_payload *hook_payload; u64 connectd_counter; const char *cmd_id; hook_payload = tal(NULL, struct peer_connected_hook_payload); hook_payload->ld = ld; hook_payload->error = NULL; if (!fromwire_connectd_peer_connected(hook_payload, msg, &id, &connectd_counter, &hook_payload->addr, &hook_payload->remote_addr, &hook_payload->incoming, &their_features)) fatal("Connectd gave bad CONNECT_PEER_CONNECTED message %s", tal_hex(msg, msg)); /* When a peer disconnects, we give subds time to clean themselves up * (this lets connectd ensure they've seen the final messages). But * now it's reconnected, we've gotta force them out. */ peer_channels_cleanup(ld, &id); /* If we're already dealing with this peer, hand off to correct * subdaemon. Otherwise, we'll hand to openingd to wait there. */ peer = peer_by_id(ld, &id); if (!peer) peer = new_peer(ld, 0, &id, &hook_payload->addr, take(their_features), hook_payload->incoming); else { tal_free(peer->their_features); peer->their_features = tal_steal(peer, their_features); } /* We track this, because messages can race between connectd and us. * For example, we could tell it to attach a subd, but it's actually * already reconnected: we would tell it again when we read the * "peer_connected" message, and it would get upset (plus, our first * subd wouldn't die as expected. So we echo this back to connectd * on peer commands, and it knows to ignore if it's wrong. */ peer->connectd_counter = connectd_counter; /* We mark peer in "connecting" state until hooks have passed. */ assert(peer->connected == PEER_DISCONNECTED); peer->connected = PEER_CONNECTING; /* Update peer address and direction */ peer->addr = hook_payload->addr; peer->connected_incoming = hook_payload->incoming; peer->remote_addr = tal_free(peer->remote_addr); hook_payload->peer_id = id; /* If there's a connect command, use its id as basis for hook id */ cmd_id = connect_any_cmd_id(tmpctx, ld, peer); /* Log and update remote_addr for Nat/IP discovery. */ if (hook_payload->remote_addr) { const struct wireaddr *best; log_peer_debug(ld->log, &id, "Peer says it sees our address as: %s", fmt_wireaddr(tmpctx, hook_payload->remote_addr)); peer->remote_addr = tal_dup(peer, struct wireaddr, hook_payload->remote_addr); best = update_remote_addr(ld, peer->remote_addr); if (best) { log_debug(ld->log, "Update our node_announcement for discovered address: %s", fmt_wireaddr(tmpctx, best)); channel_gossip_node_announce(ld); } } plugin_hook_call_peer_connected(ld, cmd_id, hook_payload); } /* connectd tells us a peer has a message and we've not already attached * a subd. Normally this is a race, but it happens for real when opening * a new channel, or referring to a channel we no longer want to talk to * it about. */ void peer_spoke(struct lightningd *ld, const u8 *msg) { struct node_id id; u16 msgtype; u64 connectd_counter; struct channel *channel; struct channel_id channel_id; struct peer *peer; bool dual_fund; u8 *error; int fds[2]; char *errmsg; if (!fromwire_connectd_peer_spoke(msg, msg, &id, &connectd_counter, &msgtype, &channel_id, &errmsg)) fatal("Connectd gave bad CONNECTD_PEER_SPOKE message %s", tal_hex(msg, msg)); /* We must know it, and it must be the right connectd_id */ peer = peer_by_id(ld, &id); assert(peer->connectd_counter == connectd_counter); /* Do we know what channel they're talking about? */ channel = find_channel_by_id(peer, &channel_id); if (channel) { /* If we have a canned error for this channel, send it now */ if (channel->error) { error = channel->error; goto send_error; } if (channel_state_wants_peercomms(channel->state)) { /* If they send an error, handle it immediately. */ if (errmsg) { channel_fail_permanent(channel, REASON_REMOTE, "They sent %s", errmsg); return; } /* If channel is active there are two possibilities: * 1. We have started subd, but channeld hasn't processed * the connectd_peer_connect_subd message yet. * 2. subd exited */ if (channel->owner) { /* We raced... */ return; } log_debug(channel->log, "channel already active"); if (channel->state == DUALOPEND_AWAITING_LOCKIN) { if (socketpair(AF_LOCAL, SOCK_STREAM, 0, fds) != 0) { log_broken(ld->log, "Failed to create socketpair: %s", strerror(errno)); error = towire_warningfmt(tmpctx, &channel_id, "Trouble in paradise?"); goto send_error; } if (peer_restart_dualopend(peer, new_peer_fd(tmpctx, fds[0]), channel, false)) goto tell_connectd; /* FIXME: Send informative error? */ close(fds[1]); } return; } if (msgtype == WIRE_CHANNEL_REESTABLISH) { log_debug(channel->log, "Reestablish on %s channel: using channeld to reply", channel_state_name(channel)); if (socketpair(AF_LOCAL, SOCK_STREAM, 0, fds) != 0) { log_broken(channel->log, "Failed to create socketpair: %s", strerror(errno)); error = towire_warningfmt(tmpctx, &channel->cid, "Trouble in paradise?"); goto send_error; } if (peer_start_channeld(channel, new_peer_fd(tmpctx, fds[0]), NULL, true, true)) { goto tell_connectd; } /* FIXME: Send informative error? */ close(fds[1]); return; } /* Send generic error. */ error = towire_errorfmt(tmpctx, &channel_id, "channel in state %s", channel_state_name(channel)); goto send_error; } dual_fund = feature_negotiated(ld->our_features, peer->their_features, OPT_DUAL_FUND); /* OK, it's an unknown channel. Create a new one if they're trying. */ switch (msgtype) { case WIRE_OPEN_CHANNEL: if (dual_fund) { error = towire_errorfmt(tmpctx, &channel_id, "OPT_DUAL_FUND: cannot use open_channel"); goto send_error; } if (peer->uncommitted_channel) { error = towire_errorfmt(tmpctx, &channel_id, "Multiple simulteneous opens not supported"); goto send_error; } peer->uncommitted_channel = new_uncommitted_channel(peer); peer->uncommitted_channel->cid = channel_id; if (socketpair(AF_LOCAL, SOCK_STREAM, 0, fds) != 0) { log_broken(ld->log, "Failed to create socketpair: %s", strerror(errno)); error = towire_warningfmt(tmpctx, &channel_id, "Trouble in paradise?"); goto send_error; } if (peer_start_openingd(peer, new_peer_fd(tmpctx, fds[0]))) { goto tell_connectd; } /* FIXME: Send informative error? */ close(fds[1]); return; case WIRE_OPEN_CHANNEL2: if (!dual_fund) { error = towire_errorfmt(tmpctx, &channel_id, "Didn't negotiate OPT_DUAL_FUND: cannot use open_channel2"); goto send_error; } channel = new_unsaved_channel(peer, peer->ld->config.fee_base, peer->ld->config.fee_per_satoshi); channel->cid = channel_id; if (socketpair(AF_LOCAL, SOCK_STREAM, 0, fds) != 0) { log_broken(ld->log, "Failed to create socketpair: %s", strerror(errno)); error = towire_warningfmt(tmpctx, &channel_id, "Trouble in paradise?"); goto send_error; } if (peer_start_dualopend(peer, new_peer_fd(tmpctx, fds[0]), channel)) goto tell_connectd; /* FIXME: Send informative error? */ close(fds[1]); return; } /* Weird message? Log and reply with error. */ log_peer_unusual(ld->log, &peer->id, "Unknown channel %s for %s", type_to_string(tmpctx, struct channel_id, &channel_id), peer_wire_name(msgtype)); error = towire_errorfmt(tmpctx, &channel_id, "Unknown channel for %s", peer_wire_name(msgtype)); send_error: log_peer_debug(ld->log, &peer->id, "Telling connectd to send error %s", tal_hex(tmpctx, error)); /* Get connectd to send error and close. */ subd_send_msg(ld->connectd, take(towire_connectd_peer_send_msg(NULL, &peer->id, peer->connectd_counter, error))); subd_send_msg(ld->connectd, take(towire_connectd_discard_peer(NULL, &peer->id, peer->connectd_counter))); return; tell_connectd: subd_send_msg(ld->connectd, take(towire_connectd_peer_connect_subd(NULL, &id, peer->connectd_counter, &channel_id))); subd_send_fd(ld->connectd, fds[1]); } struct disconnect_command { struct list_node list; /* Command structure. This is the parent of the close command. */ struct command *cmd; /* node being disconnected. */ struct node_id id; }; static void destroy_disconnect_command(struct disconnect_command *dc) { list_del(&dc->list); } void peer_disconnect_done(struct lightningd *ld, const u8 *msg) { struct node_id id; u64 connectd_counter; struct disconnect_command *i, *next; struct peer *p; if (!fromwire_connectd_peer_disconnect_done(msg, &id, &connectd_counter)) fatal("Connectd gave bad PEER_DISCONNECT_DONE message %s", tal_hex(msg, msg)); /* If we still have peer, it's disconnected now */ /* FIXME: We should keep peers until it tells us they're disconnected, * and not free when no more channels. */ p = peer_by_id(ld, &id); if (p) { struct channel *channel; assert(p->connectd_counter == connectd_counter); log_peer_debug(ld->log, &id, "peer_disconnect_done"); p->connected = PEER_DISCONNECTED; list_for_each(&p->channels, channel, list) channel_gossip_channel_disconnect(channel); } /* If you were trying to connect, it failed. */ connect_failed_disconnect(ld, &id, p && !p->connected_incoming ? &p->addr : NULL); /* Fire off plugin notifications */ notify_disconnect(ld, &id); /* Wake any disconnect commands (removes self from list) */ list_for_each_safe(&ld->disconnect_commands, i, next, list) { if (!node_id_eq(&i->id, &id)) continue; was_pending(command_success(i->cmd, json_stream_success(i->cmd))); } /* If connection was only thing keeping it, this will delete it. */ if (p) maybe_delete_peer(p); } void update_channel_from_inflight(struct lightningd *ld, struct channel *channel, const struct channel_inflight *inflight) { struct wally_psbt *psbt_copy; channel->funding = inflight->funding->outpoint; channel->funding_sats = inflight->funding->total_funds; channel->our_funds = inflight->funding->our_funds; if (!amount_sat_add_sat_s64(&channel->our_funds, channel->our_funds, inflight->funding->splice_amnt)) { channel_fail_permanent(channel, REASON_LOCAL, "Updaing channel view for splice causes" " an invalid satoshi amount wrapping," " channel: %s, initial funds: %s, splice" " banace change: %s", type_to_string(tmpctx, struct channel_id, &channel->cid), type_to_string(tmpctx, struct amount_sat, &channel->our_funds), inflight->funding->splice_amnt); } /* Lease infos ! */ channel->lease_expiry = inflight->lease_expiry; channel->push = inflight->lease_fee; tal_free(channel->lease_commit_sig); channel->lease_commit_sig = tal_dup_or_null(channel, secp256k1_ecdsa_signature, inflight->lease_commit_sig); channel->lease_chan_max_msat = inflight->lease_chan_max_msat; channel->lease_chan_max_ppt = inflight->lease_chan_max_ppt; tal_free(channel->blockheight_states); channel->blockheight_states = new_height_states(channel, channel->opener, &inflight->lease_blockheight_start); /* Make a 'clone' of this tx */ psbt_copy = clone_psbt(channel, inflight->last_tx->psbt); channel_set_last_tx(channel, bitcoin_tx_with_psbt(channel, psbt_copy), &inflight->last_sig); /* Update the reserve */ channel_update_reserve(channel, &channel->channel_info.their_config, inflight->funding->total_funds); wallet_channel_save(ld->wallet, channel); } static enum watch_result funding_depth_cb(struct lightningd *ld, const struct bitcoin_txid *txid, const struct bitcoin_tx *tx, unsigned int depth, struct channel *channel) { /* This is stub channel, we don't activate anything! */ if (is_stub_scid(channel->scid)) return DELETE_WATCH; /* We only use this to watch the current funding tx */ assert(bitcoin_txid_eq(txid, &channel->funding.txid)); channel->depth = depth; log_debug(channel->log, "Funding tx %s depth %u of %u", type_to_string(tmpctx, struct bitcoin_txid, txid), depth, channel->minimum_depth); /* Reorged out? */ if (depth == 0) { /* That's not entirely unexpected in early states */ switch (channel->state) { case DUALOPEND_AWAITING_LOCKIN: case DUALOPEND_OPEN_INIT: case DUALOPEND_OPEN_COMMIT_READY: case DUALOPEND_OPEN_COMMITTED: /* Shouldn't be here! */ channel_internal_error(channel, "Bad %s state: %s", __func__, channel_state_name(channel)); return DELETE_WATCH; case CHANNELD_AWAITING_LOCKIN: /* That's not entirely unexpected in early states */ log_debug(channel->log, "Funding tx %s reorganized out!", type_to_string(tmpctx, struct bitcoin_txid, txid)); channel->scid = tal_free(channel->scid); return KEEP_WATCHING; /* But it's often Bad News in later states */ case CHANNELD_AWAITING_SPLICE: case CHANNELD_NORMAL: /* If we opened, or it's zero-conf, we trust them anyway. */ if (channel->opener == LOCAL || channel->minimum_depth == 0) { const char *str; str = tal_fmt(tmpctx, "Funding tx %s reorganized out, but %s...", type_to_string(tmpctx, struct bitcoin_txid, txid), channel->opener == LOCAL ? "we opened it" : "zeroconf anyway"); /* Log even if not connected! */ if (!channel->owner) log_info(channel->log, "%s", str); channel_fail_transient(channel, true, "%s", str); return KEEP_WATCHING; } /* fall thru */ case AWAITING_UNILATERAL: case CHANNELD_SHUTTING_DOWN: case CLOSINGD_SIGEXCHANGE: case CLOSINGD_COMPLETE: case FUNDING_SPEND_SEEN: case ONCHAIN: case CLOSED: break; } channel_internal_error(channel, "Funding transaction has been reorged out in state %s!", channel_state_name(channel)); return KEEP_WATCHING; } if (!depthcb_update_scid(channel, txid, &channel->funding)) return DELETE_WATCH; switch (channel->state) { /* We should not be in the callback! */ case DUALOPEND_AWAITING_LOCKIN: case DUALOPEND_OPEN_INIT: case DUALOPEND_OPEN_COMMIT_READY: case DUALOPEND_OPEN_COMMITTED: abort(); case AWAITING_UNILATERAL: case CHANNELD_SHUTTING_DOWN: case CLOSINGD_SIGEXCHANGE: case CLOSINGD_COMPLETE: case FUNDING_SPEND_SEEN: case ONCHAIN: case CLOSED: /* If not awaiting lockin/announce, it doesn't care any more */ log_debug(channel->log, "Funding tx %s confirmed, but peer in state %s", type_to_string(tmpctx, struct bitcoin_txid, txid), channel_state_name(channel)); return DELETE_WATCH; case CHANNELD_AWAITING_LOCKIN: /* This may be redundant, and may be public later, but * make sure we tell gossipd at least once */ if (depth >= channel->minimum_depth && channel->remote_channel_ready) { lockin_complete(channel, CHANNELD_AWAITING_LOCKIN); } /* Fall thru */ case CHANNELD_NORMAL: case CHANNELD_AWAITING_SPLICE: channeld_tell_depth(channel, txid, depth); if (depth < ANNOUNCE_MIN_DEPTH || depth < channel->minimum_depth) return KEEP_WATCHING; /* Normal state and past announce depth? Stop bothering us! */ return DELETE_WATCH; } abort(); } static enum watch_result funding_spent(struct channel *channel, const struct bitcoin_tx *tx, size_t inputnum UNUSED, const struct block *block) { struct bitcoin_txid txid; struct channel_inflight *inflight; bitcoin_txid(tx, &txid); /* If we're doing a splice, we expect the funding transaction to be * spent, so don't freak out and just keep watching in that case */ list_for_each(&channel->inflights, inflight, list) { if (bitcoin_txid_eq(&txid, &inflight->funding->outpoint.txid)) { /* splice_locked is a special flag that indicates this * is a memory-only inflight acting as a race condition * safeguard. When we see this, it is our responsability * to clean up this memory-only inflight. */ if (inflight->splice_locked_memonly) { tal_free(inflight); return DELETE_WATCH; } return KEEP_WATCHING; } } wallet_channeltxs_add(channel->peer->ld->wallet, channel, WIRE_ONCHAIND_INIT, &txid, 0, block->height); return onchaind_funding_spent(channel, tx, block->height); } void channel_watch_wrong_funding(struct lightningd *ld, struct channel *channel) { /* Watch the "wrong" funding too, in case we spend it. */ if (channel->shutdown_wrong_funding) { watch_txo(channel, ld->topology, channel, channel->shutdown_wrong_funding, funding_spent); } } void channel_watch_funding(struct lightningd *ld, struct channel *channel) { log_debug(channel->log, "Watching for funding txid: %s", type_to_string(tmpctx, struct bitcoin_txid, &channel->funding.txid)); watch_txid(channel, ld->topology, &channel->funding.txid, funding_depth_cb, channel); tal_free(channel->funding_spend_watch); channel->funding_spend_watch = watch_txo(channel, ld->topology, channel, &channel->funding, funding_spent); channel_watch_wrong_funding(ld, channel); } static void json_add_peer(struct lightningd *ld, struct json_stream *response, struct peer *p, const enum log_level *ll) { struct channel *channel; u32 num_channels; json_object_start(response, NULL); json_add_node_id(response, "id", &p->id); json_add_bool(response, "connected", p->connected == PEER_CONNECTED); num_channels = 0; list_for_each(&p->channels, channel, list) num_channels++; json_add_num(response, "num_channels", num_channels); if (p->connected == PEER_CONNECTED) { json_array_start(response, "netaddr"); json_add_string(response, NULL, type_to_string(tmpctx, struct wireaddr_internal, &p->addr)); json_array_end(response); /* If peer reports our IP remote_addr, add that here */ if (p->remote_addr) json_add_string(response, "remote_addr", fmt_wireaddr(response, p->remote_addr)); } /* Note: If !PEER_CONNECTED, peer may use different features on reconnect */ json_add_hex_talarr(response, "features", p->their_features); if (lightningd_deprecated_out_ok(ld, ld->deprecated_ok, "listpeers", "channels", "v23.02", "v24.02")) { json_array_start(response, "channels"); json_add_uncommitted_channel(response, p->uncommitted_channel, NULL); list_for_each(&p->channels, channel, list) { if (channel_state_uncommitted(channel->state)) json_add_unsaved_channel(response, channel, NULL); else json_add_channel(ld, response, NULL, channel, NULL); } json_array_end(response); } if (ll) json_add_log(response, ld->log_book, &p->id, *ll); json_object_end(response); } static struct command_result *json_listpeers(struct command *cmd, const char *buffer, const jsmntok_t *obj UNNEEDED, const jsmntok_t *params) { enum log_level *ll; struct node_id *specific_id; struct peer *peer; struct json_stream *response; if (!param(cmd, buffer, params, p_opt("id", param_node_id, &specific_id), p_opt("level", param_loglevel, &ll), NULL)) return command_param_failed(); response = json_stream_success(cmd); json_array_start(response, "peers"); if (specific_id) { peer = peer_by_id(cmd->ld, specific_id); if (peer) json_add_peer(cmd->ld, response, peer, ll); } else { struct peer_node_id_map_iter it; for (peer = peer_node_id_map_first(cmd->ld->peers, &it); peer; peer = peer_node_id_map_next(cmd->ld->peers, &it)) { json_add_peer(cmd->ld, response, peer, ll); } } json_array_end(response); return command_success(cmd, response); } static const struct json_command listpeers_command = { "listpeers", "network", json_listpeers, "Show current peers, if {level} is set, include logs for {id}" }; /* Comment added to satisfice AUTODATA */ AUTODATA(json_command, &listpeers_command); static void json_add_scb(struct command *cmd, const char *fieldname, struct json_stream *response, struct channel *c) { u8 *scb = tal_arr(cmd, u8, 0); towire_scb_chan(&scb, c->scb); json_add_hex_talarr(response, fieldname, scb); } /* This will return a SCB for all the channels currently loaded * in the in-memory channel */ static struct command_result *json_staticbackup(struct command *cmd, const char *buffer, const jsmntok_t *obj UNNEEDED, const jsmntok_t *params) { struct json_stream *response; struct peer *peer; struct channel *channel; struct peer_node_id_map_iter it; if (!param(cmd, buffer, params, NULL)) return command_param_failed(); response = json_stream_success(cmd); json_array_start(response, "scb"); for (peer = peer_node_id_map_first(cmd->ld->peers, &it); peer; peer = peer_node_id_map_next(cmd->ld->peers, &it)) { list_for_each(&peer->channels, channel, list){ if (!channel->scb) continue; json_add_scb(cmd, NULL, response, channel); } } json_array_end(response); return command_success(cmd, response); } static const struct json_command staticbackup_command = { "staticbackup", "backup", json_staticbackup, "Returns SCB of all the channels currently present in the DB" }; /* Comment added to satisfice AUTODATA */ AUTODATA(json_command, &staticbackup_command); static void json_add_peerchannels(struct lightningd *ld, struct json_stream *response, const struct peer *peer) { struct channel *channel; json_add_uncommitted_channel(response, peer->uncommitted_channel, peer); list_for_each(&peer->channels, channel, list) { if (channel_state_uncommitted(channel->state)) json_add_unsaved_channel(response, channel, peer); else json_add_channel(ld, response, NULL, channel, peer); } } static struct command_result *json_listpeerchannels(struct command *cmd, const char *buffer, const jsmntok_t *obj UNNEEDED, const jsmntok_t *params) { struct node_id *peer_id; struct peer *peer; struct json_stream *response; /* FIME: filter by status */ if (!param(cmd, buffer, params, p_opt("id", param_node_id, &peer_id), NULL)) return command_param_failed(); response = json_stream_success(cmd); json_array_start(response, "channels"); if (peer_id) { peer = peer_by_id(cmd->ld, peer_id); if (peer) json_add_peerchannels(cmd->ld, response, peer); } else { struct peer_node_id_map_iter it; for (peer = peer_node_id_map_first(cmd->ld->peers, &it); peer; peer = peer_node_id_map_next(cmd->ld->peers, &it)) { json_add_peerchannels(cmd->ld, response, peer); } } json_array_end(response); return command_success(cmd, response); } static const struct json_command listpeerchannels_command = { "listpeerchannels", "network", json_listpeerchannels, "Show channels with direct peers." }; AUTODATA(json_command, &listpeerchannels_command); struct command_result * command_find_channel(struct command *cmd, const char *name, const char *buffer, const jsmntok_t *tok, struct channel **channel) { struct lightningd *ld = cmd->ld; struct channel_id cid; struct short_channel_id scid; struct peer *peer; if (json_tok_channel_id(buffer, tok, &cid)) { struct peer_node_id_map_iter it; for (peer = peer_node_id_map_first(ld->peers, &it); peer; peer = peer_node_id_map_next(ld->peers, &it)) { list_for_each(&peer->channels, (*channel), list) { if (!channel_state_wants_peercomms((*channel)->state)) continue; if (channel_id_eq(&(*channel)->cid, &cid)) return NULL; } } return command_fail_badparam(cmd, name, buffer, tok, "Channel id not found"); } else if (json_to_short_channel_id(buffer, tok, &scid)) { *channel = any_channel_by_scid(ld, &scid, true); if (!*channel) return command_fail_badparam(cmd, name, buffer, tok, "Short channel id not found"); return NULL; } else { return command_fail_badparam(cmd, name, buffer, tok, "should be a channel ID or short channel ID"); } } static void setup_peer(struct peer *peer, u32 delay) { struct channel *channel; struct channel_inflight *inflight; struct lightningd *ld = peer->ld; bool connect = false; list_for_each(&peer->channels, channel, list) { switch (channel->state) { case DUALOPEND_OPEN_INIT: case DUALOPEND_OPEN_COMMIT_READY: case DUALOPEND_OPEN_COMMITTED: /* Nothing to watch */ continue; /* Normal cases where we watch funding */ case CHANNELD_AWAITING_LOCKIN: case CHANNELD_NORMAL: case CHANNELD_SHUTTING_DOWN: case CLOSINGD_SIGEXCHANGE: /* We still want to watch spend, to tell onchaind: */ case CLOSINGD_COMPLETE: case AWAITING_UNILATERAL: case FUNDING_SPEND_SEEN: case ONCHAIN: case CLOSED: channel_watch_funding(ld, channel); break; /* We need to watch all inflights which may open channel */ case DUALOPEND_AWAITING_LOCKIN: list_for_each(&channel->inflights, inflight, list) watch_opening_inflight(ld, inflight); break; /* We need to watch all inflights which may splice */ case CHANNELD_AWAITING_SPLICE: list_for_each(&channel->inflights, inflight, list) watch_splice_inflight(ld, inflight); break; } if (channel_state_wants_peercomms(channel->state)) connect = true; } /* Make sure connectd knows to try reconnecting. */ if (connect) { ld->num_startup_connects++; /* To delay, make it seem like we just connected. */ if (delay > 0) { peer->reconnect_delay = delay; peer->last_connect_attempt = time_now(); } try_reconnect(peer, peer, &peer->addr); } } void setup_peers(struct lightningd *ld) { struct peer *p; /* Avoid thundering herd: after first five, delay by 1 second. */ int delay = -5; struct peer_node_id_map_iter it; for (p = peer_node_id_map_first(ld->peers, &it); p; p = peer_node_id_map_next(ld->peers, &it)) { setup_peer(p, delay > 0 ? delay : 0); delay++; } /* In case there are no peers at all to connect to */ if (ld->num_startup_connects == 0) channel_gossip_startup_done(ld); } /* Pull peers, channels and HTLCs from db, and wire them up. */ struct htlc_in_map *load_channels_from_wallet(struct lightningd *ld) { struct peer *peer; struct htlc_in_map *unconnected_htlcs_in = tal(ld, struct htlc_in_map); struct peer_node_id_map_iter it; /* Load channels from database */ if (!wallet_init_channels(ld->wallet)) fatal("Could not load channels from the database"); /* First we load the incoming htlcs */ for (peer = peer_node_id_map_first(ld->peers, &it); peer; peer = peer_node_id_map_next(ld->peers, &it)) { struct channel *channel; list_for_each(&peer->channels, channel, list) { if (!wallet_htlcs_load_in_for_channel(ld->wallet, channel, ld->htlcs_in)) { fatal("could not load htlcs for channel"); } } } /* Make a copy of the htlc_map: entries removed as they're matched */ htlc_in_map_copy(unconnected_htlcs_in, ld->htlcs_in); /* Now we load the outgoing HTLCs, so we can connect them. */ for (peer = peer_node_id_map_first(ld->peers, &it); peer; peer = peer_node_id_map_next(ld->peers, &it)) { struct channel *channel; list_for_each(&peer->channels, channel, list) { if (!wallet_htlcs_load_out_for_channel(ld->wallet, channel, ld->htlcs_out, unconnected_htlcs_in)) { fatal("could not load outgoing htlcs for channel"); } } } #ifdef COMPAT_V061 fixup_htlcs_out(ld); #endif /* COMPAT_V061 */ return unconnected_htlcs_in; } static struct command_result *param_peer(struct command *cmd, const char *name, const char *buffer, const jsmntok_t *tok, struct peer **peer) { struct node_id peerid; if (!json_to_node_id(buffer, tok, &peerid)) return command_fail_badparam(cmd, name, buffer, tok, "invalid peer id"); *peer = peer_by_id(cmd->ld, &peerid); if (!*peer) return command_fail(cmd, JSONRPC2_INVALID_PARAMS, "Unknown peer '%.*s'", tok->end - tok->start, buffer + tok->start); return NULL; } static struct command_result *json_disconnect(struct command *cmd, const char *buffer, const jsmntok_t *obj UNNEEDED, const jsmntok_t *params) { struct disconnect_command *dc; struct peer *peer; struct channel *channel; bool *force; if (!param_check(cmd, buffer, params, p_req("id", param_peer, &peer), p_opt_def("force", param_bool, &force, false), NULL)) return command_param_failed(); if (peer->connected == PEER_DISCONNECTED) { return command_fail(cmd, LIGHTNINGD, "Peer not connected"); } channel = peer_any_channel(peer, channel_state_wants_peercomms, NULL); if (channel && !*force) { return command_fail(cmd, LIGHTNINGD, "Peer has (at least one) channel in state %s", channel_state_name(channel)); } if (command_check_only(cmd)) return command_check_done(cmd); force_peer_disconnect(cmd->ld, peer, "disconnect command"); /* Connectd tells us when it's finally disconnected */ dc = tal(cmd, struct disconnect_command); dc->cmd = cmd; dc->id = peer->id; list_add_tail(&cmd->ld->disconnect_commands, &dc->list); tal_add_destructor(dc, destroy_disconnect_command); return command_still_pending(cmd); } static const struct json_command disconnect_command = { "disconnect", "network", json_disconnect, "Disconnect from {id} that has previously been connected to using connect; with {force} set, even if it has a current channel" }; AUTODATA(json_command, &disconnect_command); static struct command_result *json_getinfo(struct command *cmd, const char *buffer, const jsmntok_t *obj UNNEEDED, const jsmntok_t *params) { struct json_stream *response; struct peer *peer; struct channel *channel; unsigned int pending_channels = 0, active_channels = 0, inactive_channels = 0, num_peers = 0; size_t count_announceable; struct peer_node_id_map_iter it; if (!param(cmd, buffer, params, NULL)) return command_param_failed(); response = json_stream_success(cmd); json_add_node_id(response, "id", &cmd->ld->id); json_add_string(response, "alias", (const char *)cmd->ld->alias); json_add_hex_talarr(response, "color", cmd->ld->rgb); /* Add some peer and channel stats */ for (peer = peer_node_id_map_first(cmd->ld->peers, &it); peer; peer = peer_node_id_map_next(cmd->ld->peers, &it)) { num_peers++; list_for_each(&peer->channels, channel, list) { switch (channel->state) { case CHANNELD_AWAITING_LOCKIN: case DUALOPEND_OPEN_INIT: case DUALOPEND_OPEN_COMMIT_READY: case DUALOPEND_OPEN_COMMITTED: case DUALOPEND_AWAITING_LOCKIN: pending_channels++; continue; case CHANNELD_AWAITING_SPLICE: case CHANNELD_SHUTTING_DOWN: case CHANNELD_NORMAL: case CLOSINGD_SIGEXCHANGE: active_channels++; continue; case CLOSINGD_COMPLETE: case AWAITING_UNILATERAL: case FUNDING_SPEND_SEEN: case ONCHAIN: case CLOSED: inactive_channels++; continue; } abort(); } } json_add_num(response, "num_peers", num_peers); json_add_num(response, "num_pending_channels", pending_channels); json_add_num(response, "num_active_channels", active_channels); json_add_num(response, "num_inactive_channels", inactive_channels); /* Add network info */ json_array_start(response, "address"); if (cmd->ld->listen) { /* These are the addresses we're announcing */ count_announceable = tal_count(cmd->ld->announceable); for (size_t i = 0; i < count_announceable; i++) json_add_address(response, NULL, cmd->ld->announceable+i); /* Add discovered IPs if we announce them. * Also see `create_node_announcement` in `gossip_generation.c`. */ if ((cmd->ld->config.ip_discovery == OPT_AUTOBOOL_AUTO && count_announceable == 0) || cmd->ld->config.ip_discovery == OPT_AUTOBOOL_TRUE) { if (cmd->ld->discovered_ip_v4 != NULL && !wireaddr_arr_contains( cmd->ld->announceable, cmd->ld->discovered_ip_v4)) json_add_address(response, NULL, cmd->ld->discovered_ip_v4); if (cmd->ld->discovered_ip_v6 != NULL && !wireaddr_arr_contains( cmd->ld->announceable, cmd->ld->discovered_ip_v6)) json_add_address(response, NULL, cmd->ld->discovered_ip_v6); } json_array_end(response); /* This is what we're actually bound to. */ json_array_start(response, "binding"); for (size_t i = 0; i < tal_count(cmd->ld->binding); i++) json_add_address_internal(response, NULL, cmd->ld->binding+i); } json_array_end(response); json_add_string(response, "version", version()); /* If we're still syncing, put the height we're up to here, so * they can see progress! Otherwise use the height gossipd knows * about, so tests work properly. */ if (!topology_synced(cmd->ld->topology)) { json_add_num(response, "blockheight", get_block_height(cmd->ld->topology)); } else { json_add_num(response, "blockheight", cmd->ld->gossip_blockheight); } json_add_string(response, "network", chainparams->network_name); json_add_amount_msat(response, "fees_collected_msat", wallet_total_forward_fees(cmd->ld->wallet)); json_add_string(response, "lightning-dir", cmd->ld->config_netdir); if (!cmd->ld->topology->bitcoind->synced) json_add_string(response, "warning_bitcoind_sync", "Bitcoind is not up-to-date with network."); else if (!topology_synced(cmd->ld->topology)) json_add_string(response, "warning_lightningd_sync", "Still loading latest blocks from bitcoind."); u8 **bits = cmd->ld->our_features->bits; json_object_start(response, "our_features"); json_add_hex_talarr(response, "init", featurebits_or(cmd, bits[INIT_FEATURE], bits[GLOBAL_INIT_FEATURE])); json_add_hex_talarr(response, "node", bits[NODE_ANNOUNCE_FEATURE]); json_add_hex_talarr(response, "channel", bits[CHANNEL_FEATURE]); json_add_hex_talarr(response, "invoice", bits[BOLT11_FEATURE]); json_object_end(response); return command_success(cmd, response); } static const struct json_command getinfo_command = { "getinfo", "utility", json_getinfo, "Show information about this node" }; AUTODATA(json_command, &getinfo_command); /* Wait for at least a specific blockheight, then return, or time out. */ struct waitblockheight_waiter { /* struct lightningd::waitblockheight_commands. */ struct list_node list; /* Command structure. This is the parent of the close command. */ struct command *cmd; /* The block height being waited for. */ u32 block_height; /* Whether we have been removed from the list. */ bool removed; }; /* Completes a pending waitblockheight. */ static struct command_result * waitblockheight_complete(struct command *cmd, u32 block_height) { struct json_stream *response; response = json_stream_success(cmd); json_add_num(response, "blockheight", block_height); return command_success(cmd, response); } /* Called when command is destroyed without being resolved. */ static void destroy_waitblockheight_waiter(struct waitblockheight_waiter *w) { if (!w->removed) list_del(&w->list); } /* Called on timeout. */ static void timeout_waitblockheight_waiter(struct waitblockheight_waiter *w) { list_del(&w->list); w->removed = true; tal_steal(tmpctx, w); was_pending(command_fail(w->cmd, WAIT_TIMEOUT, "Timed out.")); } /* Called by lightningd at each new block. */ void waitblockheight_notify_new_block(struct lightningd *ld, u32 block_height) { struct waitblockheight_waiter *w, *n; char *to_delete = tal(NULL, char); /* Use safe since we could resolve commands and thus * trigger removal of list elements. */ list_for_each_safe(&ld->waitblockheight_commands, w, n, list) { /* Skip commands that have not been reached yet. */ if (w->block_height > block_height) continue; list_del(&w->list); w->removed = true; tal_steal(to_delete, w); was_pending(waitblockheight_complete(w->cmd, block_height)); } tal_free(to_delete); } static struct command_result *json_waitblockheight(struct command *cmd, const char *buffer, const jsmntok_t *obj, const jsmntok_t *params) { unsigned int *target_block_height; u32 block_height; unsigned int *timeout; struct waitblockheight_waiter *w; if (!param(cmd, buffer, params, p_req("blockheight", param_number, &target_block_height), p_opt_def("timeout", param_number, &timeout, 60), NULL)) return command_param_failed(); /* Check if already reached anyway. */ block_height = get_block_height(cmd->ld->topology); if (*target_block_height <= block_height) return waitblockheight_complete(cmd, block_height); /* Create a new waitblockheight command. */ w = tal(cmd, struct waitblockheight_waiter); tal_add_destructor(w, &destroy_waitblockheight_waiter); list_add(&cmd->ld->waitblockheight_commands, &w->list); w->cmd = cmd; w->block_height = *target_block_height; w->removed = false; /* Install the timeout. */ (void) new_reltimer(cmd->ld->timers, w, time_from_sec(*timeout), &timeout_waitblockheight_waiter, w); return command_still_pending(cmd); } static const struct json_command waitblockheight_command = { "waitblockheight", "utility", &json_waitblockheight, "Wait for the blockchain to reach {blockheight}, up to " "{timeout} seconds." }; AUTODATA(json_command, &waitblockheight_command); static bool channel_state_can_setchannel(enum channel_state state) { switch (state) { case CHANNELD_NORMAL: case CHANNELD_AWAITING_SPLICE: case CHANNELD_AWAITING_LOCKIN: case DUALOPEND_AWAITING_LOCKIN: return true; case DUALOPEND_OPEN_INIT: case DUALOPEND_OPEN_COMMIT_READY: case DUALOPEND_OPEN_COMMITTED: case CLOSINGD_SIGEXCHANGE: case CHANNELD_SHUTTING_DOWN: case CLOSINGD_COMPLETE: case AWAITING_UNILATERAL: case FUNDING_SPEND_SEEN: case ONCHAIN: case CLOSED: return false; } abort(); } static struct command_result *param_channel_or_all(struct command *cmd, const char *name, const char *buffer, const jsmntok_t *tok, struct channel ***channels) { struct command_result *res; struct peer *peer; struct channel *channel; *channels = tal_arr(cmd, struct channel *, 0); /* early return the easy case */ if (json_tok_streq(buffer, tok, "all")) { *channels = tal_free(*channels); return NULL; } /* Find channels by peer_id */ peer = peer_from_json(cmd->ld, buffer, tok); if (peer) { list_for_each(&peer->channels, channel, list) { if (channel_state_can_setchannel(channel->state)) tal_arr_expand(channels, channel); } if (tal_count(*channels) == 0) return command_fail(cmd, LIGHTNINGD, "Could not find any active channels of peer with that id"); return NULL; } /* Find channel by id or scid */ res = command_find_channel(cmd, name, buffer, tok, &channel); if (res) return res; /* check channel is found and in valid state */ if (!channel_state_can_setchannel(channel->state)) return command_fail_badparam(cmd, name, buffer, tok, tal_fmt(tmpctx, "Channel in state %s", channel_state_name(channel))); tal_arr_expand(channels, channel); return NULL; } /* Fee base is a u32, but it's convenient to let them specify it using * msat etc. suffix. */ static struct command_result *param_msat_u32(struct command *cmd, const char *name, const char *buffer, const jsmntok_t *tok, u32 **num) { struct amount_msat *msat; struct command_result *res; /* Parse just like an msat. */ res = param_msat(cmd, name, buffer, tok, &msat); if (res) return res; *num = tal(cmd, u32); if (!amount_msat_to_u32(*msat, *num)) { return command_fail_badparam(cmd, name, buffer, tok, "exceeds u32 max"); } return NULL; } static void set_channel_config(struct command *cmd, struct channel *channel, u32 *base, u32 *ppm, struct amount_msat *htlc_min, struct amount_msat *htlc_max, u32 delaysecs, bool *ignore_fee_limits, struct json_stream *response) { bool warn_cannot_set_min = false, warn_cannot_set_max = false; /* We only need to defer values if we *increase* fees (or drop * max, increase min); we always allow users to overpay fees. */ if ((base && *base > channel->feerate_base) || (ppm && *ppm > channel->feerate_ppm) || (htlc_min && amount_msat_greater(*htlc_min, channel->htlc_minimum_msat)) || (htlc_max && amount_msat_less(*htlc_max, channel->htlc_maximum_msat))) { channel->old_feerate_timeout = timeabs_add(time_now(), time_from_sec(delaysecs)); channel->old_feerate_base = channel->feerate_base; channel->old_feerate_ppm = channel->feerate_ppm; channel->old_htlc_minimum_msat = channel->htlc_minimum_msat; channel->old_htlc_maximum_msat = channel->htlc_maximum_msat; } /* set new values */ if (base) channel->feerate_base = *base; if (ppm) channel->feerate_ppm = *ppm; if (htlc_min) { struct amount_msat actual_min; /* We can't send something they'll refuse: check that here. */ actual_min = channel->channel_info.their_config.htlc_minimum; if (amount_msat_less(*htlc_min, actual_min)) { warn_cannot_set_min = true; channel->htlc_minimum_msat = actual_min; } else channel->htlc_minimum_msat = *htlc_min; } if (htlc_max) { struct amount_msat actual_max; /* Can't set it greater than actual capacity. */ actual_max = htlc_max_possible_send(channel); if (amount_msat_greater(*htlc_max, actual_max)) { warn_cannot_set_max = true; channel->htlc_maximum_msat = actual_max; } else channel->htlc_maximum_msat = *htlc_max; } if (ignore_fee_limits) channel->ignore_fee_limits = *ignore_fee_limits; /* Tell channeld about the new acceptable feerates */ if (channel->owner && streq(channel->owner->name, "channeld") && ignore_fee_limits) { channel_update_feerates(cmd->ld, channel); } /* save values to database */ wallet_channel_save(cmd->ld->wallet, channel); /* write JSON response entry */ json_object_start(response, NULL); json_add_node_id(response, "peer_id", &channel->peer->id); json_add_string(response, "channel_id", type_to_string(tmpctx, struct channel_id, &channel->cid)); if (channel->scid) json_add_short_channel_id(response, "short_channel_id", channel->scid); json_add_amount_msat(response, "fee_base_msat", amount_msat(channel->feerate_base)); json_add_u32(response, "fee_proportional_millionths", channel->feerate_ppm); json_add_amount_msat(response, "minimum_htlc_out_msat", channel->htlc_minimum_msat); if (warn_cannot_set_min) json_add_string(response, "warning_htlcmin_too_low", "Set minimum_htlc_out_msat to minimum allowed by peer"); json_add_amount_msat(response, "maximum_htlc_out_msat", channel->htlc_maximum_msat); json_add_bool(response, "ignore_fee_limits", channel->ignore_fee_limits); if (warn_cannot_set_max) json_add_string(response, "warning_htlcmax_too_high", "Set maximum_htlc_out_msat to maximum possible in channel"); json_object_end(response); } static struct command_result *json_setchannel(struct command *cmd, const char *buffer, const jsmntok_t *obj UNNEEDED, const jsmntok_t *params) { struct json_stream *response; struct peer *peer; struct channel **channels; u32 *base, *ppm, *delaysecs; struct amount_msat *htlc_min, *htlc_max; bool *ignore_fee_limits; /* Parse the JSON command */ if (!param_check(cmd, buffer, params, p_req("id", param_channel_or_all, &channels), p_opt("feebase", param_msat_u32, &base), p_opt("feeppm", param_number, &ppm), p_opt("htlcmin", param_msat, &htlc_min), p_opt("htlcmax", param_msat, &htlc_max), p_opt_def("enforcedelay", param_number, &delaysecs, 600), p_opt("ignorefeelimits", param_bool, &ignore_fee_limits), NULL)) return command_param_failed(); /* Prevent obviously incorrect things! */ if (htlc_min && htlc_max && amount_msat_less(*htlc_max, *htlc_min)) { return command_fail(cmd, LIGHTNINGD, "htlcmax cannot be less than htlcmin"); } if (command_check_only(cmd)) return command_check_done(cmd); /* Open JSON response object for later iteration */ response = json_stream_success(cmd); json_array_start(response, "channels"); /* If the users requested 'all' channels we need to iterate */ if (channels == NULL) { struct peer_node_id_map_iter it; for (peer = peer_node_id_map_first(cmd->ld->peers, &it); peer; peer = peer_node_id_map_next(cmd->ld->peers, &it)) { struct channel *channel; list_for_each(&peer->channels, channel, list) { if (!channel_state_can_setchannel(channel->state)) continue; set_channel_config(cmd, channel, base, ppm, htlc_min, htlc_max, *delaysecs, ignore_fee_limits, response); } } /* single peer should be updated */ } else { for (size_t i = 0; i < tal_count(channels); i++) { set_channel_config(cmd, channels[i], base, ppm, htlc_min, htlc_max, *delaysecs, ignore_fee_limits, response); } } /* Close and return response */ json_array_end(response); return command_success(cmd, response); } static const struct json_command setchannel_command = { "setchannel", "channels", json_setchannel, "Sets fees and/or htlc_max for channel with {id} " "(either peer ID, channel ID, short channel ID or 'all'). " "If {feebase}, {feeppm} or {htlcmax} is missing, it is unchanged." "{base} can also be defined in other units, for example '1sat'. " "If {id} is 'all', the fees will be applied for all channels. " }; AUTODATA(json_command, &setchannel_command); /* dev hack, don't use for real interfaces, which have to handle channel ids, or multiple channels */ static struct command_result *param_dev_channel(struct command *cmd, const char *name, const char *buffer, const jsmntok_t *tok, struct channel **channel) { struct peer *peer; struct command_result *res; bool more_than_one; res = param_peer(cmd, name, buffer, tok, &peer); if (res) return res; *channel = peer_any_channel(peer, channel_state_wants_peercomms, &more_than_one); if (!*channel) return command_fail_badparam(cmd, name, buffer, tok, "No channel with that peer"); if (more_than_one) return command_fail_badparam(cmd, name, buffer, tok, "More than one channel with that peer"); return NULL; } static struct command_result *json_sign_last_tx(struct command *cmd, const char *buffer, const jsmntok_t *obj UNNEEDED, const jsmntok_t *params) { struct json_stream *response; struct channel *channel; struct bitcoin_tx *tx; if (!param(cmd, buffer, params, p_req("id", param_dev_channel, &channel), NULL)) return command_param_failed(); response = json_stream_success(cmd); log_debug(channel->log, "dev-sign-last-tx: signing tx with %zu outputs", channel->last_tx->wtx->num_outputs); tx = sign_last_tx(cmd, channel, channel->last_tx, &channel->last_sig); json_add_tx(response, "tx", tx); /* If we've got inflights, return them */ if (!list_empty(&channel->inflights)) { struct channel_inflight *inflight; json_array_start(response, "inflights"); list_for_each(&channel->inflights, inflight, list) { tx = sign_last_tx(cmd, channel, inflight->last_tx, &inflight->last_sig); json_object_start(response, NULL); json_add_txid(response, "funding_txid", &inflight->funding->outpoint.txid); json_add_tx(response, "tx", tx); json_object_end(response); } json_array_end(response); } return command_success(cmd, response); } static const struct json_command dev_sign_last_tx = { "dev-sign-last-tx", "developer", json_sign_last_tx, "Sign and show the last commitment transaction with peer {id}", .dev_only = true, }; AUTODATA(json_command, &dev_sign_last_tx); static struct command_result *json_dev_fail(struct command *cmd, const char *buffer, const jsmntok_t *obj UNNEEDED, const jsmntok_t *params) { struct channel *channel; if (!param(cmd, buffer, params, p_req("id", param_dev_channel, &channel), NULL)) return command_param_failed(); channel_fail_permanent(channel, REASON_USER, "Failing due to dev-fail command"); return command_success(cmd, json_stream_success(cmd)); } static const struct json_command dev_fail_command = { "dev-fail", "developer", json_dev_fail, "Fail with peer {id}", .dev_only = true, }; AUTODATA(json_command, &dev_fail_command); static void dev_reenable_commit_finished(struct subd *channeld UNUSED, const u8 *resp UNUSED, const int *fds UNUSED, struct command *cmd) { was_pending(command_success(cmd, json_stream_success(cmd))); } static struct command_result *json_dev_reenable_commit(struct command *cmd, const char *buffer, const jsmntok_t *obj UNNEEDED, const jsmntok_t *params) { u8 *msg; struct channel *channel; if (!param_check(cmd, buffer, params, p_req("id", param_dev_channel, &channel), NULL)) return command_param_failed(); if (!channel->owner) { return command_fail(cmd, LIGHTNINGD, "Peer has no owner"); } if (!streq(channel->owner->name, "channeld")) { return command_fail(cmd, LIGHTNINGD, "Peer owned by %s", channel->owner->name); } if (command_check_only(cmd)) return command_check_done(cmd); msg = towire_channeld_dev_reenable_commit(channel); subd_req(channel, channel->owner, take(msg), -1, 0, dev_reenable_commit_finished, cmd); return command_still_pending(cmd); } static const struct json_command dev_reenable_commit = { "dev-reenable-commit", "developer", json_dev_reenable_commit, "Re-enable the commit timer on peer {id}", .dev_only = true, }; AUTODATA(json_command, &dev_reenable_commit); struct dev_forget_channel_cmd { struct short_channel_id scid; struct channel *channel; bool force; struct command *cmd; }; static void process_dev_forget_channel(struct bitcoind *bitcoind UNUSED, const struct bitcoin_tx_output *txout, void *arg) { struct json_stream *response; struct dev_forget_channel_cmd *forget = arg; if (txout != NULL && !forget->force) { was_pending(command_fail(forget->cmd, LIGHTNINGD, "Cowardly refusing to forget channel with an " "unspent funding output, if you know what " "you're doing you can override with " "`force=true`, otherwise consider `close` or " "`dev-fail`! If you force and the channel " "confirms we will not track the funds in the " "channel")); return; } response = json_stream_success(forget->cmd); json_add_bool(response, "forced", forget->force); json_add_bool(response, "funding_unspent", txout != NULL); json_add_txid(response, "funding_txid", &forget->channel->funding.txid); /* Set error so we don't try to reconnect. */ forget->channel->error = towire_errorfmt(forget->channel, &forget->channel->cid, "dev_forget_channel"); delete_channel(forget->channel); was_pending(command_success(forget->cmd, response)); } static struct command_result *json_dev_forget_channel(struct command *cmd, const char *buffer, const jsmntok_t *obj UNNEEDED, const jsmntok_t *params) { struct peer *peer; struct channel *channel; struct short_channel_id *scid; struct channel_id *find_cid; struct dev_forget_channel_cmd *forget; bool *force; if (!param_check(cmd, buffer, params, p_req("id", param_peer, &peer), p_opt("short_channel_id", param_short_channel_id, &scid), p_opt("channel_id", param_channel_id, &find_cid), p_opt_def("force", param_bool, &force, false), NULL)) return command_param_failed(); forget = tal(cmd, struct dev_forget_channel_cmd); forget->cmd = cmd; forget->force = *force; forget->channel = NULL; list_for_each(&peer->channels, channel, list) { /* Check for channel id first */ if (find_cid) { if (!channel_id_eq(find_cid, &channel->cid)) continue; } if (scid) { if (!channel->scid) continue; if (!short_channel_id_eq(channel->scid, scid)) continue; } if (forget->channel) { return command_fail(cmd, LIGHTNINGD, "Multiple channels:" " please specify short_channel_id"); } forget->channel = channel; } if (!forget->channel) { return command_fail(cmd, LIGHTNINGD, "No channels matching that peer_id%s", scid ? " and that short_channel_id" : ""); } if (channel_has_htlc_out(forget->channel) || channel_has_htlc_in(forget->channel)) { return command_fail(cmd, LIGHTNINGD, "This channel has HTLCs attached and it is " "not safe to forget it. Please use `close` " "or `dev-fail` instead."); } if (command_check_only(cmd)) return command_check_done(cmd); if (!channel_state_uncommitted(forget->channel->state)) bitcoind_getutxout(cmd->ld->topology->bitcoind, &forget->channel->funding, process_dev_forget_channel, forget); return command_still_pending(cmd); } static const struct json_command dev_forget_channel_command = { "dev-forget-channel", "developer", json_dev_forget_channel, "Forget the channel with peer {id}, ignore UTXO check with {force}='true'.", .verbose = "Forget the channel with peer {id}. Checks if the channel is still active by checking its funding transaction. Check can be ignored by setting {force} to 'true'", .dev_only = true, }; AUTODATA(json_command, &dev_forget_channel_command); static void channeld_memleak_req_done(struct subd *channeld, const u8 *msg, const int *fds UNUSED, struct leak_detect *leaks) { bool found_leak; if (!fromwire_channeld_dev_memleak_reply(msg, &found_leak)) fatal("Bad channel_dev_memleak"); if (found_leak) report_subd_memleak(leaks, channeld); } static void onchaind_memleak_req_done(struct subd *onchaind, const u8 *msg, const int *fds UNUSED, struct leak_detect *leaks) { bool found_leak; if (!fromwire_onchaind_dev_memleak_reply(msg, &found_leak)) fatal("Bad onchaind_dev_memleak"); if (found_leak) report_subd_memleak(leaks, onchaind); } static void openingd_memleak_req_done(struct subd *open_daemon, const u8 *msg, const int *fds UNUSED, struct leak_detect *leaks) { bool found_leak; if (!fromwire_openingd_dev_memleak_reply(msg, &found_leak)) fatal("Bad opening_dev_memleak"); if (found_leak) report_subd_memleak(leaks, open_daemon); } static void dualopend_memleak_req_done(struct subd *dualopend, const u8 *msg, const int *fds UNUSED, struct leak_detect *leaks) { bool found_leak; if (!fromwire_dualopend_dev_memleak_reply(msg, &found_leak)) fatal("Bad dualopend_dev_memleak"); if (found_leak) report_subd_memleak(leaks, dualopend); } void peer_dev_memleak(struct lightningd *ld, struct leak_detect *leaks) { struct peer *p; struct peer_node_id_map_iter it; for (p = peer_node_id_map_first(ld->peers, &it); p; p = peer_node_id_map_next(ld->peers, &it)) { struct channel *c; if (p->uncommitted_channel && p->uncommitted_channel->open_daemon) { struct subd *openingd = p->uncommitted_channel->open_daemon; start_leak_request(subd_req(openingd, openingd, take(towire_openingd_dev_memleak(NULL)), -1, 0, openingd_memleak_req_done, leaks), leaks); } list_for_each(&p->channels, c, list) { if (!c->owner) continue; if (streq(c->owner->name, "channeld")) { start_leak_request(subd_req(c, c->owner, take(towire_channeld_dev_memleak(NULL)), -1, 0, channeld_memleak_req_done, leaks), leaks); } else if (streq(c->owner->name, "onchaind")) { start_leak_request(subd_req(c, c->owner, take(towire_onchaind_dev_memleak(NULL)), -1, 0, onchaind_memleak_req_done, leaks), leaks); } else if (streq(c->owner->name, "dualopend")) { start_leak_request(subd_req(c, c->owner, take(towire_dualopend_dev_memleak(NULL)), -1, 0, dualopend_memleak_req_done, leaks), leaks); } } } }