#include "routing.h" #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #ifndef SUPERVERBOSE #define SUPERVERBOSE(...) #endif /* 365.25 * 24 * 60 / 10 */ #define BLOCKS_PER_YEAR 52596 struct pending_node_announce { struct routing_state *rstate; struct node_id nodeid; size_t refcount; u8 *node_announcement; u32 timestamp; u32 index; /* Automagically turns to NULL if peer freed */ struct peer *peer_softref; }; /* We consider a reasonable gossip rate to be 1 per day, with burst of * 4 per day. So we use a granularity of one hour. */ #define TOKENS_PER_MSG 24 #define TOKEN_MAX (24 * 4) static u8 update_tokens(const struct routing_state *rstate, u8 tokens, u32 prev_timestamp, u32 new_timestamp) { u64 num_tokens = tokens; assert(new_timestamp >= prev_timestamp); num_tokens += ((new_timestamp - prev_timestamp) / GOSSIP_TOKEN_TIME(rstate->dev_fast_gossip)); if (num_tokens > TOKEN_MAX) num_tokens = TOKEN_MAX; return num_tokens; } static bool ratelimit(const struct routing_state *rstate, u8 *tokens, u32 prev_timestamp, u32 new_timestamp) { *tokens = update_tokens(rstate, *tokens, prev_timestamp, new_timestamp); /* Now, if we can afford it, pass this message. */ if (*tokens >= TOKENS_PER_MSG) { *tokens -= TOKENS_PER_MSG; return true; } return false; } static const struct node_id * pending_node_announce_keyof(const struct pending_node_announce *a) { return &a->nodeid; } static bool pending_node_announce_eq(const struct pending_node_announce *pna, const struct node_id *pc) { return node_id_eq(&pna->nodeid, pc); } HTABLE_DEFINE_TYPE(struct pending_node_announce, pending_node_announce_keyof, node_map_hash_key, pending_node_announce_eq, pending_node_map); /* We keep around announcements for channels until we have an * update for them (which gives us their timestamp) */ struct unupdated_channel { /* The channel_announcement message */ const u8 *channel_announce; /* The short_channel_id */ struct short_channel_id scid; /* The ids of the nodes */ struct node_id id[2]; /* When we added, so we can discard old ones */ struct timeabs added; /* If we loaded from the store, this is where. */ u32 index; /* Channel capacity */ struct amount_sat sat; /* Automagically turns to NULL of peer freed */ struct peer *peer_softref; }; static struct unupdated_channel * get_unupdated_channel(const struct routing_state *rstate, const struct short_channel_id *scid) { return uintmap_get(&rstate->unupdated_chanmap, scid->u64); } static void destroy_unupdated_channel(struct unupdated_channel *uc, struct routing_state *rstate) { uintmap_del(&rstate->unupdated_chanmap, uc->scid.u64); } static struct node_map *new_node_map(const tal_t *ctx) { struct node_map *map = tal(ctx, struct node_map); node_map_init(map); tal_add_destructor(map, node_map_clear); return map; } /* We use a simple array (with NULL entries) until we have too many. */ static bool node_uses_chan_map(const struct node *node) { /* This is a layering violation: last entry in htable is the table ptr, * which is never NULL */ return node->chans.arr[NUM_IMMEDIATE_CHANS] != NULL; } /* When simple array fills, use a htable. */ static void convert_node_to_chan_map(struct node *node) { struct chan *chans[NUM_IMMEDIATE_CHANS]; memcpy(chans, node->chans.arr, sizeof(chans)); chan_map_init_sized(&node->chans.map, NUM_IMMEDIATE_CHANS + 1); assert(node_uses_chan_map(node)); for (size_t i = 0; i < ARRAY_SIZE(chans); i++) chan_map_add(&node->chans.map, chans[i]); } static void add_chan(struct node *node, struct chan *chan) { if (!node_uses_chan_map(node)) { for (size_t i = 0; i < NUM_IMMEDIATE_CHANS; i++) { if (node->chans.arr[i] == NULL) { node->chans.arr[i] = chan; return; } } convert_node_to_chan_map(node); } chan_map_add(&node->chans.map, chan); } static struct chan *next_chan_arr(const struct node *node, struct chan_map_iter *i) { while (i->i.off < NUM_IMMEDIATE_CHANS) { if (node->chans.arr[i->i.off]) return node->chans.arr[i->i.off]; i->i.off++; } return NULL; } struct chan *first_chan(const struct node *node, struct chan_map_iter *i) { if (!node_uses_chan_map(node)) { i->i.off = 0; return next_chan_arr(node, i); } return chan_map_first(&node->chans.map, i); } struct chan *next_chan(const struct node *node, struct chan_map_iter *i) { if (!node_uses_chan_map(node)) { i->i.off++; return next_chan_arr(node, i); } return chan_map_next(&node->chans.map, i); } static void destroy_routing_state(struct routing_state *rstate) { /* Since we omitted destructors on these, clean up manually */ u64 idx; for (struct chan *chan = uintmap_first(&rstate->chanmap, &idx); chan; chan = uintmap_after(&rstate->chanmap, &idx)) free_chan(rstate, chan); /* Free up our htables */ pending_cannouncement_map_clear(&rstate->pending_cannouncements); local_chan_map_clear(&rstate->local_chan_map); } /* We don't check this when loading from the gossip_store: that would break * our canned tests, and usually old gossip is better than no gossip */ static bool timestamp_reasonable(struct routing_state *rstate, u32 timestamp) { u64 now = gossip_time_now(rstate).ts.tv_sec; /* More than one day ahead? */ if (timestamp > now + 24*60*60) return false; /* More than 2 weeks behind? */ if (timestamp < now - GOSSIP_PRUNE_INTERVAL(rstate->dev_fast_gossip_prune)) return false; return true; } #if DEVELOPER static void memleak_help_routing_tables(struct htable *memtable, struct routing_state *rstate) { struct node *n; struct node_map_iter nit; memleak_remove_htable(memtable, &rstate->nodes->raw); memleak_remove_htable(memtable, &rstate->pending_node_map->raw); memleak_remove_htable(memtable, &rstate->pending_cannouncements.raw); memleak_remove_htable(memtable, &rstate->local_chan_map.raw); memleak_remove_uintmap(memtable, &rstate->unupdated_chanmap); for (n = node_map_first(rstate->nodes, &nit); n; n = node_map_next(rstate->nodes, &nit)) { if (node_uses_chan_map(n)) memleak_remove_htable(memtable, &n->chans.map.raw); } } #endif /* DEVELOPER */ /* Once an hour, or at 10000 entries, we expire old ones */ static void txout_failure_age(struct routing_state *rstate) { uintmap_clear(&rstate->txout_failures_old); rstate->txout_failures_old = rstate->txout_failures; uintmap_init(&rstate->txout_failures); rstate->num_txout_failures = 0; rstate->txout_failure_timer = new_reltimer(rstate->timers, rstate, time_from_sec(3600), txout_failure_age, rstate); } static void add_to_txout_failures(struct routing_state *rstate, const struct short_channel_id *scid) { if (uintmap_add(&rstate->txout_failures, scid->u64, true) && ++rstate->num_txout_failures == 10000) { tal_free(rstate->txout_failure_timer); txout_failure_age(rstate); } } static bool in_txout_failures(struct routing_state *rstate, const struct short_channel_id *scid) { if (uintmap_get(&rstate->txout_failures, scid->u64)) return true; /* If we were going to expire it, we no longer are. */ if (uintmap_get(&rstate->txout_failures_old, scid->u64)) { add_to_txout_failures(rstate, scid); return true; } return false; } struct routing_state *new_routing_state(const tal_t *ctx, const struct chainparams *chainparams, const struct node_id *local_id, struct list_head *peers, struct timers *timers, const u32 *dev_gossip_time TAKES, bool dev_fast_gossip, bool dev_fast_gossip_prune) { struct routing_state *rstate = tal(ctx, struct routing_state); rstate->nodes = new_node_map(rstate); rstate->gs = gossip_store_new(rstate, peers); rstate->timers = timers; rstate->chainparams = chainparams; rstate->local_id = *local_id; rstate->local_channel_announced = false; rstate->last_timestamp = 0; pending_cannouncement_map_init(&rstate->pending_cannouncements); uintmap_init(&rstate->chanmap); uintmap_init(&rstate->unupdated_chanmap); local_chan_map_init(&rstate->local_chan_map); rstate->num_txout_failures = 0; uintmap_init(&rstate->txout_failures); uintmap_init(&rstate->txout_failures_old); txout_failure_age(rstate); rstate->pending_node_map = tal(ctx, struct pending_node_map); pending_node_map_init(rstate->pending_node_map); #if DEVELOPER if (dev_gossip_time) { rstate->gossip_time = tal(rstate, struct timeabs); rstate->gossip_time->ts.tv_sec = *dev_gossip_time; rstate->gossip_time->ts.tv_nsec = 0; } else rstate->gossip_time = NULL; rstate->dev_fast_gossip = dev_fast_gossip; rstate->dev_fast_gossip_prune = dev_fast_gossip_prune; #endif tal_add_destructor(rstate, destroy_routing_state); memleak_add_helper(rstate, memleak_help_routing_tables); if (taken(dev_gossip_time)) tal_free(dev_gossip_time); return rstate; } const struct node_id *node_map_keyof_node(const struct node *n) { return &n->id; } size_t node_map_hash_key(const struct node_id *pc) { return siphash24(siphash_seed(), pc->k, sizeof(pc->k)); } bool node_map_node_eq(const struct node *n, const struct node_id *pc) { return node_id_eq(&n->id, pc); } static void destroy_node(struct node *node, struct routing_state *rstate) { struct chan_map_iter i; struct chan *c; node_map_del(rstate->nodes, node); /* These remove themselves from chans[]. */ while ((c = first_chan(node, &i)) != NULL) free_chan(rstate, c); /* Free htable if we need. */ if (node_uses_chan_map(node)) chan_map_clear(&node->chans.map); } struct node *get_node(struct routing_state *rstate, const struct node_id *id) { return node_map_get(rstate->nodes, id); } static struct node *new_node(struct routing_state *rstate, const struct node_id *id) { struct node *n; assert(!get_node(rstate, id)); n = tal(rstate, struct node); n->id = *id; memset(n->chans.arr, 0, sizeof(n->chans.arr)); broadcastable_init(&n->bcast); n->tokens = TOKEN_MAX; node_map_add(rstate->nodes, n); tal_add_destructor2(n, destroy_node, rstate); return n; } /* We've received a channel_announce for a channel attached to this node: * otherwise it's in the map only because it's a peer, or us. */ static bool node_has_public_channels(struct node *node) { struct chan_map_iter i; struct chan *c; for (c = first_chan(node, &i); c; c = next_chan(node, &i)) { if (is_chan_public(c)) return true; } return false; } /* We can *send* a channel_announce for a channel attached to this node: * we only send once we have a channel_update. */ static bool node_has_broadcastable_channels(struct node *node) { struct chan_map_iter i; struct chan *c; for (c = first_chan(node, &i); c; c = next_chan(node, &i)) { if (!is_chan_public(c)) continue; if (is_halfchan_defined(&c->half[0]) || is_halfchan_defined(&c->half[1])) return true; } return false; } static bool node_announce_predates_channels(const struct node *node) { struct chan_map_iter i; struct chan *c; for (c = first_chan(node, &i); c; c = next_chan(node, &i)) { if (!is_chan_public(c)) continue; if (c->bcast.index < node->bcast.index) return false; } return true; } static void remove_chan_from_node(struct routing_state *rstate, struct node *node, const struct chan *chan) { size_t num_chans; if (!node_uses_chan_map(node)) { num_chans = 0; for (size_t i = 0; i < NUM_IMMEDIATE_CHANS; i++) { if (node->chans.arr[i] == chan) node->chans.arr[i] = NULL; else if (node->chans.arr[i] != NULL) num_chans++; } } else { if (!chan_map_del(&node->chans.map, chan)) abort(); num_chans = chan_map_count(&node->chans.map); } /* Last channel? Simply delete node (and associated announce) */ if (num_chans == 0) { gossip_store_delete(rstate->gs, &node->bcast, WIRE_NODE_ANNOUNCEMENT); tal_free(node); return; } if (!node->bcast.index) return; /* Removed only public channel? Remove node announcement. */ if (!node_has_broadcastable_channels(node)) { gossip_store_delete(rstate->gs, &node->bcast, WIRE_NODE_ANNOUNCEMENT); } else if (node_announce_predates_channels(node)) { const u8 *announce; announce = gossip_store_get(tmpctx, rstate->gs, node->bcast.index); /* node announcement predates all channel announcements? * Move to end (we could, in theory, move to just past next * channel_announce, but we don't care that much about spurious * retransmissions in this corner case */ gossip_store_delete(rstate->gs, &node->bcast, WIRE_NODE_ANNOUNCEMENT); node->bcast.index = gossip_store_add(rstate->gs, announce, node->bcast.timestamp, false, NULL); } } #if DEVELOPER /* We make sure that free_chan is called on this chan! */ static void destroy_chan_check(struct chan *chan) { assert(chan->sat.satoshis == (unsigned long)chan); /* Raw: dev-hack */ } #endif /* We used to make this a tal_add_destructor2, but that costs 40 bytes per * chan, and we only ever explicitly free it anyway. */ void free_chan(struct routing_state *rstate, struct chan *chan) { remove_chan_from_node(rstate, chan->nodes[0], chan); remove_chan_from_node(rstate, chan->nodes[1], chan); uintmap_del(&rstate->chanmap, chan->scid.u64); #if DEVELOPER chan->sat.satoshis = (unsigned long)chan; /* Raw: dev-hack */ #endif tal_free(chan); } static void init_half_chan(struct routing_state *rstate, struct chan *chan, int channel_idx) { struct half_chan *c = &chan->half[channel_idx]; /* Set the channel direction */ c->channel_flags = channel_idx; // TODO: wireup message_flags c->message_flags = 0; broadcastable_init(&c->bcast); c->tokens = TOKEN_MAX; } static void bad_gossip_order(const u8 *msg, const struct peer *peer, const char *details) { status_debug("Bad gossip order from %s: %s before announcement %s", peer ? type_to_string(tmpctx, struct node_id, &peer->id) : "unknown", wire_type_name(fromwire_peektype(msg)), details); } static void destroy_local_chan(struct local_chan *local_chan, struct routing_state *rstate) { if (!local_chan_map_del(&rstate->local_chan_map, local_chan)) abort(); } static void maybe_add_local_chan(struct routing_state *rstate, struct chan *chan) { int direction; struct local_chan *local_chan; if (node_id_eq(&chan->nodes[0]->id, &rstate->local_id)) direction = 0; else if (node_id_eq(&chan->nodes[1]->id, &rstate->local_id)) direction = 1; else return; local_chan = tal(chan, struct local_chan); local_chan->chan = chan; local_chan->direction = direction; local_chan->local_disabled = false; local_chan->channel_update_timer = NULL; local_chan_map_add(&rstate->local_chan_map, local_chan); tal_add_destructor2(local_chan, destroy_local_chan, rstate); } struct chan *new_chan(struct routing_state *rstate, const struct short_channel_id *scid, const struct node_id *id1, const struct node_id *id2, struct amount_sat satoshis) { struct chan *chan = tal(rstate, struct chan); int n1idx = node_id_idx(id1, id2); struct node *n1, *n2; #if DEVELOPER tal_add_destructor(chan, destroy_chan_check); #endif /* We should never add a channel twice */ assert(!uintmap_get(&rstate->chanmap, scid->u64)); /* Create nodes on demand */ n1 = get_node(rstate, id1); if (!n1) n1 = new_node(rstate, id1); n2 = get_node(rstate, id2); if (!n2) n2 = new_node(rstate, id2); chan->scid = *scid; chan->nodes[n1idx] = n1; chan->nodes[!n1idx] = n2; broadcastable_init(&chan->bcast); /* This is how we indicate it's not public yet. */ chan->bcast.timestamp = 0; chan->sat = satoshis; add_chan(n2, chan); add_chan(n1, chan); /* Populate with (inactive) connections */ init_half_chan(rstate, chan, n1idx); init_half_chan(rstate, chan, !n1idx); uintmap_add(&rstate->chanmap, scid->u64, chan); /* Initialize shadow structure if it's local */ maybe_add_local_chan(rstate, chan); return chan; } /* Too big to reach, but don't overflow if added. */ #define INFINITE AMOUNT_MSAT(0x3FFFFFFFFFFFFFFFULL) /* We hack a multimap into a uintmap to implement a minheap by cost. * This is relatively inefficient, containing an array for each cost * value, assuming there aren't too many at same cost. * * We further optimize by never freeing or shrinking these entries, * but delete by replacing with NULL. This means that we cache the * lowest index which actually contains something, since others may * contain empty arrays. */ struct unvisited { u64 min_index; UINTMAP(struct node **) map; }; /* Risk of passing through this channel. * * There are two ways this function is used: * * 1. Normally, riskbias = 1. A tiny bias here in order to prefer * shorter routes, all things equal. * 2. Trying to find a shorter route, riskbias > 1. By adding an extra * cost to every hop, we're trying to bias against overlength routes. */ static WARN_UNUSED_RESULT bool risk_add_fee(struct amount_msat *risk, struct amount_msat msat, u32 delay, double riskfactor, u64 riskbias) { double r; /* Won't overflow on add, just lose precision */ r = (double)riskbias + riskfactor * delay * msat.millisatoshis + risk->millisatoshis; /* Raw: to double */ if (r > UINT64_MAX) return false; risk->millisatoshis = r; /* Raw: from double */ return true; } /* Check that we can fit through this channel's indicated * maximum_ and minimum_msat requirements. */ static bool hc_can_carry(const struct half_chan *hc, struct amount_msat requiredcap) { return amount_msat_greater_eq(hc->htlc_maximum, requiredcap) && amount_msat_less_eq(hc->htlc_minimum, requiredcap); } /* Theoretically, this could overflow. */ static bool fuzz_fee(u64 *fee, const struct short_channel_id *scid, double fuzz, const struct siphash_seed *base_seed) { u64 fuzzed_fee, h; double fee_scale; if (fuzz == 0.0) return true; h = siphash24(base_seed, scid, sizeof(*scid)); /* Scale fees for this channel */ /* rand = (h / UINT64_MAX) random number between 0.0 -> 1.0 * 2*fuzz*rand random number between 0.0 -> 2*fuzz * 2*fuzz*rand - fuzz random number between -fuzz -> +fuzz */ fee_scale = 1.0 + (2.0 * fuzz * h / UINT64_MAX) - fuzz; fuzzed_fee = *fee * fee_scale; if (fee_scale > 1.0 && fuzzed_fee < *fee) return false; *fee = fuzzed_fee; return true; } /* Can we carry this amount across the channel? If so, returns true and * sets newtotal and newrisk */ static bool can_reach(const struct half_chan *c, const struct short_channel_id *scid, bool no_charge, struct amount_msat total, struct amount_msat risk, double riskfactor, u64 riskbias, double fuzz, const struct siphash_seed *base_seed, struct amount_msat *newtotal, struct amount_msat *newrisk) { /* FIXME: Bias against smaller channels. */ struct amount_msat fee; if (!amount_msat_fee(&fee, total, c->base_fee, c->proportional_fee)) return false; if (!fuzz_fee(&fee.millisatoshis, scid, fuzz, base_seed)) /* Raw: double manipulation */ return false; if (no_charge) { *newtotal = total; /* We still want to consider the "charge", since it's indicative * of a bias (we discounted one channel for a reason), but we * don't pay it. So we count it as additional risk. */ if (!amount_msat_add(newrisk, risk, fee)) return false; } else { *newrisk = risk; if (!amount_msat_add(newtotal, total, fee)) return false; } /* Skip a channel if it indicated that it won't route the * requested amount. */ if (!hc_can_carry(c, *newtotal)) return false; if (!risk_add_fee(newrisk, *newtotal, c->delay, riskfactor, riskbias)) return false; return true; } /* Returns false on overflow (shouldn't happen!) */ typedef bool WARN_UNUSED_RESULT costfn_t(struct amount_msat *, struct amount_msat, struct amount_msat); static WARN_UNUSED_RESULT bool normal_cost_function(struct amount_msat *cost, struct amount_msat total, struct amount_msat risk) { if (amount_msat_add(cost, total, risk)) return true; status_broken("Can't add cost of node %s + %s", type_to_string(tmpctx, struct amount_msat, &total), type_to_string(tmpctx, struct amount_msat, &risk)); return false; } static WARN_UNUSED_RESULT bool shortest_cost_function(struct amount_msat *cost, struct amount_msat total, struct amount_msat risk) { /* We add 1, so cost is never 0, for our hacky uintmap-as-minheap. */ if (amount_msat_add(cost, risk, AMOUNT_MSAT(1))) return true; status_broken("Can't add 1 to risk of node %s", type_to_string(tmpctx, struct amount_msat, &risk)); return false; } /* Does totala+riska add up to less than totalb+riskb? * Saves sums if you want them. */ static bool costs_less(struct amount_msat totala, struct amount_msat riska, struct amount_msat *costa, struct amount_msat totalb, struct amount_msat riskb, struct amount_msat *costb, costfn_t *costfn) { struct amount_msat suma, sumb; if (!costfn(&suma, totala, riska)) return false; if (!costfn(&sumb, totalb, riskb)) return false; if (costa) *costa = suma; if (costb) *costb = sumb; return amount_msat_less(suma, sumb); } /* Determine if the given half_chan is routable */ static bool hc_is_routable(struct routing_state *rstate, const struct chan *chan, int idx) { return is_halfchan_enabled(&chan->half[idx]) && !is_chan_local_disabled(rstate, chan); } static void unvisited_add(struct unvisited *unvisited, struct amount_msat cost, struct node **arr) { u64 idx = cost.millisatoshis; /* Raw: uintmap needs u64 index */ if (idx < unvisited->min_index) { assert(idx); /* We don't allow sending 0 satoshis */ unvisited->min_index = idx - 1; } uintmap_add(&unvisited->map, idx, arr); } static struct node **unvisited_get(const struct unvisited *unvisited, struct amount_msat cost) { return uintmap_get(&unvisited->map, cost.millisatoshis); /* Raw: uintmap */ } static struct node **unvisited_del(struct unvisited *unvisited, struct amount_msat cost) { return uintmap_del(&unvisited->map, cost.millisatoshis); /* Raw: uintmap */ } static bool is_unvisited(const struct node *node, const struct unvisited *unvisited, costfn_t *costfn) { struct node **arr; struct amount_msat cost; /* If it's infinite, definitely unvisited */ if (amount_msat_eq(node->dijkstra.total, INFINITE)) return true; /* Shouldn't happen! */ if (!costfn(&cost, node->dijkstra.total, node->dijkstra.risk)) return false; arr = unvisited_get(unvisited, cost); for (size_t i = 0; i < tal_count(arr); i++) { if (arr[i] == node) return true; } return false; } static void unvisited_del_node(struct unvisited *unvisited, struct amount_msat cost, const struct node *node) { struct node **arr; arr = unvisited_get(unvisited, cost); for (size_t i = 0; i < tal_count(arr); i++) { if (arr[i] == node) { arr[i] = NULL; return; } } abort(); } static void adjust_unvisited(struct node *node, struct unvisited *unvisited, struct amount_msat cost_before, struct amount_msat total, struct amount_msat risk, struct amount_msat cost_after) { struct node **arr; /* If it was in unvisited map, remove it. */ if (!amount_msat_eq(node->dijkstra.total, INFINITE)) unvisited_del_node(unvisited, cost_before, node); /* Update node */ node->dijkstra.total = total; node->dijkstra.risk = risk; SUPERVERBOSE("%s now cost %s", type_to_string(tmpctx, struct node_id, &node->id), type_to_string(tmpctx, struct amount_msat, &cost_after)); /* Update map of unvisited nodes */ arr = unvisited_get(unvisited, cost_after); if (arr) { struct node **old_arr; /* Try for empty slot */ for (size_t i = 0; i < tal_count(arr); i++) { if (arr[i] == NULL) { arr[i] = node; return; } } /* Nope, expand */ old_arr = arr; tal_arr_expand(&arr, node); if (arr == old_arr) return; /* Realloc moved it; del and add again. */ unvisited_del(unvisited, cost_after); } else { arr = tal_arr(unvisited, struct node *, 1); arr[0] = node; } unvisited_add(unvisited, cost_after, arr); } static void remove_unvisited(struct node *node, struct unvisited *unvisited, costfn_t *costfn) { struct amount_msat cost; /* Shouldn't happen! */ if (!costfn(&cost, node->dijkstra.total, node->dijkstra.risk)) return; unvisited_del_node(unvisited, cost, node); } static void update_unvisited_neighbors(struct routing_state *rstate, struct node *cur, const struct node *me, double riskfactor, u64 riskbias, double fuzz, const struct siphash_seed *base_seed, struct unvisited *unvisited, costfn_t *costfn) { struct chan_map_iter i; struct chan *chan; /* Consider all neighbors */ for (chan = first_chan(cur, &i); chan; chan = next_chan(cur, &i)) { struct amount_msat total, risk, cost_before, cost_after; int idx = half_chan_to(cur, chan); struct node *peer = chan->nodes[idx]; SUPERVERBOSE("CONSIDERING: %s -> %s (%s/%s)", type_to_string(tmpctx, struct node_id, &cur->id), type_to_string(tmpctx, struct node_id, &peer->id), type_to_string(tmpctx, struct amount_msat, &peer->dijkstra.total), type_to_string(tmpctx, struct amount_msat, &peer->dijkstra.risk)); if (!hc_is_routable(rstate, chan, idx)) { SUPERVERBOSE("... not routable"); continue; } if (!is_unvisited(peer, unvisited, costfn)) { SUPERVERBOSE("... already visited"); continue; } /* We're looking at channels *backwards*, so peer == me * is the right test here for whether we don't charge fees. */ if (!can_reach(&chan->half[idx], &chan->scid, peer == me, cur->dijkstra.total, cur->dijkstra.risk, riskfactor, riskbias, fuzz, base_seed, &total, &risk)) { SUPERVERBOSE("... can't reach"); continue; } /* This effectively adds it to the map if it was infinite */ if (costs_less(total, risk, &cost_after, peer->dijkstra.total, peer->dijkstra.risk, &cost_before, costfn)) { SUPERVERBOSE("...%s can reach %s" " total %s risk %s", type_to_string(tmpctx, struct node_id, &cur->id), type_to_string(tmpctx, struct node_id, &peer->id), type_to_string(tmpctx, struct amount_msat, &total), type_to_string(tmpctx, struct amount_msat, &risk)); adjust_unvisited(peer, unvisited, cost_before, total, risk, cost_after); } } } static struct node *first_unvisited(struct unvisited *unvisited) { struct node **arr; while ((arr = uintmap_after(&unvisited->map, &unvisited->min_index))) { for (size_t i = 0; i < tal_count(arr); i++) { if (arr[i]) { unvisited->min_index--; return arr[i]; } } } return NULL; } static void dijkstra(struct routing_state *rstate, const struct node *dst, const struct node *me, double riskfactor, u64 riskbias, double fuzz, const struct siphash_seed *base_seed, struct unvisited *unvisited, costfn_t *costfn) { struct node *cur; while ((cur = first_unvisited(unvisited)) != NULL) { update_unvisited_neighbors(rstate, cur, me, riskfactor, riskbias, fuzz, base_seed, unvisited, costfn); remove_unvisited(cur, unvisited, costfn); if (cur == dst) return; } } /* Note that we calculated route *backwards*, for fees. So "from" * here has a high cost, "to" has a cost of exact amount sent. */ static struct chan **build_route(const tal_t *ctx, struct routing_state *rstate, const struct node *from, const struct node *to, const struct node *me, double riskfactor, u64 riskbias, double fuzz, const struct siphash_seed *base_seed, struct amount_msat *fee) { const struct node *i; struct chan **route, *chan; SUPERVERBOSE("Building route from %s (%s) -> %s (%s)", type_to_string(tmpctx, struct node_id, &from->id), type_to_string(tmpctx, struct amount_msat, &from->dijkstra.total), type_to_string(tmpctx, struct node_id, &to->id), type_to_string(tmpctx, struct amount_msat, &to->dijkstra.total)); /* Never reached? */ if (amount_msat_eq(from->dijkstra.total, INFINITE)) return NULL; /* Walk to find which neighbors we used */ route = tal_arr(ctx, struct chan *, 0); for (i = from; i != to; i = other_node(i, chan)) { struct chan_map_iter it; /* Consider all neighbors */ for (chan = first_chan(i, &it); chan; chan = next_chan(i, &it)) { struct node *peer = other_node(i, chan); struct half_chan *hc = half_chan_from(i, chan); struct amount_msat total, risk; SUPERVERBOSE("CONSIDER: %s -> %s (%s/%s)", type_to_string(tmpctx, struct node_id, &i->id), type_to_string(tmpctx, struct node_id, &peer->id), type_to_string(tmpctx, struct amount_msat, &peer->dijkstra.total), type_to_string(tmpctx, struct amount_msat, &peer->dijkstra.risk)); /* If traversing this wasn't possible, ignore */ if (!hc_is_routable(rstate, chan, !half_chan_to(i, chan))) { continue; } if (!can_reach(hc, &chan->scid, i == me, peer->dijkstra.total, peer->dijkstra.risk, riskfactor, riskbias, fuzz, base_seed, &total, &risk)) continue; /* If this was the path we took, we're done (if there are * two identical ones, it doesn't matter which) */ if (amount_msat_eq(total, i->dijkstra.total) && amount_msat_eq(risk, i->dijkstra.risk)) break; } if (!chan) { status_broken("Could not find hop to %s", type_to_string(tmpctx, struct node_id, &i->id)); return tal_free(route); } tal_arr_expand(&route, chan); } /* We don't charge ourselves fees, so skip first hop */ if (!amount_msat_sub(fee, other_node(from, route[0])->dijkstra.total, to->dijkstra.total)) { status_broken("Could not subtract %s - %s for fee", type_to_string(tmpctx, struct amount_msat, &other_node(from, route[0]) ->dijkstra.total), type_to_string(tmpctx, struct amount_msat, &to->dijkstra.total)); return tal_free(route); } return route; } static struct unvisited *dijkstra_prepare(const tal_t *ctx, struct routing_state *rstate, struct node *src, struct amount_msat msat, costfn_t *costfn) { struct node_map_iter it; struct unvisited *unvisited; struct node *n; struct node **arr; struct amount_msat cost; unvisited = tal(tmpctx, struct unvisited); uintmap_init(&unvisited->map); unvisited->min_index = UINT64_MAX; /* Reset all the information. */ for (n = node_map_first(rstate->nodes, &it); n; n = node_map_next(rstate->nodes, &it)) { if (n == src) continue; n->dijkstra.total = INFINITE; n->dijkstra.risk = INFINITE; } /* Mark start cost: place in unvisited map. */ src->dijkstra.total = msat; src->dijkstra.risk = AMOUNT_MSAT(0); arr = tal_arr(unvisited, struct node *, 1); arr[0] = src; /* Adding 0 can never fail */ if (!costfn(&cost, src->dijkstra.total, src->dijkstra.risk)) abort(); unvisited_add(unvisited, cost, arr); return unvisited; } static void dijkstra_cleanup(struct unvisited *unvisited) { struct node **arr; u64 idx; /* uintmap uses malloc, so manual cleaning needed */ while ((arr = uintmap_first(&unvisited->map, &idx)) != NULL) { tal_free(arr); uintmap_del(&unvisited->map, idx); } tal_free(unvisited); } /* We need to start biassing against long routes. */ static struct chan ** find_shorter_route(const tal_t *ctx, struct routing_state *rstate, struct node *src, struct node *dst, const struct node *me, struct amount_msat msat, u32 max_hops, double fuzz, const struct siphash_seed *base_seed, struct chan **long_route, struct amount_msat *fee) { struct unvisited *unvisited; struct chan **short_route = NULL; struct amount_msat long_cost, short_cost, cost_diff; u64 min_bias, max_bias; double riskfactor; /* We traverse backwards, so dst has largest total */ if (!amount_msat_sub(&long_cost, dst->dijkstra.total, src->dijkstra.total)) goto bad_total; tal_free(long_route); /* FIXME: It's hard to juggle both the riskfactor and riskbias here, * so we set our riskfactor to rougly equate to 1 millisatoshi * per block delay, which is close enough to zero to not break * this algorithm, but still provide some bias towards * low-delay routes. */ riskfactor = (double)1.0 / msat.millisatoshis; /* Raw: inversion */ /* First, figure out if a short route is even possible. * We set the cost function to ignore total, riskbias 1 and riskfactor * ~0 so risk simply operates as a simple hop counter. */ unvisited = dijkstra_prepare(tmpctx, rstate, src, msat, shortest_cost_function); SUPERVERBOSE("Running shortest path from %s -> %s", type_to_string(tmpctx, struct node_id, &dst->id), type_to_string(tmpctx, struct node_id, &src->id)); dijkstra(rstate, dst, NULL, riskfactor, 1, fuzz, base_seed, unvisited, shortest_cost_function); dijkstra_cleanup(unvisited); /* This must succeed, since we found a route before */ short_route = build_route(ctx, rstate, dst, src, me, riskfactor, 1, fuzz, base_seed, fee); assert(short_route); if (!amount_msat_sub(&short_cost, dst->dijkstra.total, src->dijkstra.total)) goto bad_total; /* Still too long? Oh well. */ if (tal_count(short_route) > max_hops) { status_info("Minimal possible route %s->%s is %zu", type_to_string(tmpctx, struct node_id, &dst->id), type_to_string(tmpctx, struct node_id, &src->id), tal_count(short_route)); goto out; } /* OK, so it's possible, just more expensive. */ min_bias = 0; if (!amount_msat_sub(&cost_diff, short_cost, long_cost)) { status_broken("Short cost %s < long cost %s?", type_to_string(tmpctx, struct amount_msat, &short_cost), type_to_string(tmpctx, struct amount_msat, &long_cost)); goto out; } /* This is a gross overestimate, but it works. */ max_bias = cost_diff.millisatoshis; /* Raw: bias calc */ SUPERVERBOSE("maxbias %"PRIu64" gave rlen %zu", max_bias, tal_count(short_route)); /* Now, binary search */ while (min_bias < max_bias) { struct chan **route; struct amount_msat this_fee; u64 riskbias = (min_bias + max_bias) / 2; unvisited = dijkstra_prepare(tmpctx, rstate, src, msat, normal_cost_function); dijkstra(rstate, dst, me, riskfactor, riskbias, fuzz, base_seed, unvisited, normal_cost_function); dijkstra_cleanup(unvisited); route = build_route(ctx, rstate, dst, src, me, riskfactor, riskbias, fuzz, base_seed, &this_fee); SUPERVERBOSE("riskbias %"PRIu64" rlen %zu", riskbias, tal_count(route)); /* Too long still? This is our new min_bias */ if (tal_count(route) > max_hops) { tal_free(route); min_bias = riskbias + 1; } else { /* This route is acceptable. */ tal_free(short_route); short_route = route; /* Save this fee in case we exit loop */ *fee = this_fee; max_bias = riskbias; } } return short_route; bad_total: status_broken("dst total %s < src total %s?", type_to_string(tmpctx, struct amount_msat, &dst->dijkstra.total), type_to_string(tmpctx, struct amount_msat, &src->dijkstra.total)); out: tal_free(short_route); return NULL; } /* riskfactor is already scaled to per-block amount */ static struct chan ** find_route(const tal_t *ctx, struct routing_state *rstate, const struct node_id *from, const struct node_id *to, struct amount_msat msat, double riskfactor, double fuzz, const struct siphash_seed *base_seed, u32 max_hops, struct amount_msat *fee) { struct node *src, *dst; const struct node *me; struct unvisited *unvisited; struct chan **route; /* Note: we map backwards, since we know the amount of satoshi we want * at the end, and need to derive how much we need to send. */ src = get_node(rstate, to); /* If from is NULL, that's means it's us. */ if (!from) me = dst = get_node(rstate, &rstate->local_id); else { dst = get_node(rstate, from); me = NULL; } if (!src) { status_info("find_route: cannot find %s", type_to_string(tmpctx, struct node_id, to)); return NULL; } else if (!dst) { status_info("find_route: cannot find source (%s)", type_to_string(tmpctx, struct node_id, to)); return NULL; } else if (dst == src) { status_info("find_route: this is %s, refusing to create empty route", type_to_string(tmpctx, struct node_id, to)); return NULL; } unvisited = dijkstra_prepare(tmpctx, rstate, src, msat, normal_cost_function); dijkstra(rstate, dst, me, riskfactor, 1, fuzz, base_seed, unvisited, normal_cost_function); dijkstra_cleanup(unvisited); route = build_route(ctx, rstate, dst, src, me, riskfactor, 1, fuzz, base_seed, fee); if (tal_count(route) <= max_hops) return route; /* This is the far more unlikely case */ return find_shorter_route(ctx, rstate, src, dst, me, msat, max_hops, fuzz, base_seed, route, fee); } /* Checks that key is valid, and signed this hash */ static bool check_signed_hash_nodeid(const struct sha256_double *hash, const secp256k1_ecdsa_signature *signature, const struct node_id *id) { struct pubkey key; return pubkey_from_node_id(&key, id) && check_signed_hash(hash, signature, &key); } /* Verify the signature of a channel_update message */ static u8 *check_channel_update(const tal_t *ctx, const struct node_id *node_id, const secp256k1_ecdsa_signature *node_sig, const u8 *update) { /* 2 byte msg type + 64 byte signatures */ int offset = 66; struct sha256_double hash; sha256_double(&hash, update + offset, tal_count(update) - offset); if (!check_signed_hash_nodeid(&hash, node_sig, node_id)) return towire_errorfmt(ctx, NULL, "Bad signature for %s hash %s" " on channel_update %s", type_to_string(ctx, secp256k1_ecdsa_signature, node_sig), type_to_string(ctx, struct sha256_double, &hash), tal_hex(ctx, update)); return NULL; } static u8 *check_channel_announcement(const tal_t *ctx, const struct node_id *node1_id, const struct node_id *node2_id, const struct pubkey *bitcoin1_key, const struct pubkey *bitcoin2_key, const secp256k1_ecdsa_signature *node1_sig, const secp256k1_ecdsa_signature *node2_sig, const secp256k1_ecdsa_signature *bitcoin1_sig, const secp256k1_ecdsa_signature *bitcoin2_sig, const u8 *announcement) { /* 2 byte msg type + 256 byte signatures */ int offset = 258; struct sha256_double hash; sha256_double(&hash, announcement + offset, tal_count(announcement) - offset); if (!check_signed_hash_nodeid(&hash, node1_sig, node1_id)) { return towire_errorfmt(ctx, NULL, "Bad node_signature_1 %s hash %s" " on node_announcement %s", type_to_string(ctx, secp256k1_ecdsa_signature, node1_sig), type_to_string(ctx, struct sha256_double, &hash), tal_hex(ctx, announcement)); } if (!check_signed_hash_nodeid(&hash, node2_sig, node2_id)) { return towire_errorfmt(ctx, NULL, "Bad node_signature_2 %s hash %s" " on node_announcement %s", type_to_string(ctx, secp256k1_ecdsa_signature, node2_sig), type_to_string(ctx, struct sha256_double, &hash), tal_hex(ctx, announcement)); } if (!check_signed_hash(&hash, bitcoin1_sig, bitcoin1_key)) { return towire_errorfmt(ctx, NULL, "Bad bitcoin_signature_1 %s hash %s" " on node_announcement %s", type_to_string(ctx, secp256k1_ecdsa_signature, bitcoin1_sig), type_to_string(ctx, struct sha256_double, &hash), tal_hex(ctx, announcement)); } if (!check_signed_hash(&hash, bitcoin2_sig, bitcoin2_key)) { return towire_errorfmt(ctx, NULL, "Bad bitcoin_signature_2 %s hash %s" " on node_announcement %s", type_to_string(ctx, secp256k1_ecdsa_signature, bitcoin2_sig), type_to_string(ctx, struct sha256_double, &hash), tal_hex(ctx, announcement)); } return NULL; } /* We allow node announcements for this node if it doesn't otherwise exist, so * we can process them once it does exist (a channel_announce is being * validated right now). * * If we attach one, remove it on destruction of @ctx. */ static void del_pending_node_announcement(const tal_t *ctx UNUSED, struct pending_node_announce *pna) { if (--pna->refcount == 0) { pending_node_map_del(pna->rstate->pending_node_map, pna); tal_free(pna); } } static void catch_node_announcement(const tal_t *ctx, struct routing_state *rstate, struct node_id *nodeid) { struct pending_node_announce *pna; struct node *node; /* No need if we already know about the node. We might, however, only * know about it because it's a peer (maybe with private or * not-yet-announced channels), so check for that too. */ node = get_node(rstate, nodeid); if (node && node_has_public_channels(node)) return; /* We can have multiple channels announced at same time for nodes; * but we can only have one of these in the map. */ pna = pending_node_map_get(rstate->pending_node_map, nodeid); if (!pna) { pna = tal(rstate, struct pending_node_announce); pna->rstate = rstate; pna->nodeid = *nodeid; pna->node_announcement = NULL; pna->timestamp = 0; pna->index = 0; pna->refcount = 0; pna->peer_softref = NULL; pending_node_map_add(rstate->pending_node_map, pna); } pna->refcount++; tal_add_destructor2(ctx, del_pending_node_announcement, pna); } static void process_pending_node_announcement(struct routing_state *rstate, struct node_id *nodeid) { struct pending_node_announce *pna = pending_node_map_get(rstate->pending_node_map, nodeid); if (!pna) return; if (pna->node_announcement) { SUPERVERBOSE( "Processing deferred node_announcement for node %s", type_to_string(pna, struct node_id, nodeid)); /* Can fail it timestamp is now too old */ if (!routing_add_node_announcement(rstate, pna->node_announcement, pna->index, pna->peer_softref, NULL)) status_unusual("pending node_announcement %s too old?", tal_hex(tmpctx, pna->node_announcement)); /* Never send this again. */ pna->node_announcement = tal_free(pna->node_announcement); } /* We don't need to catch any more node_announcements, since we've * accepted the public channel now. But other pending announcements * may still hold a reference they use in * del_pending_node_announcement, so simply delete it from the map. */ pending_node_map_del(rstate->pending_node_map, notleak(pna)); } static struct pending_cannouncement * find_pending_cannouncement(struct routing_state *rstate, const struct short_channel_id *scid) { struct pending_cannouncement *pann; pann = pending_cannouncement_map_get(&rstate->pending_cannouncements, scid); return pann; } static void destroy_pending_cannouncement(struct pending_cannouncement *pending, struct routing_state *rstate) { pending_cannouncement_map_del(&rstate->pending_cannouncements, pending); } static bool is_local_channel(const struct routing_state *rstate, const struct chan *chan) { return node_id_eq(&chan->nodes[0]->id, &rstate->local_id) || node_id_eq(&chan->nodes[1]->id, &rstate->local_id); } static void add_channel_announce_to_broadcast(struct routing_state *rstate, struct chan *chan, const u8 *channel_announce, u32 timestamp, u32 index) { u8 *addendum = towire_gossip_store_channel_amount(tmpctx, chan->sat); bool is_local = is_local_channel(rstate, chan); chan->bcast.timestamp = timestamp; /* 0, unless we're loading from store */ if (index) chan->bcast.index = index; else chan->bcast.index = gossip_store_add(rstate->gs, channel_announce, chan->bcast.timestamp, is_local, addendum); rstate->local_channel_announced |= is_local; } bool routing_add_channel_announcement(struct routing_state *rstate, const u8 *msg TAKES, struct amount_sat sat, u32 index, struct peer *peer) { struct chan *chan; secp256k1_ecdsa_signature node_signature_1, node_signature_2; secp256k1_ecdsa_signature bitcoin_signature_1, bitcoin_signature_2; u8 *features; struct bitcoin_blkid chain_hash; struct short_channel_id scid; struct node_id node_id_1; struct node_id node_id_2; struct pubkey bitcoin_key_1; struct pubkey bitcoin_key_2; struct unupdated_channel *uc; const u8 *private_updates[2] = { NULL, NULL }; /* Make sure we own msg, even if we don't save it. */ if (taken(msg)) tal_steal(tmpctx, msg); if (!fromwire_channel_announcement( tmpctx, msg, &node_signature_1, &node_signature_2, &bitcoin_signature_1, &bitcoin_signature_2, &features, &chain_hash, &scid, &node_id_1, &node_id_2, &bitcoin_key_1, &bitcoin_key_2)) return false; /* The channel may already exist if it was non-public from * local_add_channel(); normally we don't accept new * channel_announcements. See handle_channel_announcement. */ chan = get_channel(rstate, &scid); /* private updates will exist in the store before the announce: we * can't index those for broadcast since they would predate it, so we * add fresh ones. */ if (chan) { /* If this was in the gossip_store, gossip_store is bad! */ if (index) { status_broken("gossip_store channel_announce" " %u replaces %u!", index, chan->bcast.index); return false; } /* Reload any private updates */ if (chan->half[0].bcast.index) private_updates[0] = gossip_store_get_private_update(NULL, rstate->gs, chan->half[0].bcast.index); if (chan->half[1].bcast.index) private_updates[1] = gossip_store_get_private_update(NULL, rstate->gs, chan->half[1].bcast.index); remove_channel_from_store(rstate, chan); free_chan(rstate, chan); } uc = tal(rstate, struct unupdated_channel); uc->channel_announce = tal_dup_arr(uc, u8, msg, tal_count(msg), 0); uc->added = gossip_time_now(rstate); uc->index = index; uc->sat = sat; uc->scid = scid; uc->id[0] = node_id_1; uc->id[1] = node_id_2; set_softref(uc, &uc->peer_softref, peer); uintmap_add(&rstate->unupdated_chanmap, scid.u64, uc); tal_add_destructor2(uc, destroy_unupdated_channel, rstate); /* If a node_announcement comes along, save it for once we're updated */ catch_node_announcement(uc, rstate, &node_id_1); catch_node_announcement(uc, rstate, &node_id_2); /* If we had private updates, they'll immediately create the channel. */ if (private_updates[0]) routing_add_channel_update(rstate, take(private_updates[0]), 0, peer); if (private_updates[1]) routing_add_channel_update(rstate, take(private_updates[1]), 0, peer); return true; } u8 *handle_channel_announcement(struct routing_state *rstate, const u8 *announce TAKES, u32 current_blockheight, const struct short_channel_id **scid, struct peer *peer) { struct pending_cannouncement *pending; struct bitcoin_blkid chain_hash; u8 *features, *err; secp256k1_ecdsa_signature node_signature_1, node_signature_2; secp256k1_ecdsa_signature bitcoin_signature_1, bitcoin_signature_2; struct chan *chan; pending = tal(rstate, struct pending_cannouncement); set_softref(pending, &pending->peer_softref, peer); pending->updates[0] = NULL; pending->updates[1] = NULL; pending->update_peer_softref[0] = pending->update_peer_softref[1] = NULL; pending->announce = tal_dup_arr(pending, u8, announce, tal_count(announce), 0); pending->update_timestamps[0] = pending->update_timestamps[1] = 0; if (!fromwire_channel_announcement(pending, pending->announce, &node_signature_1, &node_signature_2, &bitcoin_signature_1, &bitcoin_signature_2, &features, &chain_hash, &pending->short_channel_id, &pending->node_id_1, &pending->node_id_2, &pending->bitcoin_key_1, &pending->bitcoin_key_2)) { err = towire_errorfmt(rstate, NULL, "Malformed channel_announcement %s", tal_hex(pending, pending->announce)); goto malformed; } /* If we know the blockheight, and it's in the future, reject * out-of-hand. Remember, it should be 6 deep before they tell us * anyway. */ if (current_blockheight != 0 && short_channel_id_blocknum(&pending->short_channel_id) > current_blockheight) { status_debug("Ignoring future channel_announcment for %s" " (current block %u)", type_to_string(tmpctx, struct short_channel_id, &pending->short_channel_id), current_blockheight); goto ignored; } /* If a prior txout lookup failed there is little point it trying * again. Just drop the announcement and walk away whistling. */ if (in_txout_failures(rstate, &pending->short_channel_id)) { SUPERVERBOSE( "Ignoring channel_announcement of %s due to a prior txout " "query failure. The channel was likely closed on-chain.", type_to_string(tmpctx, struct short_channel_id, &pending->short_channel_id)); goto ignored; } /* Check if we know the channel already (no matter in what * state, we stop here if yes). */ chan = get_channel(rstate, &pending->short_channel_id); if (chan != NULL && is_chan_public(chan)) { SUPERVERBOSE("%s: %s already has public channel", __func__, type_to_string(tmpctx, struct short_channel_id, &pending->short_channel_id)); goto ignored; } if (get_unupdated_channel(rstate, &pending->short_channel_id)) { SUPERVERBOSE("%s: %s already has unupdated channel", __func__, type_to_string(tmpctx, struct short_channel_id, &pending->short_channel_id)); goto ignored; } /* We don't replace previous ones, since we might validate that and * think this one is OK! */ if (find_pending_cannouncement(rstate, &pending->short_channel_id)) { SUPERVERBOSE("%s: %s already has pending cannouncement", __func__, type_to_string(tmpctx, struct short_channel_id, &pending->short_channel_id)); goto ignored; } /* FIXME: Handle duplicates as per BOLT #7 */ /* BOLT #7: * * - if `features` field contains _unknown even bits_: * - MUST NOT parse the remainder of the message. * - MAY discard the message altogether. * - SHOULD NOT connect to the node. * - MAY forward `node_announcement`s that contain an _unknown_ * `features` _bit_, regardless of if it has parsed the announcement * or not. */ if (!features_supported(features)) { status_debug("Ignoring channel announcement, unsupported features %s.", tal_hex(pending, features)); goto ignored; } /* BOLT #7: * The receiving node: *... * - if the specified `chain_hash` is unknown to the receiver: * - MUST ignore the message. */ if (!bitcoin_blkid_eq(&chain_hash, &rstate->chainparams->genesis_blockhash)) { status_debug( "Received channel_announcement %s for unknown chain %s", type_to_string(pending, struct short_channel_id, &pending->short_channel_id), type_to_string(pending, struct bitcoin_blkid, &chain_hash)); goto ignored; } /* Note that if node_id_1 or node_id_2 are malformed, it's caught here */ err = check_channel_announcement(rstate, &pending->node_id_1, &pending->node_id_2, &pending->bitcoin_key_1, &pending->bitcoin_key_2, &node_signature_1, &node_signature_2, &bitcoin_signature_1, &bitcoin_signature_2, pending->announce); if (err) { /* BOLT #7: * * - if `bitcoin_signature_1`, `bitcoin_signature_2`, * `node_signature_1` OR `node_signature_2` are invalid OR NOT * correct: * - SHOULD fail the connection. */ goto malformed; } /* Don't add an infinite number of pending announcements. If we're * catching up with the bitcoin chain, though, they can definitely * pile up. */ if (pending_cannouncement_map_count(&rstate->pending_cannouncements) > 100000) { static bool warned = false; if (!warned) { status_unusual("Flooded by channel_announcements:" " ignoring some"); warned = true; } goto ignored; } status_debug("Received channel_announcement for channel %s", type_to_string(tmpctx, struct short_channel_id, &pending->short_channel_id)); /* Add both endpoints to the pending_node_map so we can stash * node_announcements while we wait for the txout check */ catch_node_announcement(pending, rstate, &pending->node_id_1); catch_node_announcement(pending, rstate, &pending->node_id_2); pending_cannouncement_map_add(&rstate->pending_cannouncements, pending); tal_add_destructor2(pending, destroy_pending_cannouncement, rstate); /* Success */ // MSC: Cppcheck 1.86 gets this false positive // cppcheck-suppress autoVariables *scid = &pending->short_channel_id; return NULL; malformed: tal_free(pending); *scid = NULL; return err; ignored: tal_free(pending); *scid = NULL; return NULL; } static void process_pending_channel_update(struct daemon *daemon, struct routing_state *rstate, const struct short_channel_id *scid, const u8 *cupdate, struct peer *peer) { u8 *err; if (!cupdate) return; err = handle_channel_update(rstate, cupdate, peer, NULL); if (err) { /* FIXME: We could send this error back to peer if != NULL */ status_debug("Pending channel_update for %s from %s: %s", type_to_string(tmpctx, struct short_channel_id, scid), peer ? type_to_string(tmpctx, struct node_id, &peer->id) : "unknown", sanitize_error(tmpctx, err, NULL)); tal_free(err); } } bool handle_pending_cannouncement(struct daemon *daemon, struct routing_state *rstate, const struct short_channel_id *scid, struct amount_sat sat, const u8 *outscript) { const u8 *s; struct pending_cannouncement *pending; pending = find_pending_cannouncement(rstate, scid); if (!pending) return false; /* BOLT #7: * * The receiving node: *... * - if the `short_channel_id`'s output... is spent: * - MUST ignore the message. */ if (tal_count(outscript) == 0) { status_debug("channel_announcement: no unspent txout %s", type_to_string(pending, struct short_channel_id, scid)); tal_free(pending); add_to_txout_failures(rstate, scid); return false; } /* BOLT #7: * * The receiving node: *... * - if the `short_channel_id`'s output does NOT correspond to a P2WSH * (using `bitcoin_key_1` and `bitcoin_key_2`, as specified in * [BOLT #3](03-transactions.md#funding-transaction-output)) ... * - MUST ignore the message. */ s = scriptpubkey_p2wsh(pending, bitcoin_redeem_2of2(pending, &pending->bitcoin_key_1, &pending->bitcoin_key_2)); if (!scripteq(s, outscript)) { status_debug("channel_announcement: txout %s expectes %s, got %s", type_to_string(pending, struct short_channel_id, scid), tal_hex(tmpctx, s), tal_hex(tmpctx, outscript)); tal_free(pending); return false; } /* Remove pending now, so below functions don't see it. */ pending_cannouncement_map_del(&rstate->pending_cannouncements, pending); tal_del_destructor2(pending, destroy_pending_cannouncement, rstate); /* Can fail if channel_announcement too old */ if (!routing_add_channel_announcement(rstate, pending->announce, sat, 0, pending->peer_softref)) status_unusual("Could not add channel_announcement %s: too old?", tal_hex(tmpctx, pending->announce)); else { /* Did we have an update waiting? If so, apply now. */ process_pending_channel_update(daemon, rstate, scid, pending->updates[0], pending->update_peer_softref[0]); process_pending_channel_update(daemon, rstate, scid, pending->updates[1], pending->update_peer_softref[1]); } tal_free(pending); return true; } static void update_pending(struct pending_cannouncement *pending, u32 timestamp, const u8 *update, const u8 direction, struct peer *peer) { SUPERVERBOSE("Deferring update for pending channel %s/%d", type_to_string(tmpctx, struct short_channel_id, &pending->short_channel_id), direction); if (pending->update_timestamps[direction] < timestamp) { if (pending->updates[direction]) { status_debug("Replacing existing update"); tal_free(pending->updates[direction]); } pending->updates[direction] = tal_dup_arr(pending, u8, update, tal_count(update), 0); pending->update_timestamps[direction] = timestamp; clear_softref(pending, &pending->update_peer_softref[direction]); set_softref(pending, &pending->update_peer_softref[direction], peer); } } static void set_connection_values(struct chan *chan, int idx, u32 base_fee, u32 proportional_fee, u32 delay, u8 message_flags, u8 channel_flags, u32 timestamp, struct amount_msat htlc_minimum, struct amount_msat htlc_maximum) { struct half_chan *c = &chan->half[idx]; c->delay = delay; c->htlc_minimum = htlc_minimum; c->htlc_maximum = htlc_maximum; c->base_fee = base_fee; c->proportional_fee = proportional_fee; c->message_flags = message_flags; c->channel_flags = channel_flags; c->bcast.timestamp = timestamp; assert((c->channel_flags & ROUTING_FLAGS_DIRECTION) == idx); SUPERVERBOSE("Channel %s/%d was updated.", type_to_string(tmpctx, struct short_channel_id, &chan->scid), idx); } bool routing_add_channel_update(struct routing_state *rstate, const u8 *update TAKES, u32 index, struct peer *peer) { secp256k1_ecdsa_signature signature; struct short_channel_id short_channel_id; u32 timestamp; u8 message_flags, channel_flags; u16 expiry; struct amount_msat htlc_minimum, htlc_maximum; u32 fee_base_msat; u32 fee_proportional_millionths; struct bitcoin_blkid chain_hash; struct chan *chan; struct half_chan *hc; struct unupdated_channel *uc; u8 direction; struct amount_sat sat; /* Make sure we own msg, even if we don't save it. */ if (taken(update)) tal_steal(tmpctx, update); if (!fromwire_channel_update(update, &signature, &chain_hash, &short_channel_id, ×tamp, &message_flags, &channel_flags, &expiry, &htlc_minimum, &fee_base_msat, &fee_proportional_millionths)) return false; /* If it's flagged as containing the optional field, reparse for * the optional field */ if ((message_flags & ROUTING_OPT_HTLC_MAX_MSAT) && !fromwire_channel_update_option_channel_htlc_max( update, &signature, &chain_hash, &short_channel_id, ×tamp, &message_flags, &channel_flags, &expiry, &htlc_minimum, &fee_base_msat, &fee_proportional_millionths, &htlc_maximum)) return false; direction = channel_flags & 0x1; chan = get_channel(rstate, &short_channel_id); if (chan) { uc = NULL; sat = chan->sat; } else { /* Maybe announcement was waiting for this update? */ uc = get_unupdated_channel(rstate, &short_channel_id); if (!uc) { return false; } sat = uc->sat; } if (message_flags & ROUTING_OPT_HTLC_MAX_MSAT) { /* Reject update if the `htlc_maximum_msat` is greater * than the total available channel satoshis */ if (amount_msat_greater_sat(htlc_maximum, sat)) return false; } else { /* If not indicated, set htlc_max_msat to channel capacity */ if (!amount_sat_to_msat(&htlc_maximum, sat)) { status_broken("Channel capacity %s overflows!", type_to_string(tmpctx, struct amount_sat, &sat)); return false; } } /* Check timestamp is sane (unless from store). */ if (!index && !timestamp_reasonable(rstate, timestamp)) { status_debug("Ignoring update timestamp %u for %s/%u", timestamp, type_to_string(tmpctx, struct short_channel_id, &short_channel_id), direction); return false; } /* OK, we're going to accept this, so create chan if doesn't exist */ if (uc) { assert(!chan); chan = new_chan(rstate, &short_channel_id, &uc->id[0], &uc->id[1], sat); } /* Discard older updates */ hc = &chan->half[direction]; if (is_halfchan_defined(hc)) { /* If we're loading from store, duplicate entries are a bug. */ if (index != 0) { status_broken("gossip_store channel_update %u replaces %u!", index, hc->bcast.index); return false; } if (timestamp <= hc->bcast.timestamp) { SUPERVERBOSE("Ignoring outdated update."); /* Ignoring != failing */ return true; } /* Allow redundant updates once every 7 days */ if (timestamp < hc->bcast.timestamp + GOSSIP_PRUNE_INTERVAL(rstate->dev_fast_gossip_prune) / 2 && !cupdate_different(rstate->gs, hc, update)) { status_debug("Ignoring redundant update for %s/%u" " (last %u, now %u)", type_to_string(tmpctx, struct short_channel_id, &short_channel_id), direction, hc->bcast.timestamp, timestamp); /* Ignoring != failing */ return true; } /* Make sure it's not spamming us. */ if (!ratelimit(rstate, &hc->tokens, hc->bcast.timestamp, timestamp)) { status_debug("Ignoring spammy update for %s/%u" " (last %u, now %u)", type_to_string(tmpctx, struct short_channel_id, &short_channel_id), direction, hc->bcast.timestamp, timestamp); /* Ignoring != failing */ return true; } } /* FIXME: https://github.com/lightningnetwork/lightning-rfc/pull/512 * says we MUST NOT exceed 2^32-1, but c-lightning did, so just trim * rather than rejecting. */ if (amount_msat_greater(htlc_maximum, rstate->chainparams->max_payment)) htlc_maximum = rstate->chainparams->max_payment; set_connection_values(chan, direction, fee_base_msat, fee_proportional_millionths, expiry, message_flags, channel_flags, timestamp, htlc_minimum, htlc_maximum); /* Safe even if was never added, but if it's a private channel it * would be a WIRE_GOSSIP_STORE_PRIVATE_UPDATE. */ gossip_store_delete(rstate->gs, &hc->bcast, is_chan_public(chan) ? WIRE_CHANNEL_UPDATE : WIRE_GOSSIP_STORE_PRIVATE_UPDATE); /* BOLT #7: * - MUST consider the `timestamp` of the `channel_announcement` to be * the `timestamp` of a corresponding `channel_update`. * - MUST consider whether to send the `channel_announcement` after * receiving the first corresponding `channel_update`. */ if (uc) { add_channel_announce_to_broadcast(rstate, chan, uc->channel_announce, timestamp, uc->index); } else if (!is_chan_public(chan)) { /* For private channels, we get updates without an announce: don't * broadcast them! But save local ones to store anyway. */ assert(is_local_channel(rstate, chan)); /* Don't save if we're loading from store */ if (!index) { hc->bcast.index = gossip_store_add_private_update(rstate->gs, update); } else hc->bcast.index = index; return true; } /* If we're loading from store, this means we don't re-add to store. */ if (index) hc->bcast.index = index; else { hc->bcast.index = gossip_store_add(rstate->gs, update, hc->bcast.timestamp, is_local_channel(rstate, chan), NULL); if (hc->bcast.timestamp > rstate->last_timestamp && hc->bcast.timestamp < time_now().ts.tv_sec) rstate->last_timestamp = hc->bcast.timestamp; peer_supplied_good_gossip(peer, 1); } if (uc) { /* If we were waiting for these nodes to appear (or gain a public channel), process node_announcements now */ process_pending_node_announcement(rstate, &chan->nodes[0]->id); process_pending_node_announcement(rstate, &chan->nodes[1]->id); tal_free(uc); } return true; } bool would_ratelimit_cupdate(struct routing_state *rstate, const struct half_chan *hc, u32 timestamp) { return update_tokens(rstate, hc->tokens, hc->bcast.timestamp, timestamp) >= TOKENS_PER_MSG; } static const struct node_id *get_channel_owner(struct routing_state *rstate, const struct short_channel_id *scid, int direction) { struct chan *chan = get_channel(rstate, scid); struct unupdated_channel *uc; if (chan) return &chan->nodes[direction]->id; /* Might be unupdated channel */ uc = get_unupdated_channel(rstate, scid); if (uc) return &uc->id[direction]; return NULL; } void remove_channel_from_store(struct routing_state *rstate, struct chan *chan) { int update_type, announcment_type; if (is_chan_public(chan)) { update_type = WIRE_CHANNEL_UPDATE; announcment_type = WIRE_CHANNEL_ANNOUNCEMENT; } else { update_type = WIRE_GOSSIP_STORE_PRIVATE_UPDATE; announcment_type = WIRE_GOSSIPD_LOCAL_ADD_CHANNEL; } /* If these aren't in the store, these are noops. */ gossip_store_delete(rstate->gs, &chan->bcast, announcment_type); gossip_store_delete(rstate->gs, &chan->half[0].bcast, update_type); gossip_store_delete(rstate->gs, &chan->half[1].bcast, update_type); } u8 *handle_channel_update(struct routing_state *rstate, const u8 *update TAKES, struct peer *peer, struct short_channel_id *unknown_scid) { u8 *serialized; const struct node_id *owner; secp256k1_ecdsa_signature signature; struct short_channel_id short_channel_id; u32 timestamp; u8 message_flags, channel_flags; u16 expiry; struct amount_msat htlc_minimum; u32 fee_base_msat; u32 fee_proportional_millionths; struct bitcoin_blkid chain_hash; u8 direction; size_t len = tal_count(update); struct pending_cannouncement *pending; u8 *err; serialized = tal_dup_arr(tmpctx, u8, update, len, 0); if (!fromwire_channel_update(serialized, &signature, &chain_hash, &short_channel_id, ×tamp, &message_flags, &channel_flags, &expiry, &htlc_minimum, &fee_base_msat, &fee_proportional_millionths)) { err = towire_errorfmt(rstate, NULL, "Malformed channel_update %s", tal_hex(tmpctx, serialized)); return err; } direction = channel_flags & 0x1; /* BOLT #7: * * The receiving node: *... * - if the specified `chain_hash` value is unknown (meaning it isn't * active on the specified chain): * - MUST ignore the channel update. */ if (!bitcoin_blkid_eq(&chain_hash, &rstate->chainparams->genesis_blockhash)) { status_debug("Received channel_update for unknown chain %s", type_to_string(tmpctx, struct bitcoin_blkid, &chain_hash)); return NULL; } /* If we dropped the matching announcement for this channel due to the * txout query failing, don't report failure, it's just too noisy on * mainnet */ if (in_txout_failures(rstate, &short_channel_id)) return NULL; /* If we have an unvalidated channel, just queue on that */ pending = find_pending_cannouncement(rstate, &short_channel_id); if (pending) { status_debug("Updated pending announce with update %s/%u", type_to_string(tmpctx, struct short_channel_id, &short_channel_id), direction); update_pending(pending, timestamp, serialized, direction, peer); return NULL; } owner = get_channel_owner(rstate, &short_channel_id, direction); if (!owner) { if (unknown_scid) *unknown_scid = short_channel_id; bad_gossip_order(serialized, peer, tal_fmt(tmpctx, "%s/%u", type_to_string(tmpctx, struct short_channel_id, &short_channel_id), direction)); return NULL; } err = check_channel_update(rstate, owner, &signature, serialized); if (err) { /* BOLT #7: * * - if `signature` is not a valid signature, using `node_id` * of the double-SHA256 of the entire message following the * `signature` field (including unknown fields following * `fee_proportional_millionths`): * - MUST NOT process the message further. * - SHOULD fail the connection. */ return err; } status_debug("Received channel_update for channel %s/%d now %s (from %s)", type_to_string(tmpctx, struct short_channel_id, &short_channel_id), channel_flags & 0x01, channel_flags & ROUTING_FLAGS_DISABLED ? "DISABLED" : "ACTIVE", peer ? type_to_string(tmpctx, struct node_id, &peer->id) : "unknown"); routing_add_channel_update(rstate, take(serialized), 0, peer); return NULL; } struct wireaddr *read_addresses(const tal_t *ctx, const u8 *ser) { const u8 *cursor = ser; size_t len = tal_count(ser); struct wireaddr *wireaddrs = tal_arr(ctx, struct wireaddr, 0); while (cursor && len) { struct wireaddr wireaddr; /* BOLT #7: * * The receiving node: *... * - SHOULD ignore the first `address descriptor` that does * NOT match the types defined above. */ if (!fromwire_wireaddr(&cursor, &len, &wireaddr)) { if (!cursor) /* Parsing address failed */ return tal_free(wireaddrs); /* Unknown type, stop there. */ status_debug("read_addresses: unknown address type %u", cursor[0]); break; } tal_arr_expand(&wireaddrs, wireaddr); } return wireaddrs; } bool routing_add_node_announcement(struct routing_state *rstate, const u8 *msg TAKES, u32 index, struct peer *peer, bool *was_unknown) { struct node *node; secp256k1_ecdsa_signature signature; u32 timestamp; struct node_id node_id; u8 rgb_color[3]; u8 alias[32]; u8 *features, *addresses; if (was_unknown) *was_unknown = false; /* Make sure we own msg, even if we don't save it. */ if (taken(msg)) tal_steal(tmpctx, msg); /* Note: validity of node_id is already checked. */ if (!fromwire_node_announcement(tmpctx, msg, &signature, &features, ×tamp, &node_id, rgb_color, alias, &addresses)) { return false; } /* Only log this if *not* loading from store. */ if (!index) status_debug("Received node_announcement for node %s", type_to_string(tmpctx, struct node_id, &node_id)); /* Check timestamp is sane (unless from gossip_store). */ if (!index && !timestamp_reasonable(rstate, timestamp)) { status_debug("Ignoring node_announcement timestamp %u for %s", timestamp, type_to_string(tmpctx, struct node_id, &node_id)); return false; } node = get_node(rstate, &node_id); if (node == NULL || !node_has_broadcastable_channels(node)) { struct pending_node_announce *pna; /* BOLT #7: * * - if `node_id` is NOT previously known from a * `channel_announcement` message, OR if `timestamp` is NOT * greater than the last-received `node_announcement` from * this `node_id`: * - SHOULD ignore the message. */ /* Check if we are currently verifying the txout for a * matching channel */ pna = pending_node_map_get(rstate->pending_node_map, &node_id); if (!pna) { if (was_unknown) *was_unknown = true; bad_gossip_order(msg, peer, type_to_string(tmpctx, struct node_id, &node_id)); return false; } else if (timestamp <= pna->timestamp) /* Ignore old ones: they're OK (unless from store). */ return index == 0; SUPERVERBOSE("Deferring node_announcement for node %s", type_to_string(tmpctx, struct node_id, &node_id)); pna->timestamp = timestamp; pna->index = index; tal_free(pna->node_announcement); clear_softref(pna, &pna->peer_softref); pna->node_announcement = tal_dup_arr(pna, u8, msg, tal_count(msg), 0); set_softref(pna, &pna->peer_softref, peer); return true; } if (node->bcast.index) { if (index != 0) { status_broken("gossip_store node_announcement %u replaces %u!", index, node->bcast.index); return false; } if (node->bcast.timestamp >= timestamp) { SUPERVERBOSE("Ignoring node announcement, it's outdated."); /* OK unless we're loading from store */ return index == 0; } /* Allow redundant updates once every 7 days */ if (timestamp < node->bcast.timestamp + GOSSIP_PRUNE_INTERVAL(rstate->dev_fast_gossip_prune) / 2 && !nannounce_different(rstate->gs, node, msg)) { status_debug("Ignoring redundant nannounce for %s" " (last %u, now %u)", type_to_string(tmpctx, struct node_id, &node_id), node->bcast.timestamp, timestamp); /* Ignoring != failing */ return true; } /* Make sure it's not spamming us. */ if (!ratelimit(rstate, &node->tokens, node->bcast.timestamp, timestamp)) { status_debug("Ignoring spammy nannounce for %s" " (last %u, now %u)", type_to_string(tmpctx, struct node_id, &node_id), node->bcast.timestamp, timestamp); /* Ignoring != failing */ return true; } } /* Harmless if it was never added */ gossip_store_delete(rstate->gs, &node->bcast, WIRE_NODE_ANNOUNCEMENT); node->bcast.timestamp = timestamp; if (node->bcast.timestamp > rstate->last_timestamp && node->bcast.timestamp < time_now().ts.tv_sec) rstate->last_timestamp = node->bcast.timestamp; if (index) node->bcast.index = index; else { node->bcast.index = gossip_store_add(rstate->gs, msg, node->bcast.timestamp, node_id_eq(&node_id, &rstate->local_id), NULL); peer_supplied_good_gossip(peer, 1); } return true; } u8 *handle_node_announcement(struct routing_state *rstate, const u8 *node_ann, struct peer *peer, bool *was_unknown) { u8 *serialized; struct sha256_double hash; secp256k1_ecdsa_signature signature; u32 timestamp; struct node_id node_id; u8 rgb_color[3]; u8 alias[32]; u8 *features, *addresses; struct wireaddr *wireaddrs; size_t len = tal_count(node_ann); if (was_unknown) *was_unknown = false; serialized = tal_dup_arr(tmpctx, u8, node_ann, len, 0); if (!fromwire_node_announcement(tmpctx, serialized, &signature, &features, ×tamp, &node_id, rgb_color, alias, &addresses)) { /* BOLT #7: * * - if `node_id` is NOT a valid compressed public key: * - SHOULD fail the connection. * - MUST NOT process the message further. */ u8 *err = towire_errorfmt(rstate, NULL, "Malformed node_announcement %s", tal_hex(tmpctx, node_ann)); return err; } /* BOLT #7: * * The receiving node: *... * - if `features` field contains _unknown even bits_: * - MUST NOT parse the remainder of the message. * - MAY discard the message altogether. * - SHOULD NOT connect to the node. */ if (!features_supported(features)) { status_debug("Ignoring node announcement for node %s, unsupported features %s.", type_to_string(tmpctx, struct node_id, &node_id), tal_hex(tmpctx, features)); return NULL; } sha256_double(&hash, serialized + 66, tal_count(serialized) - 66); /* If node_id is invalid, it fails here */ if (!check_signed_hash_nodeid(&hash, &signature, &node_id)) { /* BOLT #7: * * - if `signature` is not a valid signature, using * `node_id` of the double-SHA256 of the entire * message following the `signature` field * (including unknown fields following * `fee_proportional_millionths`): * - MUST NOT process the message further. * - SHOULD fail the connection. */ u8 *err = towire_errorfmt(rstate, NULL, "Bad signature for %s hash %s" " on node_announcement %s", type_to_string(tmpctx, secp256k1_ecdsa_signature, &signature), type_to_string(tmpctx, struct sha256_double, &hash), tal_hex(tmpctx, node_ann)); return err; } wireaddrs = read_addresses(tmpctx, addresses); if (!wireaddrs) { /* BOLT #7: * * - if `addrlen` is insufficient to hold the address * descriptors of the known types: * - SHOULD fail the connection. */ u8 *err = towire_errorfmt(rstate, NULL, "Malformed wireaddrs %s in %s.", tal_hex(tmpctx, wireaddrs), tal_hex(tmpctx, node_ann)); return err; } /* May still fail, if we don't know the node. */ routing_add_node_announcement(rstate, serialized, 0, peer, was_unknown); return NULL; } struct route_hop *get_route(const tal_t *ctx, struct routing_state *rstate, const struct node_id *source, const struct node_id *destination, struct amount_msat msat, double riskfactor, u32 final_cltv, double fuzz, u64 seed, struct exclude_entry **excluded, u32 max_hops) { struct chan **route; struct amount_msat total_amount; unsigned int total_delay; struct amount_msat fee; struct route_hop *hops; struct node *n; struct amount_msat *saved_capacity; struct short_channel_id_dir *excluded_chan; struct siphash_seed base_seed; saved_capacity = tal_arr(tmpctx, struct amount_msat, 0); excluded_chan = tal_arr(tmpctx, struct short_channel_id_dir, 0); base_seed.u.u64[0] = base_seed.u.u64[1] = seed; if (amount_msat_eq(msat, AMOUNT_MSAT(0))) return NULL; /* Temporarily set the capacity of the excluded channels and the incoming channels * of excluded nodes to zero. */ for (size_t i = 0; i < tal_count(excluded); i++) { if (excluded[i]->type == EXCLUDE_CHANNEL) { struct short_channel_id_dir *chan_id = &excluded[i]->u.chan_id; struct chan *chan = get_channel(rstate, &chan_id->scid); if (!chan) continue; tal_arr_expand(&saved_capacity, chan->half[chan_id->dir].htlc_maximum); tal_arr_expand(&excluded_chan, *chan_id); chan->half[chan_id->dir].htlc_maximum = AMOUNT_MSAT(0); } else { assert(excluded[i]->type == EXCLUDE_NODE); struct node *node = get_node(rstate, &excluded[i]->u.node_id); if (!node) continue; struct chan_map_iter i; struct chan *chan; for (chan = first_chan(node, &i); chan; chan = next_chan(node, &i)) { int dir = half_chan_to(node, chan); tal_arr_expand(&saved_capacity, chan->half[dir].htlc_maximum); struct short_channel_id_dir id; id.scid = chan->scid; id.dir = dir; tal_arr_expand(&excluded_chan, id); chan->half[dir].htlc_maximum = AMOUNT_MSAT(0); } } } route = find_route(ctx, rstate, source, destination, msat, riskfactor / BLOCKS_PER_YEAR / 100, fuzz, &base_seed, max_hops, &fee); /* Now restore the capacity. */ /* Restoring is done in reverse order, in order to properly * handle the case where a channel is indicated twice in * our input. * Entries in `saved_capacity` of that channel beyond the * first entry will be 0, only the first entry of that * channel will be the correct capacity. * By restoring in reverse order we ensure we can restore * the correct capacity. */ for (ssize_t i = tal_count(excluded_chan) - 1; i >= 0; i--) { struct chan *chan = get_channel(rstate, &excluded_chan[i].scid); if (!chan) continue; chan->half[excluded_chan[i].dir].htlc_maximum = saved_capacity[i]; } if (!route) { return NULL; } /* Fees, delays need to be calculated backwards along route. */ hops = tal_arr(ctx, struct route_hop, tal_count(route)); total_amount = msat; total_delay = final_cltv; /* Start at destination node. */ n = get_node(rstate, destination); for (int i = tal_count(route) - 1; i >= 0; i--) { const struct half_chan *c; int idx = half_chan_to(n, route[i]); c = &route[i]->half[idx]; hops[i].channel_id = route[i]->scid; hops[i].nodeid = n->id; hops[i].amount = total_amount; hops[i].delay = total_delay; hops[i].direction = idx; /* Since we calculated this route, it should not overflow! */ if (!amount_msat_add_fee(&total_amount, c->base_fee, c->proportional_fee)) { status_broken("Route overflow step %i: %s + %u/%u!?", i, type_to_string(tmpctx, struct amount_msat, &total_amount), c->base_fee, c->proportional_fee); return tal_free(hops); } total_delay += c->delay; n = other_node(n, route[i]); } assert(node_id_eq(&n->id, source ? source : &rstate->local_id)); return hops; } void routing_failure(struct routing_state *rstate, const struct node_id *erring_node_id, const struct short_channel_id *scid, int erring_direction, enum onion_type failcode, const u8 *channel_update) { struct chan **pruned = tal_arr(tmpctx, struct chan *, 0); status_debug("Received routing failure 0x%04x (%s), " "erring node %s, " "channel %s/%u", (int) failcode, onion_type_name(failcode), type_to_string(tmpctx, struct node_id, erring_node_id), type_to_string(tmpctx, struct short_channel_id, scid), erring_direction); /* lightningd will only extract this if UPDATE is set. */ if (channel_update) { u8 *err = handle_channel_update(rstate, channel_update, NULL, NULL); if (err) { status_unusual("routing_failure: " "bad channel_update %s", sanitize_error(err, err, NULL)); tal_free(err); } } else if (failcode & UPDATE) { status_unusual("routing_failure: " "UPDATE bit set, no channel_update. " "failcode: 0x%04x", (int) failcode); } /* We respond to permanent errors, ignore the rest: they're * for the pay command to worry about. */ if (!(failcode & PERM)) return; if (failcode & NODE) { struct node *node = get_node(rstate, erring_node_id); if (!node) { status_unusual("routing_failure: Erring node %s not in map", type_to_string(tmpctx, struct node_id, erring_node_id)); } else { struct chan_map_iter i; struct chan *c; status_debug("Deleting node %s", type_to_string(tmpctx, struct node_id, &node->id)); for (c = first_chan(node, &i); c; c = next_chan(node, &i)) { /* Set it up to be pruned. */ tal_arr_expand(&pruned, c); } } } else { struct chan *chan = get_channel(rstate, scid); if (!chan) status_unusual("routing_failure: " "Channel %s unknown", type_to_string(tmpctx, struct short_channel_id, scid)); else { /* This error can be triggered by sendpay if caller * uses the wrong key for dest. */ if (failcode == WIRE_INVALID_ONION_HMAC && !node_id_eq(&chan->nodes[!erring_direction]->id, erring_node_id)) return; status_debug("Deleting channel %s", type_to_string(tmpctx, struct short_channel_id, scid)); /* Set it up to be deleted. */ tal_arr_expand(&pruned, chan); } } /* Now free all the chans and maybe even nodes. */ for (size_t i = 0; i < tal_count(pruned); i++) free_chan(rstate, pruned[i]); } void route_prune(struct routing_state *rstate) { u64 now = gossip_time_now(rstate).ts.tv_sec; /* Anything below this highwater mark ought to be pruned */ const s64 highwater = now - GOSSIP_PRUNE_INTERVAL(rstate->dev_fast_gossip_prune); struct chan **pruned = tal_arr(tmpctx, struct chan *, 0); u64 idx; /* Now iterate through all channels and see if it is still alive */ for (struct chan *chan = uintmap_first(&rstate->chanmap, &idx); chan; chan = uintmap_after(&rstate->chanmap, &idx)) { /* Local-only? Don't prune. */ if (!is_chan_public(chan)) continue; if ((!is_halfchan_defined(&chan->half[0]) || chan->half[0].bcast.timestamp < highwater) && (!is_halfchan_defined(&chan->half[1]) || chan->half[1].bcast.timestamp < highwater)) { status_debug( "Pruning channel %s from network view (ages %"PRIu64" and %"PRIu64"s)", type_to_string(tmpctx, struct short_channel_id, &chan->scid), is_halfchan_defined(&chan->half[0]) ? now - chan->half[0].bcast.timestamp : 0, is_halfchan_defined(&chan->half[1]) ? now - chan->half[1].bcast.timestamp : 0); /* This may perturb iteration so do outside loop. */ tal_arr_expand(&pruned, chan); } } /* Look for channels we had an announcement for, but no update. */ for (struct unupdated_channel *uc = uintmap_first(&rstate->unupdated_chanmap, &idx); uc; uc = uintmap_after(&rstate->unupdated_chanmap, &idx)) { if (uc->added.ts.tv_sec < highwater) { tal_free(uc); } } /* Now free all the chans and maybe even nodes. */ for (size_t i = 0; i < tal_count(pruned); i++) { remove_channel_from_store(rstate, pruned[i]); free_chan(rstate, pruned[i]); } } bool handle_local_add_channel(struct routing_state *rstate, const u8 *msg, u64 index) { struct short_channel_id scid; struct node_id remote_node_id; struct amount_sat sat; struct chan *chan; if (!fromwire_gossipd_local_add_channel(msg, &scid, &remote_node_id, &sat)) { status_broken("Unable to parse local_add_channel message: %s", tal_hex(msg, msg)); return false; } /* Can happen on channeld restart. */ if (get_channel(rstate, &scid)) { status_debug("Attempted to local_add_channel a known channel"); return true; } status_debug("local_add_channel %s", type_to_string(tmpctx, struct short_channel_id, &scid)); /* Create new (unannounced) channel */ chan = new_chan(rstate, &scid, &rstate->local_id, &remote_node_id, sat); if (!index) index = gossip_store_add(rstate->gs, msg, 0, false, NULL); chan->bcast.index = index; return true; } struct timeabs gossip_time_now(const struct routing_state *rstate) { #if DEVELOPER if (rstate->gossip_time) return *rstate->gossip_time; #endif return time_now(); } const char *unfinalized_entries(const tal_t *ctx, struct routing_state *rstate) { struct unupdated_channel *uc; u64 index; struct pending_node_announce *pna; struct pending_node_map_iter it; uc = uintmap_first(&rstate->unupdated_chanmap, &index); if (uc) return tal_fmt(ctx, "Unupdated channel_announcement at %u", uc->index); pna = pending_node_map_first(rstate->pending_node_map, &it); if (pna) return tal_fmt(ctx, "Waiting node_announcement at %u", pna->index); return NULL; } /* Gossip store was corrupt, forget anything we loaded. */ void remove_all_gossip(struct routing_state *rstate) { struct node *n; struct node_map_iter nit; struct chan *c; struct unupdated_channel *uc; u64 index; struct pending_cannouncement *pca; struct pending_cannouncement_map_iter pit; struct pending_node_map_iter pnait; /* We don't want them to try to delete from store, so do this * manually. */ while ((n = node_map_first(rstate->nodes, &nit)) != NULL) { tal_del_destructor2(n, destroy_node, rstate); if (node_uses_chan_map(n)) chan_map_clear(&n->chans.map); node_map_del(rstate->nodes, n); tal_free(n); } /* Now free all the channels. */ while ((c = uintmap_first(&rstate->chanmap, &index)) != NULL) { uintmap_del(&rstate->chanmap, index); #if DEVELOPER c->sat.satoshis = (unsigned long)c; /* Raw: dev-hack */ #endif tal_free(c); } while ((uc = uintmap_first(&rstate->unupdated_chanmap, &index)) != NULL) tal_free(uc); while ((pca = pending_cannouncement_map_first(&rstate->pending_cannouncements, &pit)) != NULL) tal_free(pca); /* Freeing unupdated chanmaps should empty this */ assert(pending_node_map_first(rstate->pending_node_map, &pnait) == NULL); }