#include "gossip_control.h"
#include "hsm_control.h"
#include "lightningd.h"
#include "peer_control.h"
#include "subd.h"
#include <backtrace.h>
#include <ccan/array_size/array_size.h>
#include <ccan/cast/cast.h>
#include <ccan/crypto/hkdf_sha256/hkdf_sha256.h>
#include <ccan/err/err.h>
#include <ccan/io/fdpass/fdpass.h>
#include <ccan/io/io.h>
#include <ccan/json_escape/json_escape.h>
#include <ccan/noerr/noerr.h>
#include <ccan/pipecmd/pipecmd.h>
#include <ccan/read_write_all/read_write_all.h>
#include <ccan/take/take.h>
#include <ccan/tal/grab_file/grab_file.h>
#include <ccan/tal/path/path.h>
#include <ccan/tal/str/str.h>
#include <common/daemon.h>
#include <common/ecdh_hsmd.h>
#include <common/features.h>
#include <common/memleak.h>
#include <common/timeout.h>
#include <common/utils.h>
#include <common/version.h>
#include <errno.h>
#include <fcntl.h>
#include <gen_header_versions.h>
#include <lightningd/bitcoind.h>
#include <lightningd/chaintopology.h>
#include <lightningd/channel_control.h>
#include <lightningd/coin_mvts.h>
#include <lightningd/connect_control.h>
#include <lightningd/invoice.h>
#include <lightningd/io_loop_with_timers.h>
#include <lightningd/jsonrpc.h>
#include <lightningd/log.h>
#include <lightningd/memdump.h>
#include <lightningd/onchain_control.h>
#include <lightningd/options.h>
#include <signal.h>
#include <sodium.h>
#include <sys/resource.h>
#include <sys/types.h>
#include <unistd.h>
static void destroy_alt_subdaemons(struct lightningd *ld);
#if DEVELOPER
static void memleak_help_alt_subdaemons(struct htable *memtable,
struct lightningd *ld);
#endif /* DEVELOPER */
static struct lightningd *new_lightningd(const tal_t *ctx)
{
struct lightningd *ld = tal(ctx, struct lightningd);
#if DEVELOPER
ld->dev_debug_subprocess = NULL;
ld->dev_disconnect_fd = -1;
ld->dev_subdaemon_fail = false;
ld->dev_allow_localhost = false;
ld->dev_gossip_time = 0;
ld->dev_fast_gossip = false;
ld->dev_fast_gossip_prune = false;
ld->dev_force_privkey = NULL;
ld->dev_force_bip32_seed = NULL;
ld->dev_force_channel_secrets = NULL;
ld->dev_force_channel_secrets_shaseed = NULL;
ld->dev_force_tmp_channel_id = NULL;
ld->dev_no_htlc_timeout = false;
ld->dev_no_version_checks = false;
#endif
list_head_init(&ld->peers);
htlc_in_map_init(&ld->htlcs_in);
htlc_out_map_init(&ld->htlcs_out);
htlc_set_map_init(&ld->htlc_sets);
ld->log_book = new_log_book(ld, 100*1024*1024);
ld->log = new_log(ld, ld->log_book, NULL, "lightningd");
ld->logfile = NULL;
ld->alias = NULL;
ld->rgb = NULL;
list_head_init(&ld->connects);
list_head_init(&ld->waitsendpay_commands);
list_head_init(&ld->sendpay_commands);
list_head_init(&ld->close_commands);
list_head_init(&ld->ping_commands);
list_head_init(&ld->waitblockheight_commands);
ld->proposed_wireaddr = tal_arr(ld, struct wireaddr_internal, 0);
ld->proposed_listen_announce = tal_arr(ld, enum addr_listen_announce, 0);
ld->portnum = DEFAULT_PORT;
ld->listen = true;
ld->autolisten = true;
ld->reconnect = true;
ld->timers = tal(ld, struct timers);
timers_init(ld->timers, time_mono());
ld->topology = new_topology(ld, ld->log);
ld->daemon_parent_fd = -1;
ld->proxyaddr = NULL;
ld->use_proxy_always = false;
ld->pure_tor_setup = false;
ld->tor_service_password = NULL;
ld->max_funding_unconfirmed = 2016;
ld->wallet = NULL;
jsonrpc_setup(ld);
ld->original_directory = path_cwd(ld);
ld->plugins = plugins_new(ld, ld->log_book, ld);
ld->plugins->startup = true;
ld->stop_conn = NULL;
ld->encrypted_hsm = false;
strmap_init(&ld->alt_subdaemons);
tal_add_destructor(ld, destroy_alt_subdaemons);
memleak_add_helper(ld, memleak_help_alt_subdaemons);
ld->initial_umask = umask(0);
umask(ld->initial_umask);
ld->rpc_filemode = 0600;
ld->exit_code = NULL;
list_head_init(&ld->rr_channels);
return ld;
}
static const char *subdaemons[] = {
"lightning_channeld",
"lightning_closingd",
"lightning_connectd",
"lightning_gossipd",
"lightning_hsmd",
"lightning_onchaind",
"lightning_openingd"
};
bool is_subdaemon(const char *sdname)
{
for (size_t i = 0; i < ARRAY_SIZE(subdaemons); i++)
if (streq(sdname, subdaemons[i] + strlen("lightning_")))
return true;
return false;
}
static void destroy_alt_subdaemons(struct lightningd *ld)
{
strmap_clear(&ld->alt_subdaemons);
}
#if DEVELOPER
static void memleak_help_alt_subdaemons(struct htable *memtable,
struct lightningd *ld)
{
memleak_remove_strmap(memtable, &ld->alt_subdaemons);
}
#endif /* DEVELOPER */
const char *subdaemon_path(const tal_t *ctx, const struct lightningd *ld, const char *name)
{
size_t pfxlen = strlen("lightning_");
assert(strlen(name) > pfxlen);
const char *short_name = tal_strdup(ctx, name + pfxlen);
const char *dpath;
const char *alt = strmap_get(&ld->alt_subdaemons, short_name);
if (alt) {
dpath = path_join(ctx, ld->daemon_dir, alt);
} else {
dpath = path_join(ctx, ld->daemon_dir, name);
}
return dpath;
}
void test_subdaemons(const struct lightningd *ld)
{
size_t i;
for (i = 0; i < ARRAY_SIZE(subdaemons); i++) {
int outfd;
const char *dpath = subdaemon_path(tmpctx, ld, subdaemons[i]);
const char *verstring;
pid_t pid = pipecmd(NULL, &outfd, &outfd,
dpath, "--version", NULL);
log_debug(ld->log, "testing %s", dpath);
if (pid == -1)
err(1, "Could not run %s", dpath);
verstring = grab_fd(tmpctx, outfd);
if (!verstring)
err(1, "Could not get output from %s", dpath);
if (!strstarts(verstring, version())
|| verstring[strlen(version())] != '\n')
errx(1, "%s: bad version '%s'",
subdaemons[i], verstring);
waitpid(pid, NULL, 0);
}
}
static bool has_all_subdaemons(const char *daemon_dir)
{
size_t i;
bool missing_daemon = false;
for (i = 0; i < ARRAY_SIZE(subdaemons); ++i) {
if (!path_is_file(path_join(tmpctx, daemon_dir, subdaemons[i]))) {
missing_daemon = true;
break;
}
}
return !missing_daemon;
}
static const char *find_my_directory(const tal_t *ctx, const char *argv0)
{
const char *me = find_my_abspath(NULL, argv0);
return path_dirname(ctx, take(me));
}
static const char *find_my_pkglibexec_path(struct lightningd *ld,
const char *my_path TAKES)
{
const char *pkglibexecdir;
pkglibexecdir = path_join(NULL, my_path, BINTOPKGLIBEXECDIR);
plugins_set_builtin_plugins_dir(ld->plugins,
path_join(tmpctx,
pkglibexecdir, "plugins"));
return path_simplify(ld, take(pkglibexecdir));
}
static const char *find_daemon_dir(struct lightningd *ld, const char *argv0)
{
const char *my_path = find_my_directory(ld, argv0);
if (has_all_subdaemons(my_path)) {
plugins_set_builtin_plugins_dir(ld->plugins,
path_join(tmpctx,
my_path,
"../plugins"));
return my_path;
}
return find_my_pkglibexec_path(ld, take(my_path));
}
static void shutdown_subdaemons(struct lightningd *ld)
{
struct peer *p;
db_begin_transaction(ld->wallet->db);
close(ld->hsm_fd);
ld->connectd = subd_shutdown(ld->connectd, 10);
free_htlcs(ld, NULL);
while ((p = list_top(&ld->peers, struct peer, list)) != NULL) {
struct channel *c;
while ((c = list_top(&p->channels, struct channel, list))
!= NULL) {
tal_free(c);
}
if (p->uncommitted_channel) {
struct uncommitted_channel *uc = p->uncommitted_channel;
p->uncommitted_channel = NULL;
tal_free(uc);
}
tal_free(p);
}
ld->gossip = subd_shutdown(ld->gossip, 10);
ld->hsm = subd_shutdown(ld->hsm, 10);
db_commit_transaction(ld->wallet->db);
}
static void init_txfilter(struct wallet *w, struct txfilter *filter)
{
struct ext_key ext;
u64 bip32_max_index;
bip32_max_index = db_get_intvar(w->db, "bip32_max_index", 0);
for (u64 i = 0; i <= bip32_max_index + w->keyscan_gap; i++) {
if (bip32_key_from_parent(w->bip32_base, i, BIP32_FLAG_KEY_PUBLIC, &ext) != WALLY_OK) {
abort();
}
txfilter_add_derkey(filter, ext.pub_key);
}
}
static void complete_daemonize(struct lightningd *ld)
{
int ok_status = 0;
close(STDIN_FILENO);
close(STDOUT_FILENO);
close(STDERR_FILENO);
if (open("/dev/null", O_WRONLY) != 0)
fatal("Could not open /dev/null: %s", strerror(errno));
if (dup2(0, STDERR_FILENO) != STDERR_FILENO)
fatal("Could not dup /dev/null for stderr: %s", strerror(errno));
close(0);
if (setsid() == (pid_t)-1)
fatal("Could not setsid: %s", strerror(errno));
ld->initial_umask = umask(0);
write_all(ld->daemon_parent_fd, &ok_status, sizeof(ok_status));
close(ld->daemon_parent_fd);
}
static void pidfile_create(const struct lightningd *ld)
{
int pid_fd;
char *pid;
pid_fd = open(ld->pidfile, O_WRONLY|O_CREAT, 0640);
if (pid_fd < 0)
err(1, "Failed to open PID file");
if (lockf(pid_fd, F_TLOCK, 0) < 0)
err(1, "lightningd already running? Error locking PID file");
pid = tal_fmt(tmpctx, "%d\n", getpid());
write_all(pid_fd, pid, strlen(pid));
}
static int io_poll_lightningd(struct pollfd *fds, nfds_t nfds, int timeout)
{
return daemon_poll(fds, nfds, timeout);
}
void notify_new_block(struct lightningd *ld, u32 block_height)
{
htlcs_notify_new_block(ld, block_height);
channel_notify_new_block(ld, block_height);
gossip_notify_new_block(ld, block_height);
waitblockheight_notify_new_block(ld, block_height);
}
static void on_sigint(int _ UNUSED)
{
static const char *msg = "lightningd: SIGINT caught, exiting.\n";
write_all(STDERR_FILENO, msg, strlen(msg));
_exit(1);
}
static void on_sigterm(int _ UNUSED)
{
static const char *msg = "lightningd: SIGTERM caught, exiting.\n";
write_all(STDERR_FILENO, msg, strlen(msg));
_exit(1);
}
static void setup_sig_handlers(void)
{
struct sigaction sigint, sigterm;
memset(&sigint, 0, sizeof(struct sigaction));
memset(&sigterm, 0, sizeof(struct sigaction));
sigint.sa_handler = on_sigint;
sigterm.sa_handler = on_sigterm;
if (1 == getpid()) {
sigaction(SIGINT, &sigint, NULL);
sigaction(SIGTERM, &sigterm, NULL);
}
}
static struct feature_set *default_features(const tal_t *ctx)
{
struct feature_set *ret = NULL;
static const u32 features[] = {
OPTIONAL_FEATURE(OPT_DATA_LOSS_PROTECT),
OPTIONAL_FEATURE(OPT_UPFRONT_SHUTDOWN_SCRIPT),
OPTIONAL_FEATURE(OPT_GOSSIP_QUERIES),
OPTIONAL_FEATURE(OPT_VAR_ONION),
OPTIONAL_FEATURE(OPT_PAYMENT_SECRET),
OPTIONAL_FEATURE(OPT_BASIC_MPP),
OPTIONAL_FEATURE(OPT_GOSSIP_QUERIES_EX),
OPTIONAL_FEATURE(OPT_STATIC_REMOTEKEY),
#if EXPERIMENTAL_FEATURES
OPTIONAL_FEATURE(OPT_ANCHOR_OUTPUTS),
OPTIONAL_FEATURE(OPT_ONION_MESSAGES),
#endif
};
for (size_t i = 0; i < ARRAY_SIZE(features); i++) {
struct feature_set *f
= feature_set_for_feature(NULL, features[i]);
if (!ret)
ret = tal_steal(ctx, f);
else
feature_set_or(ret, take(f));
}
return ret;
}
static void hsm_ecdh_failed(enum status_failreason fail,
const char *fmt, ...)
{
fatal("hsm failure: %s", fmt);
}
void lightningd_exit(struct lightningd *ld, int exit_code)
{
ld->exit_code = tal(ld, int);
*ld->exit_code = exit_code;
io_break(ld);
}
int main(int argc, char *argv[])
{
struct lightningd *ld;
u32 min_blockheight, max_blockheight;
int connectd_gossipd_fd;
int stop_fd;
struct timers *timers;
const char *stop_response;
struct htlc_in_map *unconnected_htlcs_in;
struct ext_key *bip32_base;
struct rlimit nofile = {1024, 1024};
int exit_code = 0;
setrlimit(RLIMIT_NOFILE, &nofile);
setup_locale();
setup_sig_handlers();
check_linked_library_versions();
daemon_setup(argv[0], log_backtrace_print, log_backtrace_exit);
ld = new_lightningd(NULL);
ld->state = LD_STATE_RUNNING;
ld->daemon_dir = find_daemon_dir(ld, argv[0]);
if (!ld->daemon_dir)
errx(1, "Could not find daemons");
ld->our_features = default_features(ld);
handle_early_opts(ld, argc, argv);
plugins_init(ld->plugins);
handle_opts(ld, argc, argv);
pidfile_create(ld);
if (IFDEV(!ld->dev_no_version_checks, 1))
test_subdaemons(ld);
bip32_base = hsm_init(ld);
ld->wallet = wallet_new(ld, ld->timers, bip32_base);
coin_mvts_init_count(ld);
ld->owned_txfilter = txfilter_new(ld);
io_poll_override(io_poll_lightningd);
if (ld->config.keypass)
sodium_munlock(ld->config.keypass->data, sizeof(ld->config.keypass->data));
setup_color_and_alias(ld);
connectd_gossipd_fd = connectd_init(ld);
gossip_init(ld, connectd_gossipd_fd);
db_begin_transaction(ld->wallet->db);
if (!wallet_network_check(ld->wallet))
errx(1, "Wallet network check failed.");
init_txfilter(ld->wallet, ld->owned_txfilter);
wallet_blocks_heights(ld->wallet, UINT32_MAX,
&min_blockheight, &max_blockheight);
if (ld->config.rescan < 0)
max_blockheight = -ld->config.rescan;
else if (max_blockheight < (u32)ld->config.rescan)
max_blockheight = 0;
else if (max_blockheight != UINT32_MAX)
max_blockheight -= ld->config.rescan;
db_commit_transaction(ld->wallet->db);
setup_topology(ld->topology, ld->timers,
min_blockheight, max_blockheight);
db_begin_transaction(ld->wallet->db);
wallet_clean_utxos(ld->wallet, ld->topology->bitcoind);
unconnected_htlcs_in = load_channels_from_wallet(ld);
db_commit_transaction(ld->wallet->db);
jsonrpc_listen(ld->jsonrpc, ld);
plugins_config(ld->plugins);
db_begin_transaction(ld->wallet->db);
htlcs_resubmit(ld, unconnected_htlcs_in);
db_commit_transaction(ld->wallet->db);
connectd_activate(ld);
onchaind_replay_channels(ld);
log_info(ld->log, "--------------------------------------------------");
log_info(ld->log, "Server started with public key %s, alias %s (color #%s) and lightningd %s",
type_to_string(tmpctx, struct node_id, &ld->id),
json_escape(tmpctx, (const char *)ld->alias)->s,
tal_hex(tmpctx, ld->rgb), version());
activate_peers(ld);
begin_topology(ld->topology);
if (ld->daemon_parent_fd != -1)
complete_daemonize(ld);
crashlog = ld->log;
ecdh_hsmd_setup(ld->hsm_fd, hsm_ecdh_failed);
void *io_loop_ret = io_loop_with_timers(ld);
assert(io_loop_ret == ld);
ld->state = LD_STATE_SHUTDOWN;
if (ld->exit_code) {
exit_code = *ld->exit_code;
stop_fd = -1;
stop_response = NULL;
} else {
stop_fd = io_conn_fd(ld->stop_conn);
io_close_taken_fd(ld->stop_conn);
stop_response = tal_steal(NULL, ld->stop_response);
}
shutdown_subdaemons(ld);
plugins_free(ld->plugins);
db_begin_transaction(ld->wallet->db);
tal_free(ld->jsonrpc);
free_unreleased_txs(ld->wallet);
db_commit_transaction(ld->wallet->db);
htlc_in_map_clear(&ld->htlcs_in);
htlc_out_map_clear(&ld->htlcs_out);
remove(ld->pidfile);
clean_tmpctx();
timers = tal_steal(NULL, ld->timers);
tal_free(ld);
timers_cleanup(timers);
tal_free(timers);
opt_free_table();
daemon_shutdown();
if (stop_fd >= 0) {
write_all(stop_fd, stop_response, strlen(stop_response));
close(stop_fd);
tal_free(stop_response);
}
return exit_code;
}
