#include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include namespace llarp { std::string tostr(string_view val) { return {val.begin(), val.end()}; } int svtoi(string_view val) { auto str = tostr(val); return std::atoi(str.c_str()); } absl::optional< bool > setOptBool(string_view val) { if(IsTrueValue(val)) { return true; } else if(IsFalseValue(val)) { return false; } return {}; } void RouterConfig::fromSection(string_view key, string_view val) { if(key == "default-protocol") { m_DefaultLinkProto = tostr(val); LogInfo("overriding default link protocol to '", val, "'"); } if(key == "netid") { if(val.size() <= NetID::size()) { m_netId = tostr(val); LogInfo("setting netid to '", val, "'"); } else { llarp::LogError("invalid netid '", val, "', is too long"); } } if(key == "max-connections") { auto ival = svtoi(val); if(ival > 0) { m_maxConnectedRouters = ival; LogInfo("max connections set to ", m_maxConnectedRouters); } } if(key == "min-connections") { auto ival = svtoi(val); if(ival > 0) { m_minConnectedRouters = ival; LogInfo("min connections set to ", m_minConnectedRouters); } } if(key == "nickname") { m_nickname = tostr(val); // set logger name here LogContext::Instance().nodeName = nickname(); LogInfo("nickname set"); } if(key == "encryption-privkey") { m_encryptionKeyfile = tostr(val); LogDebug("encryption key set to ", m_encryptionKeyfile); } if(key == "contact-file") { m_ourRcFile = tostr(val); LogDebug("rc file set to ", m_ourRcFile); } if(key == "transport-privkey") { m_transportKeyfile = tostr(val); LogDebug("transport key set to ", m_transportKeyfile); } if((key == "identity-privkey" || key == "ident-privkey")) { m_identKeyfile = tostr(val); LogDebug("identity key set to ", m_identKeyfile); } if(key == "public-address" || key == "public-ip") { llarp::LogInfo("public ip ", val, " size ", val.size()); if(val.size() < 17) { // assume IPv4 llarp::Addr a(val); llarp::LogInfo("setting public ipv4 ", a); m_addrInfo.ip = *a.addr6(); m_publicOverride = true; } } if(key == "public-port") { llarp::LogInfo("Setting public port ", val); int p = svtoi(val); // Not needed to flip upside-down - this is done in llarp::Addr(const // AddressInfo&) m_ip4addr.sin_port = p; m_addrInfo.port = p; m_publicOverride = true; } if(key == "worker-threads" || key == "threads") { m_workerThreads = svtoi(val); if(m_workerThreads <= 0) { LogWarn("worker threads invalid value: '", val, "' defaulting to 1"); m_workerThreads = 1; } else { LogDebug("set to use ", m_workerThreads, " worker threads"); } } if(key == "net-threads") { m_numNetThreads = svtoi(val); if(m_numNetThreads <= 0) { LogWarn("net threads invalid value: '", val, "' defaulting to 1"); m_numNetThreads = 1; } else { LogDebug("set to use ", m_numNetThreads, " net threads"); } } if(key == "block-bogons") { m_blockBogons = setOptBool(val); } } void NetworkConfig::fromSection(string_view key, string_view val) { if(key == "profiling") { m_enableProfiling = setOptBool(val); } else if(key == "profiles") { m_routerProfilesFile = tostr(val); llarp::LogInfo("setting profiles to ", routerProfilesFile()); } else if(key == "strict-connect") { m_strictConnect = tostr(val); } else { m_netConfig.emplace(tostr(key), tostr(val)); } } void NetdbConfig::fromSection(string_view key, string_view val) { if(key == "dir") { m_nodedbDir = tostr(val); } } void DnsConfig::fromSection(string_view key, string_view val) { if(key == "upstream") { llarp::LogInfo("add upstream resolver ", val); netConfig.emplace("upstream-dns", tostr(val)); } if(key == "bind") { llarp::LogInfo("set local dns to ", val); netConfig.emplace("local-dns", tostr(val)); } } void LinksConfig::fromSection(string_view key, string_view val) { uint16_t proto = 0; std::unordered_set< std::string > parsed_opts; std::string v = tostr(val); std::string::size_type idx; static constexpr char delimiter = ','; do { idx = v.find_first_of(delimiter); if(idx != std::string::npos) { std::string data = v.substr(0, idx); absl::StripAsciiWhitespace(&data); parsed_opts.emplace(std::move(data)); v = v.substr(idx + 1); } else { absl::StripAsciiWhitespace(&v); parsed_opts.insert(std::move(v)); } } while(idx != std::string::npos); std::unordered_set< std::string > opts; /// for each option for(const auto &item : parsed_opts) { /// see if it's a number auto port = std::atoi(item.c_str()); if(port > 0) { /// set port if(proto == 0) { proto = port; } } else { opts.insert(item); } } if(key == "*") { m_OutboundLink = std::make_tuple( "*", AF_INET, fromEnv(proto, "OUTBOUND_PORT"), std::move(opts)); } else { m_InboundLinks.emplace_back(tostr(key), AF_INET, proto, std::move(opts)); } } void ConnectConfig::fromSection(ABSL_ATTRIBUTE_UNUSED string_view key, string_view val) { routers.emplace_back(val.begin(), val.end()); } void ServicesConfig::fromSection(string_view key, string_view val) { services.emplace_back(tostr(key), tostr(val)); } void SystemConfig::fromSection(string_view key, string_view val) { if(key == "pidfile") { pidfile = tostr(val); } } void MetricsConfig::fromSection(string_view key, string_view val) { if(key == "disable-metrics") { disableMetrics = true; } else if(key == "disable-metrics-log") { disableMetricLogs = true; } else if(key == "json-metrics-path") { jsonMetricsPath = tostr(val); } else if(key == "metric-tank-host") { metricTankHost = tostr(val); } else { // consume everything else as a metric tag metricTags[tostr(key)] = tostr(val); } } void ApiConfig::fromSection(string_view key, string_view val) { if(key == "enabled") { m_enableRPCServer = IsTrueValue(val); } if(key == "bind") { m_rpcBindAddr = tostr(val); } if(key == "authkey") { // TODO: add pubkey to whitelist } } void LokidConfig::fromSection(string_view key, string_view val) { if(key == "service-node-seed") { usingSNSeed = true; ident_keyfile = tostr(val); } if(key == "enabled") { whitelistRouters = IsTrueValue(val); } if(key == "jsonrpc" || key == "addr") { lokidRPCAddr = tostr(val); } if(key == "username") { lokidRPCUser = tostr(val); } if(key == "password") { lokidRPCPassword = tostr(val); } } void BootstrapConfig::fromSection(string_view key, string_view val) { if(key == "add-node") { routers.emplace_back(val.begin(), val.end()); } } void LoggingConfig::fromSection(string_view key, string_view val) { if(key == "type" && val == "syslog") { // TODO(despair): write event log syslog class #if defined(_WIN32) LogError("syslog not supported on win32"); #else LogInfo("Switching to syslog"); LogContext::Instance().logStream = std::make_unique< SysLogStream >(); #endif } if(key == "type" && val == "json") { m_LogJSON = true; } if(key == "file") { LogInfo("open log file: ", val); std::string fname = tostr(val); FILE *const logfile = ::fopen(fname.c_str(), "a"); if(logfile) { m_LogFile = logfile; LogInfo("will log to file ", val); } else if(errno) { LogError("could not open log file at '", val, "': ", strerror(errno)); errno = 0; } else { LogError("failed to open log file at '", val, "' for an unknown reason, bailing tf out kbai"); ::abort(); } } } template < typename Section, typename Config > Section find_section(Config &c, const std::string &name) { Section ret; auto visitor = [&ret](const ConfigParser::Section_t §ion) -> bool { for(const auto &sec : section) { ret.fromSection(sec.first, sec.second); } return true; }; if(c.VisitSection(name.c_str(), visitor)) { return ret; } return {}; } bool Config::Load(const char *fname) { ConfigParser parser; if(!parser.LoadFile(fname)) { return false; } return parse(parser); } bool Config::LoadFromStr(string_view str) { ConfigParser parser; if(!parser.LoadFromStr(str)) { return false; } return parse(parser); } bool Config::parse(const ConfigParser &parser) { router = find_section< RouterConfig >(parser, "router"); network = find_section< NetworkConfig >(parser, "network"); connect = find_section< ConnectConfig >(parser, "connect"); netdb = find_section< NetdbConfig >(parser, "netdb"); dns = find_section< DnsConfig >(parser, "dns"); links = find_section< LinksConfig >(parser, "bind"); services = find_section< ServicesConfig >(parser, "services"); system = find_section< SystemConfig >(parser, "system"); metrics = find_section< MetricsConfig >(parser, "metrics"); api = find_section< ApiConfig >(parser, "api"); lokid = find_section< LokidConfig >(parser, "lokid"); bootstrap = find_section< BootstrapConfig >(parser, "bootstrap"); logging = find_section< LoggingConfig >(parser, "logging"); return true; } fs::path GetDefaultConfigDir() { #ifdef _WIN32 const fs::path homedir = fs::path(getenv("APPDATA")); #else const fs::path homedir = fs::path(getenv("HOME")); #endif return homedir / fs::path(".lokinet"); } fs::path GetDefaultConfigPath() { return GetDefaultConfigDir() / "lokinet.ini"; } } // namespace llarp /// fname should be a relative path (from CWD) or absolute path to the config /// file extern "C" bool llarp_ensure_config(const char *fname, const char *basedir, bool overwrite, bool asRouter) { std::error_code ec; if(fs::exists(fname, ec) && !overwrite) { return true; } if(ec) { llarp::LogError(ec); return false; } std::string basepath; if(basedir) { basepath = basedir; #ifndef _WIN32 basepath += "/"; #else basepath += "\\"; #endif } llarp::LogInfo("Attempting to create config file ", fname); // abort if config already exists if(!asRouter) { if(fs::exists(fname, ec) && !overwrite) { llarp::LogError(fname, " currently exists, please use -f to overwrite"); return true; } if(ec) { llarp::LogError(ec); return false; } } // write fname ini auto optional_f = llarp::util::OpenFileStream< std::ofstream >(fname, std::ios::binary); if(!optional_f || !optional_f.value().is_open()) { llarp::LogError("failed to open ", fname, " for writing"); return false; } auto &f = optional_f.value(); llarp_generic_ensure_config(f, basepath, asRouter); if(asRouter) { llarp_ensure_router_config(f, basepath); } else { llarp_ensure_client_config(f, basepath); } llarp::LogInfo("Generated new config ", fname); return true; } void llarp_generic_ensure_config(std::ofstream &f, std::string basepath, bool isRouter) { f << "# this configuration was auto generated with 'sane' defaults\n"; f << "# change these values as desired\n"; f << "\n\n"; f << "[router]\n"; f << "# number of crypto worker threads \n"; f << "threads=4\n"; f << "# path to store signed RC\n"; f << "contact-file=" << basepath << "self.signed\n"; f << "# path to store transport private key\n"; f << "transport-privkey=" << basepath << "transport.private\n"; f << "# path to store identity signing key\n"; f << "ident-privkey=" << basepath << "identity.private\n"; f << "# encryption key for onion routing\n"; f << "encryption-privkey=" << basepath << "encryption.private\n"; f << std::endl; f << "# uncomment following line to set router nickname to 'lokinet'" << std::endl; f << "#nickname=lokinet\n"; const auto limits = isRouter ? llarp::limits::snode : llarp::limits::client; f << "# maintain min connections to other routers\n"; f << "min-routers=" << std::to_string(limits.DefaultMinRouters) << std::endl; f << "# hard limit of routers globally we are connected to at any given " "time\n"; f << "max-routers=" << std::to_string(limits.DefaultMaxRouters) << std::endl; f << "\n\n"; // logging f << "[logging]\n"; f << "level=info\n"; f << "# uncomment for logging to file\n"; f << "#type=file\n"; f << "#file=/path/to/logfile\n"; f << "# uncomment for syslog logging\n"; f << "#type=syslog\n"; // metrics f << "[metrics]\n"; f << "json-metrics-path=" << basepath << "metrics.json\n"; f << "\n\n"; f << "# admin api (disabled by default)\n"; f << "[api]\n"; f << "enabled=false\n"; f << "#authkey=insertpubkey1here\n"; f << "#authkey=insertpubkey2here\n"; f << "#authkey=insertpubkey3here\n"; f << "bind=127.0.0.1:1190\n"; f << "\n\n"; f << "# system settings for privileges and such\n"; f << "[system]\n"; f << "user=" << DEFAULT_LOKINET_USER << std::endl; f << "group=" << DEFAULT_LOKINET_GROUP << std::endl; f << "pidfile=" << basepath << "lokinet.pid\n"; f << "\n\n"; f << "# dns provider configuration section\n"; f << "[dns]\n"; f << "# resolver\n"; f << "upstream=" << DEFAULT_RESOLVER_US << std::endl; // Make auto-config smarter // will this break reproducibility rules? // (probably) #ifdef __linux__ #ifdef ANDROID f << "bind=127.0.0.1:1153\n"; #else f << "bind=127.3.2.1:53\n"; #endif #else f << "bind=127.0.0.1:53\n"; #endif f << "\n\n"; f << "# network database settings block \n"; f << "[netdb]\n"; f << "# directory for network database skiplist storage\n"; f << "dir=" << basepath << "netdb\n"; f << "\n\n"; f << "# bootstrap settings\n"; f << "[bootstrap]\n"; f << "# add a bootstrap node's signed identity to the list of nodes we want " "to bootstrap from\n"; f << "# if we don't have any peers we connect to this router\n"; f << "add-node=" << basepath << "bootstrap.signed\n"; // we only process one of these... // f << "# add another bootstrap node\n"; // f << "#add-node=/path/to/alternative/self.signed\n"; f << "\n\n"; } void llarp_ensure_router_config(std::ofstream &f, std::string basepath) { f << "# lokid settings (disabled by default)\n"; f << "[lokid]\n"; f << "enabled=false\n"; f << "jsonrpc=127.0.0.1:22023\n"; f << "#service-node-seed=/path/to/servicenode/seed\n"; f << std::endl; f << "# network settings \n"; f << "[network]\n"; f << "profiles=" << basepath << "profiles.dat\n"; // better to let the routers auto-configure // f << "ifaddr=auto\n"; // f << "ifname=auto\n"; f << "enabled=true\n"; f << "exit=false\n"; f << "#exit-blacklist=tcp:25\n"; f << "#exit-whitelist=tcp:*\n"; f << "#exit-whitelist=udp:*\n"; f << std::endl; f << "# ROUTERS ONLY: publish network interfaces for handling inbound " "traffic\n"; f << "[bind]\n"; // get ifname std::string ifname; if(llarp::GetBestNetIF(ifname, AF_INET)) { f << ifname << "=1090\n"; } else { f << "# could not autodetect network interface\n" << "#eth0=1090\n"; } f << std::endl; } bool llarp_ensure_client_config(std::ofstream &f, std::string basepath) { // write snapp-example.ini const std::string snappExample_fpath = basepath + "snapp-example.ini"; { auto stream = llarp::util::OpenFileStream< std::ofstream >( snappExample_fpath, std::ios::binary); if(!stream) { return false; } auto &example_f = stream.value(); if(example_f.is_open()) { // pick ip // don't revert me const static std::string ip = "10.33.0.1/16"; /* std::string ip = llarp::findFreePrivateRange(); if(ip == "") { llarp::LogError( "Couldn't easily detect a private range to map lokinet onto"); return false; } */ example_f << "# this is an example configuration for a snapp\n"; example_f << "[example-snapp]\n"; example_f << "# keyfile is the path to the private key of the snapp, " "your .loki is tied to this key, DON'T LOSE IT\n"; example_f << "keyfile=" << basepath << "example-snap-keyfile.private\n"; example_f << "# ifaddr is the ip range to allocate to this snapp\n"; example_f << "ifaddr=" << ip << std::endl; // probably fine to leave this (and not-auto-detect it) I'm not worried // about any collisions example_f << "# ifname is the name to try and give to the network " "interface this snap owns\n"; example_f << "ifname=snapp-tun0\n"; } else { llarp::LogError("failed to write ", snappExample_fpath); } } // now do up fname f << "\n\n"; f << "# snapps configuration section\n"; f << "[services]\n"; f << "# uncomment next line to enable a snapp\n"; f << "#example-snapp=" << snappExample_fpath << std::endl; f << "\n\n"; f << "# network settings \n"; f << "[network]\n"; f << "profiles=" << basepath << "profiles.dat\n"; f << "# uncomment next line to add router with pubkey to list of routers we " "connect directly to\n"; f << "#strict-connect=pubkey\n"; f << "# uncomment next line to use router with pubkey as an exit node\n"; f << "#exit-node=pubkey\n"; // better to set them to auto then to hard code them now // operating environment may change over time and this will help adapt // f << "ifname=auto\n"; // f << "ifaddr=auto\n"; // should this also be auto? or not declared? // probably auto in case they want to set up a hidden service f << "enabled=true\n"; return true; }