Implement IRC peer discovery

bitcoin/signature.c

@@ -251,6 +251,12 @@ size_t signature_to_der(secp256k1_context *secpctx,
 	return len;
 }
 
+bool signature_from_der(secp256k1_context *secpctx,
+			const u8 *der, size_t len, struct signature *sig)
+{
+	return secp256k1_ecdsa_signature_parse_der(secpctx, &sig->sig, der, len);
+}
+
 /* Signature must have low S value. */
 bool sig_valid(secp256k1_context *secpctx, const struct signature *sig)
 {

bitcoin/signature.h

@@ -58,4 +58,8 @@ bool sig_valid(secp256k1_context *secpctx, const struct signature *sig);
 size_t signature_to_der(secp256k1_context *secpctx,
 			u8 der[72], const struct signature *s);
 
+/* Parse DER encoding into signature sig */
+bool signature_from_der(secp256k1_context *secpctx,
+			const u8 *der, size_t len, struct signature *sig);
+
 #endif /* LIGHTNING_BITCOIN_SIGNATURE_H */

daemon/Makefile

@@ -26,6 +26,7 @@ DAEMON_SRC :=					\
 	daemon/feechange.c			\
 	daemon/htlc.c				\
 	daemon/invoice.c			\
+	daemon/irc_announce.c			\
 	daemon/jsonrpc.c			\
 	daemon/lightningd.c			\
 	daemon/netaddr.c			\
@@ -41,6 +42,7 @@ DAEMON_SRC :=					\
 	daemon/wallet.c				\
 	daemon/watch.c				\
 	names.c					\
+	irc.c					\
 	state.c
 
 DAEMON_OBJS := $(DAEMON_SRC:.c=.o)

daemon/chaintopology.c

@@ -493,6 +493,27 @@ u64 get_feerate(struct lightningd_state *dstate)
 	return dstate->topology->feerate;
 }
 
