Browse Source
gossipd.c is doing too many things: this is a start. Signed-off-by: Rusty Russell <rusty@rustcorp.com.au>travis-debug
Rusty Russell
5 years ago
7 changed files with 614 additions and 547 deletions
@ -0,0 +1,65 @@ |
|||
#ifndef LIGHTNING_GOSSIPD_GOSSIPD_H |
|||
#define LIGHTNING_GOSSIPD_GOSSIPD_H |
|||
#include "config.h" |
|||
#include <ccan/list/list.h> |
|||
#include <ccan/short_types/short_types.h> |
|||
#include <common/node_id.h> |
|||
|
|||
/* We talk to `hsmd` to sign our gossip messages with the node key */ |
|||
#define HSM_FD 3 |
|||
/* connectd asks us for help finding nodes, and gossip fds for new peers */ |
|||
#define CONNECTD_FD 4 |
|||
|
|||
/*~ The core daemon structure: */ |
|||
struct daemon { |
|||
/* Who am I? Helps us find ourself in the routing map. */ |
|||
struct node_id id; |
|||
|
|||
/* Peers we are gossiping to: id is unique */ |
|||
struct list_head peers; |
|||
|
|||
/* Connection to lightningd. */ |
|||
struct daemon_conn *master; |
|||
|
|||
/* Connection to connect daemon. */ |
|||
struct daemon_conn *connectd; |
|||
|
|||
/* Routing information */ |
|||
struct routing_state *rstate; |
|||
|
|||
/* chainhash for checking/making gossip msgs */ |
|||
struct bitcoin_blkid chain_hash; |
|||
|
|||
/* Timers: we batch gossip, and also refresh announcements */ |
|||
struct timers timers; |
|||
|
|||
/* Minimum interval for generating updated gossip */ |
|||
u32 gossip_min_interval; |
|||
|
|||
/* Global features to list in node_announcement. */ |
|||
u8 *globalfeatures; |
|||
|
|||
/* Alias (not NUL terminated) and favorite color for node_announcement */ |
|||
u8 alias[32]; |
|||
u8 rgb[3]; |
|||
|
|||
/* What addresses we can actually announce. */ |
|||
struct wireaddr *announcable; |
|||
|
|||
/* Do we think we're missing gossip? Contains timer to re-check */ |
|||
struct oneshot *gossip_missing; |
|||
|
|||
/* Channels we've heard about, but don't know. */ |
|||
struct short_channel_id *unknown_scids; |
|||
|
|||
/* Timer until we can send a new node_announcement */ |
|||
struct oneshot *node_announce_timer; |
|||
}; |
|||
|
|||
/* Search for a peer. */ |
|||
struct peer *find_peer(struct daemon *daemon, const struct node_id *id); |
|||
|
|||
/* Queue a gossip message for the peer: the subdaemon on the other end simply
|
|||
* forwards it to the peer. */ |
|||
void queue_peer_msg(struct peer *peer, const u8 *msg TAKES); |
|||
#endif /* LIGHTNING_GOSSIPD_GOSSIPD_H */ |
|||
@ -0,0 +1,456 @@ |
|||
/* Routines to make our own gossip messages */ |
|||
#include <ccan/mem/mem.h> |
|||
#include <common/memleak.h> |
|||
#include <common/timeout.h> |
|||
#include <common/utils.h> |
|||
#include <common/wireaddr.h> |
|||
#include <errno.h> |
|||
#include <gossipd/gen_gossip_peerd_wire.h> |
|||
#include <gossipd/gossip_store.h> |
|||
#include <gossipd/gossipd.h> |
|||
#include <gossipd/make_gossip.h> |
|||
#include <hsmd/gen_hsm_wire.h> |
|||
#include <wire/gen_peer_wire.h> |
|||
#include <wire/wire_sync.h> |
|||
|
|||
/* Create a node_announcement with the given signature. It may be NULL in the
|
|||
* case we need to create a provisional announcement for the HSM to sign. |
|||
* This is called twice: once with the dummy signature to get it signed and a |
|||
* second time to build the full packet with the signature. The timestamp is |
|||
* handed in rather than using time_now() internally, since that could change |
|||
* between the dummy creation and the call with a signature. */ |
|||
static u8 *create_node_announcement(const tal_t *ctx, struct daemon *daemon, |
|||
const secp256k1_ecdsa_signature *sig, |
|||
u32 timestamp) |
|||
{ |
|||
u8 *addresses = tal_arr(tmpctx, u8, 0); |
|||
u8 *announcement; |
|||
size_t i; |
|||
|
|||
if (!sig) |
|||
sig = talz(tmpctx, secp256k1_ecdsa_signature); |
|||
|
|||
for (i = 0; i < tal_count(daemon->announcable); i++) |
|||
towire_wireaddr(&addresses, &daemon->announcable[i]); |
|||
|
|||
announcement = |
|||
towire_node_announcement(ctx, sig, daemon->globalfeatures, timestamp, |
|||
&daemon->id, daemon->rgb, daemon->alias, |
|||
addresses); |
|||
return announcement; |
|||
} |
|||
|
|||
/* Helper to get non-signature, non-timestamp parts of (valid!) channel_update */ |
|||
void get_cupdate_parts(const u8 *channel_update, |
|||
const u8 *parts[2], |
|||
size_t sizes[2]) |
|||
{ |
|||
/* BOLT #7:
|
|||
* |
|||
* 1. type: 258 (`channel_update`) |
|||
* 2. data: |
|||
* * [`signature`:`signature`] |
|||
* * [`chain_hash`:`chain_hash`] |
|||
* * [`short_channel_id`:`short_channel_id`] |
|||
* * [`u32`:`timestamp`] |
|||
*... |
|||
*/ |
|||
/* Note: 2 bytes for `type` field */ |
|||
/* We already checked it's valid before accepting */ |
|||
assert(tal_count(channel_update) > 2 + 64 + 32 + 8 + 4); |
|||
parts[0] = channel_update + 2 + 64; |
|||
sizes[0] = 32 + 8; |
|||
parts[1] = channel_update + 2 + 64 + 32 + 8 + 4; |
|||
sizes[1] = tal_count(channel_update) - (64 + 2 + 32 + 8 + 4); |
|||
} |
|||
|
|||
/* Is this channel_update different from prev (not sigs and timestamps)? */ |
|||
bool cupdate_different(struct gossip_store *gs, |
|||
const struct half_chan *hc, |
|||
const u8 *cupdate) |
|||
{ |
|||
const u8 *oparts[2], *nparts[2]; |
|||
size_t osizes[2], nsizes[2]; |
|||
const u8 *orig; |
|||
|
|||
/* Get last one we have. */ |
|||
orig = gossip_store_get(tmpctx, gs, hc->bcast.index); |
|||
get_cupdate_parts(orig, oparts, osizes); |
|||
get_cupdate_parts(cupdate, nparts, nsizes); |
|||
|
|||
return !memeq(oparts[0], osizes[0], nparts[0], nsizes[0]) |
|||
|| !memeq(oparts[1], osizes[1], nparts[1], nsizes[1]); |
|||
} |
|||
|
|||
/* Get non-signature, non-timestamp parts of (valid!) node_announcement */ |
|||
static void get_nannounce_parts(const u8 *node_announcement, |
|||
const u8 *parts[2], |
|||
size_t sizes[2]) |
|||
{ |
|||
size_t len; |
|||
const u8 *flen; |
|||
|
|||
/* BOLT #7:
|
|||
* |
|||
* 1. type: 257 (`node_announcement`) |
|||
* 2. data: |
|||
* * [`signature`:`signature`] |
|||
* * [`u16`:`flen`] |
|||
* * [`flen*byte`:`features`] |
|||
* * [`u32`:`timestamp`] |
|||
*... |
|||
*/ |
|||
/* Note: 2 bytes for `type` field */ |
|||
/* We already checked it's valid before accepting */ |
|||
assert(tal_count(node_announcement) > 2 + 64); |
|||
parts[0] = node_announcement + 2 + 64; |
|||
|
|||
/* Read flen to get size */ |
|||
flen = parts[0]; |
|||
len = tal_count(node_announcement) - (2 + 64); |
|||
sizes[0] = 2 + fromwire_u16(&flen, &len); |
|||
assert(flen != NULL && len >= 4); |
|||
|
|||
parts[1] = node_announcement + 2 + 64 + sizes[0] + 4; |
|||
sizes[1] = tal_count(node_announcement) - (2 + 64 + sizes[0] + 4); |
|||
} |
|||
|
|||
/* Is this node_announcement different from prev (not sigs and timestamps)? */ |
|||
bool nannounce_different(struct gossip_store *gs, |
|||
const struct node *node, |
|||
const u8 *nannounce) |
|||
{ |
|||
const u8 *oparts[2], *nparts[2]; |
|||
size_t osizes[2], nsizes[2]; |
|||
const u8 *orig; |
|||
|
|||
/* Get last one we have. */ |
|||
orig = gossip_store_get(tmpctx, gs, node->bcast.index); |
|||
get_nannounce_parts(orig, oparts, osizes); |
|||
get_nannounce_parts(nannounce, nparts, nsizes); |
|||
|
|||
return !memeq(oparts[0], osizes[0], nparts[0], nsizes[0]) |
|||
|| !memeq(oparts[1], osizes[1], nparts[1], nsizes[1]); |
|||
} |
|||
|
|||
/* This routine created a `node_announcement` for our node, and hands it to
|
|||
* the routing.c code like any other `node_announcement`. Such announcements |
|||
* are only accepted if there is an announced channel associated with that node |
|||
* (to prevent spam), so we only call this once we've announced a channel. */ |
|||
static void update_own_node_announcement(struct daemon *daemon) |
|||
{ |
|||
u32 timestamp = gossip_time_now(daemon->rstate).ts.tv_sec; |
|||
secp256k1_ecdsa_signature sig; |
|||
u8 *msg, *nannounce, *err; |
|||
struct node *self = get_node(daemon->rstate, &daemon->id); |
|||
|
|||
/* Discard existing timer. */ |
|||
daemon->node_announce_timer = tal_free(daemon->node_announce_timer); |
|||
|
|||
/* Make unsigned announcement. */ |
|||
nannounce = create_node_announcement(tmpctx, daemon, NULL, timestamp); |
|||
|
|||
/* If it's the same as the previous, nothing to do. */ |
|||
if (self && self->bcast.index) { |
|||
u32 next; |
|||
|
|||
if (!nannounce_different(daemon->rstate->gs, self, nannounce)) |
|||
return; |
|||
|
|||
/* BOLT #7:
|
|||
* |
|||
* The origin node: |
|||
* - MUST set `timestamp` to be greater than that of any |
|||
* previous `node_announcement` it has previously created. |
|||
*/ |
|||
/* We do better: never send them within more than 5 minutes. */ |
|||
next = self->bcast.timestamp + daemon->gossip_min_interval; |
|||
|
|||
if (timestamp < next) { |
|||
status_debug("node_announcement: delaying %u secs", |
|||
next - timestamp); |
|||
daemon->node_announce_timer |
|||
= new_reltimer(&daemon->timers, |
|||
daemon, |
|||
time_from_sec(next - timestamp), |
|||
update_own_node_announcement, |
|||
daemon); |
|||
return; |
|||
} |
|||
} |
|||
|
|||
/* Ask hsmd to sign it (synchronous) */ |
|||
if (!wire_sync_write(HSM_FD, take(towire_hsm_node_announcement_sig_req(NULL, nannounce)))) |
|||
status_failed(STATUS_FAIL_MASTER_IO, "Could not write to HSM: %s", strerror(errno)); |
|||
|
|||
msg = wire_sync_read(tmpctx, HSM_FD); |
|||
if (!fromwire_hsm_node_announcement_sig_reply(msg, &sig)) |
|||
status_failed(STATUS_FAIL_MASTER_IO, "HSM returned an invalid node_announcement sig"); |
|||
|
|||
/* We got the signature for our provisional node_announcement back
|
|||
* from the HSM, create the real announcement and forward it to |
|||
* gossipd so it can take care of forwarding it. */ |
|||
nannounce = create_node_announcement(NULL, daemon, &sig, timestamp); |
|||
|
|||
/* This injects it into the routing code in routing.c; it should not
|
|||
* reject it! */ |
|||
err = handle_node_announcement(daemon->rstate, take(nannounce)); |
|||
if (err) |
|||
status_failed(STATUS_FAIL_INTERNAL_ERROR, |
|||
"rejected own node announcement: %s", |
|||
tal_hex(tmpctx, err)); |
|||
} |
|||
|
|||
/* Should we announce our own node? Called at strategic places. */ |
|||
void maybe_send_own_node_announce(struct daemon *daemon) |
|||
{ |
|||
/* We keep an internal flag in the routing code to say we've announced
|
|||
* a local channel. The alternative would be to have it make a |
|||
* callback, but when we start up we don't want to make multiple |
|||
* announcments, so we use this approach for now. */ |
|||
if (!daemon->rstate->local_channel_announced) |
|||
return; |
|||
|
|||
update_own_node_announcement(daemon); |
|||
daemon->rstate->local_channel_announced = false; |
|||
} |
|||
|
|||
/* Our timer callbacks take a single argument, so we marshall everything
|
|||
* we need into this structure: */ |
|||
struct local_cupdate { |
|||
struct daemon *daemon; |
|||
struct local_chan *local_chan; |
|||
|
|||
bool disable; |
|||
bool even_if_identical; |
|||
|
|||
u16 cltv_expiry_delta; |
|||
struct amount_msat htlc_minimum, htlc_maximum; |
|||
u32 fee_base_msat, fee_proportional_millionths; |
|||
}; |
|||
|
|||
/* This generates a `channel_update` message for one of our channels. We do
|
|||
* this here, rather than in `channeld` because we (may) need to do it |
|||
* ourselves anyway if channeld dies, or when we refresh it once a week, |
|||
* and so we can avoid creating redundant ones. */ |
|||
static void update_local_channel(struct local_cupdate *lc /* frees! */) |
|||
{ |
|||
struct daemon *daemon = lc->daemon; |
|||
secp256k1_ecdsa_signature dummy_sig; |
|||
u8 *update, *msg; |
|||
u32 timestamp = gossip_time_now(daemon->rstate).ts.tv_sec, next; |
|||
u8 message_flags, channel_flags; |
|||
struct chan *chan = lc->local_chan->chan; |
|||
struct half_chan *hc; |
|||
const int direction = lc->local_chan->direction; |
|||
|
|||
/* Discard existing timer. */ |
|||
lc->local_chan->channel_update_timer |
|||
= tal_free(lc->local_chan->channel_update_timer); |
|||
|
|||
/* So valgrind doesn't complain */ |
|||
memset(&dummy_sig, 0, sizeof(dummy_sig)); |
|||
|
|||
/* Create an unsigned channel_update: we backdate enables, so
|
|||
* we can always send a disable in an emergency. */ |
|||
if (!lc->disable) |
|||
timestamp -= daemon->gossip_min_interval; |
|||
|
|||
/* BOLT #7:
|
|||
* |
|||
* The `channel_flags` bitfield is used to indicate the direction of |
|||
* the channel: it identifies the node that this update originated |
|||
* from and signals various options concerning the channel. The |
|||
* following table specifies the meaning of its individual bits: |
|||
* |
|||
* | Bit Position | Name | Meaning | |
|||
* | ------------- | ----------- | -------------------------------- | |
|||
* | 0 | `direction` | Direction this update refers to. | |
|||
* | 1 | `disable` | Disable the channel. | |
|||
*/ |
|||
channel_flags = direction; |
|||
if (lc->disable) |
|||
channel_flags |= ROUTING_FLAGS_DISABLED; |
|||
|
|||
/* BOLT #7:
|
|||
* |
|||
* The `message_flags` bitfield is used to indicate the presence of |
|||
* optional fields in the `channel_update` message: |
|||
* |
|||
*| Bit Position | Name | Field | |
|||
*... |
|||
*| 0 | `option_channel_htlc_max` | `htlc_maximum_msat` | |
|||
*/ |
|||
message_flags = 0 | ROUTING_OPT_HTLC_MAX_MSAT; |
|||
|
|||
/* We create an update with a dummy signature, and hand to hsmd to get
|
|||
* it signed. */ |
|||
update = towire_channel_update_option_channel_htlc_max(tmpctx, &dummy_sig, |
|||
&daemon->chain_hash, |
|||
&chan->scid, |
|||
timestamp, |
|||
message_flags, channel_flags, |
|||
lc->cltv_expiry_delta, |
|||
lc->htlc_minimum, |
|||
lc->fee_base_msat, |
|||
lc->fee_proportional_millionths, |
|||
lc->htlc_maximum); |
|||
|
|||
hc = &chan->half[direction]; |
|||
if (is_halfchan_defined(hc)) { |
|||
/* Suppress duplicates. */ |
|||
if (!lc->even_if_identical |
|||
&& !cupdate_different(daemon->rstate->gs, hc, update)) { |
|||
tal_free(lc); |
|||
return; |
|||
} |
|||
|
|||
/* Is it too soon to send another update? */ |
|||
next = hc->bcast.timestamp + daemon->gossip_min_interval; |
|||
|
|||
if (timestamp < next) { |
|||
status_debug("channel_update %s/%u: delaying %u secs", |
|||
type_to_string(tmpctx, |
|||
struct short_channel_id, |
|||
&chan->scid), |
|||
direction, |
|||
next - timestamp); |
|||
lc->local_chan->channel_update_timer |
|||
= new_reltimer(&daemon->timers, lc, |
|||
time_from_sec(next - timestamp), |
|||
update_local_channel, |
|||
lc); |
|||
/* If local chan vanishes, so does update, and timer. */ |
|||
notleak(tal_steal(lc->local_chan, lc)); |
|||
return; |
|||
} |
|||
} |
|||
|
|||
/* Note that we treat the hsmd as synchronous. This is simple (no
|
|||
* callback hell)!, but may need to change to async if we ever want |
|||
* remote HSMs */ |
|||
if (!wire_sync_write(HSM_FD, |
|||
towire_hsm_cupdate_sig_req(tmpctx, update))) { |
|||
status_failed(STATUS_FAIL_HSM_IO, "Writing cupdate_sig_req: %s", |
|||
strerror(errno)); |
|||
} |
|||
|
|||
msg = wire_sync_read(tmpctx, HSM_FD); |
|||
if (!msg || !fromwire_hsm_cupdate_sig_reply(NULL, msg, &update)) { |
|||
status_failed(STATUS_FAIL_HSM_IO, |
|||
"Reading cupdate_sig_req: %s", |
|||
strerror(errno)); |
|||
} |
|||
|
|||
/* BOLT #7:
|
|||
* |
|||
* The origin node: |
|||
* - MAY create a `channel_update` to communicate the channel parameters to the |
|||
* channel peer, even though the channel has not yet been announced (i.e. the |
|||
* `announce_channel` bit was not set). |
|||
*/ |
|||
if (!is_chan_public(chan)) { |
|||
/* handle_channel_update will not put private updates in the
|
|||
* broadcast list, but we send it direct to the peer (if we |
|||
* have one connected) now */ |
|||
struct peer *peer = find_peer(daemon, |
|||
&chan->nodes[!direction]->id); |
|||
if (peer) |
|||
queue_peer_msg(peer, update); |
|||
} |
|||
|
|||
/* We feed it into routing.c like any other channel_update; it may
|
|||
* discard it (eg. non-public channel), but it should not complain |
|||
* about it being invalid! __func__ is a magic C constant which |
|||
* expands to this function name. */ |
|||
msg = handle_channel_update(daemon->rstate, take(update), __func__, |
|||
NULL); |
|||
if (msg) |
|||
status_failed(STATUS_FAIL_INTERNAL_ERROR, |
|||
"%s: rejected local channel update %s: %s", |
|||
__func__, |
|||
/* Normally we must not touch something taken()
|
|||
* but we're in deep trouble anyway, and |
|||
* handle_channel_update only tal_steals onto |
|||
* tmpctx, so it's actually OK. */ |
|||
tal_hex(tmpctx, update), |
|||
tal_hex(tmpctx, msg)); |
|||
tal_free(lc); |
|||
} |
|||
|
|||
/* This is a refresh of a local channel: sends an update if one is needed. */ |
|||
void refresh_local_channel(struct daemon *daemon, |
|||
struct local_chan *local_chan, |
|||
bool even_if_identical) |
|||
{ |
|||
const struct half_chan *hc; |
|||
struct local_cupdate *lc; |
|||
|
|||
hc = &local_chan->chan->half[local_chan->direction]; |
|||
|
|||
/* Don't generate a channel_update for an uninitialized channel. */ |
|||
if (!is_halfchan_defined(hc)) |
|||
return; |
|||
|
|||
lc = tal(NULL, struct local_cupdate); |
|||
lc->daemon = daemon; |
|||
lc->local_chan = local_chan; |
|||
lc->even_if_identical = even_if_identical; |
|||
lc->disable = (hc->channel_flags & ROUTING_FLAGS_DISABLED) |
|||
|| local_chan->local_disabled; |
|||
lc->cltv_expiry_delta = hc->delay; |
|||
lc->htlc_minimum = hc->htlc_minimum; |
|||
lc->htlc_maximum = hc->htlc_maximum; |
|||
lc->fee_base_msat = hc->base_fee; |
|||
lc->fee_proportional_millionths = hc->proportional_fee; |
|||
|
|||
update_local_channel(lc); |
|||
} |
|||
|
|||
/* channeld asks us to update the local channel. */ |
|||
bool handle_local_channel_update(struct daemon *daemon, |
|||
const struct node_id *src, |
|||
const u8 *msg) |
|||
{ |
|||
struct short_channel_id scid; |
|||
struct local_cupdate *lc = tal(tmpctx, struct local_cupdate); |
|||
|
|||
lc->daemon = daemon; |
|||
lc->even_if_identical = false; |
|||
|
|||
/* FIXME: We should get scid from lightningd when setting up the
|
|||
* connection, so no per-peer daemon can mess with channels other than |
|||
* its own! */ |
|||
if (!fromwire_gossipd_local_channel_update(msg, |
|||
&scid, |
|||
&lc->disable, |
|||
&lc->cltv_expiry_delta, |
|||
&lc->htlc_minimum, |
|||
&lc->fee_base_msat, |
|||
&lc->fee_proportional_millionths, |
|||
&lc->htlc_maximum)) { |
|||
status_broken("peer %s bad local_channel_update %s", |
|||
type_to_string(tmpctx, struct node_id, src), |
|||
tal_hex(tmpctx, msg)); |
|||
return false; |
|||
} |
|||
|
|||
lc->local_chan = local_chan_map_get(&daemon->rstate->local_chan_map, |
|||
&scid); |
|||
/* Can theoretically happen if channel just closed. */ |
|||
if (!lc->local_chan) { |
|||
status_debug("peer %s local_channel_update for unknown %s", |
|||
type_to_string(tmpctx, struct node_id, src), |
|||
type_to_string(tmpctx, struct short_channel_id, |
|||
&scid)); |
|||
return true; |
|||
} |
|||
|
|||
/* Remove soft local_disabled flag, if they're marking it enabled. */ |
|||
if (!lc->disable) |
|||
local_enable_chan(daemon->rstate, lc->local_chan->chan); |
|||
|
|||
/* Apply the update they told us */ |
|||
update_local_channel(tal_steal(NULL, lc)); |
|||
return true; |
|||
} |
|||
@ -0,0 +1,47 @@ |
|||
#ifndef LIGHTNING_GOSSIPD_MAKE_GOSSIP_H |
|||
#define LIGHTNING_GOSSIPD_MAKE_GOSSIP_H |
|||
#include "config.h" |
|||
#include <ccan/short_types/short_types.h> |
|||
#include <stdbool.h> |
|||
#include <stddef.h> |
|||
|
|||
struct chan; |
|||
struct daemon; |
|||
struct half_chan; |
|||
struct local_chan; |
|||
struct gossip_store; |
|||
struct peer; |
|||
struct node; |
|||
|
|||
/* Helper to get non-signature, non-timestamp parts of (valid!) channel_update */ |
|||
void get_cupdate_parts(const u8 *channel_update, |
|||
const u8 *parts[2], |
|||
size_t sizes[2]); |
|||
|
|||
|
|||
/* Is this channel_update different from prev (not sigs and timestamps)?
|
|||
* is_halfchan_defined(hc) must be true! */ |
|||
bool cupdate_different(struct gossip_store *gs, |
|||
const struct half_chan *hc, |
|||
const u8 *cupdate); |
|||
|
|||
/* Is this node_announcement different from prev (not sigs and timestamps)?
|
|||
* node->bcast.index must be non-zero! */ |
|||
bool nannounce_different(struct gossip_store *gs, |
|||
const struct node *node, |
|||
const u8 *nannounce); |
|||
|
|||
/* Should we announce our own node? Called at strategic places. */ |
|||
void maybe_send_own_node_announce(struct daemon *daemon); |
|||
|
|||
/* This is a refresh of a local channel: sends an update if one is needed. */ |
|||
void refresh_local_channel(struct daemon *daemon, |
|||
struct local_chan *local_chan, |
|||
bool even_if_identical); |
|||
|
|||
/* channeld asks us to update the local channel. */ |
|||
bool handle_local_channel_update(struct daemon *daemon, |
|||
const struct node_id *src, |
|||
const u8 *msg); |
|||
|
|||
#endif /* LIGHTNING_GOSSIPD_MAKE_GOSSIP_H */ |
|||
Loading…
Reference in new issue