|
|
|
/* This contains the code which actively seeks out gossip from peers */
|
|
|
|
#include <bitcoin/short_channel_id.h>
|
|
|
|
#include <ccan/list/list.h>
|
|
|
|
#include <ccan/tal/tal.h>
|
|
|
|
#include <common/status.h>
|
|
|
|
#include <common/timeout.h>
|
|
|
|
#include <common/type_to_string.h>
|
|
|
|
#include <gossipd/gossipd.h>
|
|
|
|
#include <gossipd/queries.h>
|
|
|
|
#include <gossipd/routing.h>
|
|
|
|
#include <gossipd/seeker.h>
|
|
|
|
#include <wire/gen_peer_wire.h>
|
|
|
|
|
|
|
|
#define GOSSIP_SEEKER_INTERVAL(seeker) \
|
|
|
|
DEV_FAST_GOSSIP((seeker)->daemon->rstate->dev_fast_gossip, 5, 60)
|
|
|
|
|
|
|
|
enum seeker_state {
|
|
|
|
/* First initialized, no peers. */
|
|
|
|
STARTING_UP_NEED_PEER,
|
|
|
|
|
|
|
|
/* Still streaming gossip from single peer. */
|
|
|
|
STARTING_UP_FIRSTPEER,
|
|
|
|
|
|
|
|
/* Normal running. */
|
|
|
|
NORMAL,
|
|
|
|
};
|
|
|
|
|
|
|
|
/* Gossip we're seeking at the moment. */
|
|
|
|
struct seeker {
|
|
|
|
struct daemon *daemon;
|
|
|
|
|
|
|
|
enum seeker_state state;
|
|
|
|
|
|
|
|
/* Timer which checks on progress every minute */
|
|
|
|
struct oneshot *check_timer;
|
|
|
|
|
|
|
|
/* Channels we've heard about, but don't know. */
|
|
|
|
struct short_channel_id *unknown_scids;
|
|
|
|
|
|
|
|
/* Timestamp of gossip store (or 0). */
|
|
|
|
u32 last_gossip_timestamp;
|
|
|
|
|
|
|
|
/* During startup, we ask a single peer for gossip. */
|
|
|
|
struct peer *random_peer_softref;
|
|
|
|
|
|
|
|
/* This checks progress of our random peer during startup */
|
|
|
|
size_t prev_gossip_count;
|
|
|
|
};
|
|
|
|
|
|
|
|
/* Mutual recursion */
|
|
|
|
static void seeker_check(struct seeker *seeker);
|
|
|
|
|
|
|
|
static void begin_check_timer(struct seeker *seeker)
|
|
|
|
{
|
|
|
|
const u32 polltime = GOSSIP_SEEKER_INTERVAL(seeker);
|
|
|
|
|
|
|
|
seeker->check_timer = new_reltimer(&seeker->daemon->timers,
|
|
|
|
seeker,
|
|
|
|
time_from_sec(polltime),
|
|
|
|
seeker_check, seeker);
|
|
|
|
}
|
|
|
|
|
|
|
|
struct seeker *new_seeker(struct daemon *daemon, u32 timestamp)
|
|
|
|
{
|
|
|
|
struct seeker *seeker = tal(daemon, struct seeker);
|
|
|
|
|
|
|
|
seeker->daemon = daemon;
|
|
|
|
seeker->unknown_scids = tal_arr(seeker, struct short_channel_id, 0);
|
|
|
|
seeker->last_gossip_timestamp = timestamp;
|
|
|
|
seeker->state = STARTING_UP_NEED_PEER;
|
|
|
|
begin_check_timer(seeker);
|
|
|
|
return seeker;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Set this peer as our random peer; return false if NULL. */
|
|
|
|
static bool selected_peer(struct seeker *seeker, struct peer *peer)
|
|
|
|
{
|
|
|
|
if (!peer)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
set_softref(seeker, &seeker->random_peer_softref, peer);
|
|
|
|
|
|
|
|
/* Give it some grace in case we immediately hit timer */
|
|
|
|
seeker->prev_gossip_count
|
|
|
|
= peer->gossip_counter - GOSSIP_SEEKER_INTERVAL(seeker);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool peer_made_progress(struct seeker *seeker)
|
|
|
|
{
|
|
|
|
const struct peer *peer = seeker->random_peer_softref;
|
|
|
|
|
|
|
|
/* Has it made progress (at least one valid update per second)? If
|
|
|
|
* not, we assume it's finished, and if it hasn't, we'll end up
|
|
|
|
* querying backwards in next steps. */
|
|
|
|
if (peer->gossip_counter
|
|
|
|
>= seeker->prev_gossip_count + GOSSIP_SEEKER_INTERVAL(seeker)) {
|
|
|
|
seeker->prev_gossip_count = peer->gossip_counter;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void normal_gossip_start(struct seeker *seeker, struct peer *peer)
|
|
|
|
{
|
|
|
|
u32 start;
|
|
|
|
u8 *msg;
|
|
|
|
|
|
|
|
/* FIXME: gets the last minute of gossip, works around our current
|
|
|
|
* lack of discovery if we're missing gossip. */
|
|
|
|
if (peer->gossip_enabled)
|
|
|
|
start = time_now().ts.tv_sec - 60;
|
|
|
|
else
|
|
|
|
start = UINT32_MAX;
|
|
|
|
|
|
|
|
status_debug("seeker: starting %s from %s",
|
|
|
|
peer->gossip_enabled ? "gossip" : "disabled gossip",
|
|
|
|
type_to_string(tmpctx, struct node_id, &peer->id));
|
|
|
|
|
|
|
|
/* This is allowed even if they don't understand it (odd) */
|
|
|
|
msg = towire_gossip_timestamp_filter(NULL,
|
|
|
|
&seeker->daemon->chain_hash,
|
|
|
|
start,
|
|
|
|
UINT32_MAX);
|
|
|
|
queue_peer_msg(peer, take(msg));
|
|
|
|
}
|
|
|
|
|
|
|
|
/* We have selected this peer to stream us startup gossip */
|
|
|
|
static void peer_gossip_startup(struct seeker *seeker, struct peer *peer)
|
|
|
|
{
|
|
|
|
const u32 polltime = GOSSIP_SEEKER_INTERVAL(seeker);
|
|
|
|
u8 *msg;
|
|
|
|
u32 start;
|
|
|
|
|
|
|
|
if (seeker->last_gossip_timestamp < polltime)
|
|
|
|
start = 0;
|
|
|
|
else
|
|
|
|
start = seeker->last_gossip_timestamp - polltime;
|
|
|
|
|
|
|
|
selected_peer(seeker, peer);
|
|
|
|
|
|
|
|
status_debug("seeker: startup gossip from t=%u from %s",
|
|
|
|
start, type_to_string(tmpctx, struct node_id, &peer->id));
|
|
|
|
msg = towire_gossip_timestamp_filter(NULL,
|
|
|
|
&peer->daemon->chain_hash,
|
|
|
|
start, UINT32_MAX);
|
|
|
|
queue_peer_msg(peer, take(msg));
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool peer_has_gossip_queries(const struct peer *peer)
|
|
|
|
{
|
|
|
|
return peer->gossip_queries_feature;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void check_firstpeer(struct seeker *seeker)
|
|
|
|
{
|
|
|
|
struct peer *peer = seeker->random_peer_softref, *p;
|
|
|
|
|
|
|
|
/* It might have died, pick another. */
|
|
|
|
if (!peer) {
|
|
|
|
status_debug("seeker: startup peer died, re-choosing");
|
|
|
|
peer = random_peer(seeker->daemon, peer_has_gossip_queries);
|
|
|
|
/* No peer? Wait for a new one to join. */
|
|
|
|
if (!peer) {
|
|
|
|
status_debug("seeker: no peers, waiting");
|
|
|
|
seeker->state = STARTING_UP_NEED_PEER;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
peer_gossip_startup(seeker, peer);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* If no progress, we assume it's finished, and if it hasn't,
|
|
|
|
* we'll end up querying backwards in next steps. */
|
|
|
|
if (peer_made_progress(seeker))
|
|
|
|
return;
|
|
|
|
|
|
|
|
/* Begin normal gossip regime */
|
|
|
|
status_debug("seeker: startup peer finished");
|
|
|
|
clear_softref(seeker, &seeker->random_peer_softref);
|
|
|
|
seeker->state = NORMAL;
|
|
|
|
list_for_each(&seeker->daemon->peers, p, list) {
|
|
|
|
if (p == peer)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
normal_gossip_start(seeker, p);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Periodic timer to see how our gossip is going. */
|
|
|
|
static void seeker_check(struct seeker *seeker)
|
|
|
|
{
|
|
|
|
switch (seeker->state) {
|
|
|
|
case STARTING_UP_NEED_PEER:
|
|
|
|
break;
|
|
|
|
case STARTING_UP_FIRSTPEER:
|
|
|
|
check_firstpeer(seeker);
|
|
|
|
break;
|
|
|
|
case NORMAL:
|
|
|
|
/* FIXME: Check! */
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
begin_check_timer(seeker);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* We get this when we have a new peer. */
|
|
|
|
void seeker_setup_peer_gossip(struct seeker *seeker, struct peer *peer)
|
|
|
|
{
|
|
|
|
/* Can't do anything useful with these peers. */
|
|
|
|
if (!peer->gossip_queries_feature)
|
|
|
|
return;
|
|
|
|
|
|
|
|
switch (seeker->state) {
|
|
|
|
case STARTING_UP_NEED_PEER:
|
|
|
|
peer_gossip_startup(seeker, peer);
|
|
|
|
seeker->state = STARTING_UP_FIRSTPEER;
|
|
|
|
return;
|
|
|
|
case STARTING_UP_FIRSTPEER:
|
|
|
|
/* Waiting for seeker_check to release us */
|
|
|
|
return;
|
|
|
|
case NORMAL:
|
|
|
|
normal_gossip_start(seeker, peer);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
abort();
|
|
|
|
}
|
|
|
|
|
|
|
|
/* We've found gossip is missing. */
|
|
|
|
void gossip_missing(struct daemon *daemon, struct seeker *seeker)
|
|
|
|
{
|
|
|
|
/* FIXME */
|
|
|
|
}
|
|
|
|
|
|
|
|
bool remove_unknown_scid(struct seeker *seeker,
|
|
|
|
const struct short_channel_id *scid)
|
|
|
|
{
|
|
|
|
for (size_t i = 0; i < tal_count(seeker->unknown_scids); i++) {
|
|
|
|
if (short_channel_id_eq(&seeker->unknown_scids[i], scid)) {
|
|
|
|
tal_arr_remove(&seeker->unknown_scids, i);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool add_unknown_scid(struct seeker *seeker,
|
|
|
|
const struct short_channel_id *scid)
|
|
|
|
{
|
|
|
|
/* Don't go overboard if we're already asking for a lot. */
|
|
|
|
if (tal_count(seeker->unknown_scids) > 1000)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
/* Check we're not already getting this one. */
|
|
|
|
for (size_t i = 0; i < tal_count(seeker->unknown_scids); i++)
|
|
|
|
if (short_channel_id_eq(&seeker->unknown_scids[i], scid))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
tal_arr_expand(&seeker->unknown_scids, *scid);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* This peer told us about an update to an unknown channel. Ask it for a
|
|
|
|
* channel_announcement. */
|
|
|
|
void query_unknown_channel(struct daemon *daemon,
|
|
|
|
struct peer *peer,
|
|
|
|
const struct short_channel_id *id)
|
|
|
|
{
|
|
|
|
/* Too many, or duplicate? */
|
|
|
|
if (!add_unknown_scid(daemon->seeker, id))
|
|
|
|
return;
|
|
|
|
|
|
|
|
/* This is best effort: if peer is busy, we'll try next time. */
|
|
|
|
query_short_channel_ids(daemon, peer, daemon->seeker->unknown_scids,
|
|
|
|
NULL);
|
|
|
|
}
|