From bf118f1b86cbb744682983b18f34775263cf53dd Mon Sep 17 00:00:00 2001 From: Rusty Russell Date: Tue, 10 Jan 2017 15:38:33 +1030 Subject: [PATCH] lightningd/lightningd: add connect command. Unlike the old daemon, this just connects; a separate command will be needed to create a channel. Signed-off-by: Rusty Russell --- lightningd/Makefile | 2 + lightningd/lightningd.h | 8 +++ lightningd/peer_control.c | 132 +++++++++++++++++++++++++++++++++----- 3 files changed, 127 insertions(+), 15 deletions(-) diff --git a/lightningd/Makefile b/lightningd/Makefile index 84f688e30..d037e53b5 100644 --- a/lightningd/Makefile +++ b/lightningd/Makefile @@ -10,6 +10,8 @@ default: lightningd-all LIGHTNINGD_OLD_SRC := \ daemon/configdir.c \ + daemon/dns.c \ + daemon/netaddr.c \ daemon/json.c \ daemon/jsonrpc.c \ daemon/log.c \ diff --git a/lightningd/lightningd.h b/lightningd/lightningd.h index fc75d8ae8..3474e1de4 100644 --- a/lightningd/lightningd.h +++ b/lightningd/lightningd.h @@ -1,6 +1,7 @@ #ifndef LIGHTNING_LIGHTNINGD_LIGHTNINGD_H #define LIGHTNING_LIGHTNINGD_LIGHTNINGD_H #include "config.h" +#include #include /* BOLT #1: @@ -27,4 +28,11 @@ struct lightningd { /* All peers we're tracking. */ struct list_head peers; }; + +/* FIXME */ +static inline struct lightningd * +ld_from_dstate(const struct lightningd_state *dstate) +{ + return container_of(dstate, struct lightningd, dstate); +} #endif /* LIGHTNING_LIGHTNINGD_LIGHTNINGD_H */ diff --git a/lightningd/peer_control.c b/lightningd/peer_control.c index 47f334cdd..dfcde1750 100644 --- a/lightningd/peer_control.c +++ b/lightningd/peer_control.c @@ -4,6 +4,9 @@ #include #include #include +#include +#include +#include #include #include #include @@ -51,25 +54,29 @@ static struct peer *new_peer(const tal_t *ctx, struct lightningd *ld, int fd) return peer; } -static void handshake_responder_succeeded(struct subdaemon *hs, const u8 *msg, - struct peer *peer) +static void handshake_succeeded(struct subdaemon *hs, const u8 *msg, + struct peer *peer) { struct crypto_state *cs; - struct pubkey id; - if (!fromwire_handshake_responder_resp(msg, msg, NULL, &id, &cs)) { - log_broken(hs->log, "Malformed responder resp: %s", - tal_hex(peer, msg)); - tal_free(peer); - return; + if (!peer->id) { + struct pubkey id; + + if (!fromwire_handshake_responder_resp(msg, msg, NULL, &id, &cs)) + goto err; + peer->id = tal_dup(peer, struct pubkey, &id); + log_info_struct(hs->log, "Peer in from %s", + struct pubkey, peer->id); + } else { + if (!fromwire_handshake_initiator_resp(msg, msg, NULL, &cs)) + goto err; + log_info_struct(hs->log, "Peer out to %s", + struct pubkey, peer->id); } /* FIXME: Look for peer duplicates! */ /* Peer is now a full-fledged citizen. */ - peer->id = tal_dup(peer, struct pubkey, &id); - - log_info_struct(hs->log, "Peer in from %s", struct pubkey, peer->id); /* Tell handshaked to exit. */ subdaemon_req(peer->owner, take(towire_handshake_exit_req(msg)), @@ -77,11 +84,19 @@ static void handshake_responder_succeeded(struct subdaemon *hs, const u8 *msg, /* FIXME: start lightningd_connect */ peer->owner = NULL; + return; + +err: + log_broken(hs->log, "Malformed resp: %s", tal_hex(peer, msg)); + close(peer->fd); + tal_free(peer); } static void peer_got_hsmfd(struct subdaemon *hsm, const u8 *msg, struct peer *peer) { + const u8 *req; + if (!fromwire_hsmctl_hsmfd_ecdh_response(msg, NULL)) { log_unusual(peer->ld->log, "Malformed hsmfd response: %s", tal_hex(peer, msg)); @@ -105,12 +120,16 @@ static void peer_got_hsmfd(struct subdaemon *hsm, const u8 *msg, * when it does. */ tal_steal(peer->owner, peer); + if (peer->id) + req = towire_handshake_initiator_req(peer, &peer->ld->dstate.id, + peer->id); + else + req = towire_handshake_responder_req(peer, &peer->ld->dstate.id); + /* Now hand peer fd to the handshake daemon, it hand back on success */ - subdaemon_req(peer->owner, - take(towire_handshake_responder_req(peer, - &peer->ld->dstate.id)), + subdaemon_req(peer->owner, take(req), peer->fd, &peer->fd, - handshake_responder_succeeded, peer); + handshake_succeeded, peer); /* Peer struct longer owns fd. */ peer->fd = -1; @@ -234,3 +253,86 @@ void setup_listeners(struct lightningd *ld) fatal("Could not bind to a network address on port %u", ld->dstate.portnum); } + +struct json_connecting { + /* This owns us, so we're freed after command_fail or command_success */ + struct command *cmd; + const char *name, *port; + struct pubkey id; +}; + +/* FIXME: timeout handshake if taking too long? */ +static struct io_plan *peer_out(struct io_conn *conn, + struct lightningd_state *dstate, + struct json_connecting *jc) +{ + struct lightningd *ld = ld_from_dstate(jc->cmd->dstate); + struct peer *peer = new_peer(ld, ld, io_conn_fd(conn)); + + /* We already know ID we're trying to reach. */ + peer->id = tal_dup(peer, struct pubkey, &jc->id); + + /* Get HSM fd for this peer. */ + /* FIXME: We use pointer as ID. */ + subdaemon_req(ld->hsm, take(towire_hsmctl_hsmfd_ecdh(ld, (u64)peer)), + -1, &peer->hsmfd, peer_got_hsmfd, peer); + + /* We don't need conn, we'll pass fd to handshaked. */ + return io_close_taken_fd(conn); +} + +static void connect_failed(struct lightningd_state *dstate, + struct json_connecting *connect) +{ + /* FIXME: Better diagnostics! */ + command_fail(connect->cmd, "Failed to connect to peer %s:%s", + connect->name, connect->port); +} + +static void json_connect(struct command *cmd, + const char *buffer, const jsmntok_t *params) +{ + struct json_connecting *connect; + jsmntok_t *host, *port, *idtok; + const tal_t *tmpctx = tal_tmpctx(cmd); + + if (!json_get_params(buffer, params, + "host", &host, + "port", &port, + "id", &idtok, + NULL)) { + command_fail(cmd, "Need host, port and id to connect"); + return; + } + + connect = tal(cmd, struct json_connecting); + connect->cmd = cmd; + connect->name = tal_strndup(connect, buffer + host->start, + host->end - host->start); + connect->port = tal_strndup(connect, buffer + port->start, + port->end - port->start); + + if (!pubkey_from_hexstr(buffer + idtok->start, + idtok->end - idtok->start, &connect->id)) { + command_fail(cmd, "id %.*s not valid", + idtok->end - idtok->start, + buffer + idtok->start); + return; + } + + if (!dns_resolve_and_connect(cmd->dstate, connect->name, connect->port, + peer_out, connect_failed, connect)) { + command_fail(cmd, "DNS failed"); + return; + } + + tal_free(tmpctx); +} + +static const struct json_command connect_command = { + "connect", + json_connect, + "Connect to a {host} at {port} expecting node {id}", + "Returns the {id} on success (once channel established)" +}; +AUTODATA(json_command, &connect_command);