+struct txlocator *locate_tx(const void *ctx, struct lightningd_state *dstate,
+			    const struct sha256_double *txid)
+{
+	struct block *block = block_for_tx(dstate, txid);
+	if (block == NULL) {
+		return NULL;
+	}
+
+	struct txlocator *loc = talz(ctx, struct txlocator);
+	loc->blkheight = block->height;
+
+	size_t i, n = tal_count(block->txids);
+	for (i = 0; i < n; i++) {
+		if (structeq(&block->txids[i], txid)){
+			loc->index = i;
+			break;
+		}
+	}
+	return loc;
+}
+
 void setup_topology(struct lightningd_state *dstate)
 {
 	dstate->topology = tal(dstate, struct topology);

daemon/chaintopology.h

@@ -10,6 +10,16 @@ struct peer;
 struct sha256_double;
 struct txwatch;
 
+/* Information relevant to locating a TX in a blockchain. */
+struct txlocator {
+
+	/* The height of the block that includes this transaction */
+	u32 blkheight;
+
+	/* Position of the transaction in the transactions list */
+	u32 index;
+};
+
 /* This is the number of blocks which would have to be mined to invalidate
  * the tx. */
 size_t get_tx_depth(struct lightningd_state *dstate,
@@ -33,4 +43,6 @@ void broadcast_tx(struct peer *peer, const struct bitcoin_tx *tx);
 
 void setup_topology(struct lightningd_state *dstate);
 
+struct txlocator *locate_tx(const void *ctx, struct lightningd_state *dstate, const struct sha256_double *txid);
+
 #endif /* LIGHTNING_DAEMON_CRYPTOPKT_H */

daemon/irc_announce.c

@@ -0,0 +1,155 @@
+#include "bitcoin/privkey.h"
+#include "bitcoin/signature.h"
+#include "daemon/chaintopology.h"
+#include "daemon/irc_announce.h"
+#include "daemon/lightningd.h"
+#include "daemon/log.h"
+#include "daemon/peer.h"
+#include "daemon/routing.h"
+#include "daemon/secrets.h"
+#include "daemon/timeout.h"
+#include "utils.h"
+
+#include <ccan/list/list.h>
+#include <ccan/str/hex/hex.h>
+
+static bool announce_channel(const tal_t *ctx, struct ircstate *state, struct peer *p)
+{
+	char txid[65];
+	int siglen;
+	u8 der[72];
+	struct signature sig;
+	struct privmsg *msg = talz(ctx, struct privmsg);
+	struct txlocator *loc = locate_tx(ctx, state->dstate, &p->anchor.txid);
+
+	if (loc == NULL)
+		return false;
+
+	bitcoin_txid_to_hex(&p->anchor.txid, txid, sizeof(txid));
+	msg->channel = "#lightning-nodes";
+	msg->msg = tal_fmt(
+		msg, "CHAN %s %s %s %d %d %d %d %d",
+		pubkey_to_hexstr(msg, state->dstate->secpctx, &state->dstate->id),
+		pubkey_to_hexstr(msg, state->dstate->secpctx, p->id),
+		txid,
+		loc->blkheight,
+		loc->index,
+		state->dstate->config.fee_base,
+		state->dstate->config.fee_per_satoshi,
+		p->remote.locktime.locktime
+		);
+
+	privkey_sign(state->dstate, msg->msg, strlen(msg->msg), &sig);
+	siglen = signature_to_der(state->dstate->secpctx, der, &sig);
+	msg->msg = tal_fmt(msg, "%s %s", tal_hexstr(ctx, der, siglen), msg->msg);
+
+	irc_send_msg(state, msg);
+	return true;
+}
+
+static void announce_channels(struct ircstate *state)
+{
+	tal_t *ctx = tal(state, tal_t);
+	struct peer *p;
+
+	list_for_each(&state->dstate->peers, p, list) {
+
+		if (!state_is_normal(p->state))
+			continue;
+		announce_channel(ctx, state, p);
+	}
+	tal_free(ctx);
+
+	new_reltimer(state->dstate, state, time_from_sec(60), announce_channels, state);
+}
+
+/* Reconnect to IRC server upon disconnection. */
+static void handle_irc_disconnect(struct ircstate *state)
+{
+	new_reltimer(state->dstate, state, state->reconnect_timeout, irc_connect, state);
+}
+
+/*
+ * Handle an incoming message by checking if it is a channel
+ * announcement, parse it and add the channel to the topology if yes.
+ *
+ * The format for a valid announcement is:
+ * <sig> CHAN <pk1> <pk2> <anchor txid> <block height> <tx position> <base_fee>
+ * <proportional_fee> <locktime>
+ */
+static void handle_irc_privmsg(struct ircstate *istate, const struct privmsg *msg)
+{
+	int blkheight;
+	char **splits = tal_strsplit(msg, msg->msg + 1, " ", STR_NO_EMPTY);
+
+	if (tal_count(splits) != 11 || !streq(splits[1], "CHAN"))
+		return;
+
+	int siglen = hex_data_size(strlen(splits[0]));
+	u8 *der = tal_hexdata(msg, splits[0], strlen(splits[0]));
+	if (der == NULL)
+		return;
+
+	struct signature sig;
+	struct sha256_double hash;
+	char *content = strchr(msg->msg, ' ') + 1;
+	if (!signature_from_der(istate->dstate->secpctx, der, siglen, &sig))
+		return;
+
+	sha256_double(&hash, content, strlen(content));
+	splits++;
+
+	struct pubkey *pk1 = talz(msg, struct pubkey);
+	struct pubkey *pk2 = talz(msg, struct pubkey);
+	struct sha256_double *txid = talz(msg, struct sha256_double);
+	int index;
+
+	bool ok = true;
+	ok &= pubkey_from_hexstr(istate->dstate->secpctx, splits[1], strlen(splits[1]), pk1);
+	ok &= pubkey_from_hexstr(istate->dstate->secpctx, splits[2], strlen(splits[2]), pk2);
+	ok &= bitcoin_txid_from_hex(splits[3], strlen(splits[3]), txid);
+	blkheight = atoi(splits[4]);
+	index = atoi(splits[5]);
+	if (!ok || index < 0 || blkheight < 0) {
+		log_debug(istate->dstate->base_log, "Unable to parse channel announcent.");
+		return;
+	}
+
+	if (!check_signed_hash(istate->dstate->secpctx, &hash, &sig, pk1)) {
+		log_debug(istate->log,
+			  "Ignoring announcement from %s, signature check failed.",
+			  splits[1]);
+		return;
+	}
+
+	/*
+	 * FIXME Check in topology that the tx is in the block and
+	 * that the endpoints match.
+	 */
+
+	add_connection(istate->dstate, pk1, pk2, atoi(splits[6]),
+		       atoi(splits[7]), atoi(splits[8]), 6);
+}
+
+void setup_irc_connection(struct lightningd_state *dstate)
+{
+	// Register callback
+	irc_privmsg_cb = *handle_irc_privmsg;
+	irc_disconnect_cb = *handle_irc_disconnect;
+
+	struct ircstate *state = talz(dstate, struct ircstate);
+	state->dstate = dstate;
+	state->server = "irc.freenode.net";
+	state->reconnect_timeout = time_from_sec(15);
+	state->log = new_log(state, state->dstate->log_record, "%s:irc",
+			     log_prefix(state->dstate->base_log));
+
+	/* Truncate nick at 13 bytes, would be imposed by freenode anyway */
+	state->nick = tal_fmt(
+		state,
+		"N%.12s",
+		pubkey_to_hexstr(state, dstate->secpctx, &dstate->id) + 1);
+
+	irc_connect(state);
+	announce_channels(state);
+}

daemon/irc_announce.h

@@ -0,0 +1,9 @@
+#ifndef LIGHTNING_DAEMON_IRC_ANNOUNCE_H
+#define LIGHTNING_DAEMON_IRC_ANNOUNCE_H
+#include "config.h"
+#include "irc.h"
+
+// Main entrypoint for the lightning daemon
+void setup_irc_connection(struct lightningd_state *dstate);
+
+#endif /* LIGHTNING_DAEMON_IRC_ANNOUNCE_H */

daemon/lightningd.c

@@ -3,6 +3,7 @@
 #include "configdir.h"
 #include "controlled_time.h"
 #include "db.h"
+#include "irc_announce.h"
 #include "jsonrpc.h"
 #include "lightningd.h"
 #include "log.h"
@@ -145,6 +146,9 @@ static void config_register_opts(struct lightningd_state *dstate)
 			 dstate,
 			 "Add route of form srcid/dstid/base/var/delay/minblocks"
 			 "(base in millisatoshi, var in millionths of satoshi per satoshi)");
+	opt_register_noarg("--disable-irc", opt_set_invbool,
+			   &dstate->config.use_irc,
+			   "Disable IRC peer discovery for routing");
 }
 
 static void dev_register_opts(struct lightningd_state *dstate)
@@ -210,6 +214,9 @@ static void default_config(struct config *config)
 	config->fee_base = 546000;
 	/* Take 0.001% */
 	config->fee_per_satoshi = 10;
+
+	/* Discover new peers using IRC */
+	config->use_irc = true;
 }
 
 static void check_config(struct lightningd_state *dstate)
@@ -360,6 +367,10 @@ int main(int argc, char *argv[])
 	/* Set up connections from peers. */
 	setup_listeners(dstate, portnum);
 
+	/* set up IRC peer discovery */
+	if (dstate->config.use_irc)
+		setup_irc_connection(dstate);
+
 	/* Make sure we use the artificially-controlled time for timers */
 	io_time_override(controlled_time);
 

daemon/lightningd.h

@@ -56,6 +56,9 @@ struct config {
 
 	/* How long between changing commit and sending COMMIT message. */
 	struct timerel commit_time;
+
+	/* Whether to enable IRC peer discovery. */
+	bool use_irc;
 };
 
 /* Here's where the global variables hide! */