From 5a628007e1ca502dd8d45bfd921997f3a5664d1a Mon Sep 17 00:00:00 2001 From: dr7ana Date: Fri, 3 Nov 2023 06:40:14 -0700 Subject: [PATCH] A soothing re-nomenclatura --- daemon/lokinet.cpp | 8 +- llarp/config/config.cpp | 522 ++++++++++++++++--------------- llarp/config/config.hpp | 199 ++++++------ llarp/config/definition.cpp | 197 ++++++------ llarp/config/definition.hpp | 232 +++++++------- llarp/config/ini.cpp | 105 ++++--- llarp/config/ini.hpp | 42 +-- llarp/config/key_manager.cpp | 12 +- llarp/context.cpp | 2 +- llarp/dns/server.cpp | 14 +- llarp/handlers/exit.cpp | 6 +- llarp/handlers/tun.cpp | 50 +-- llarp/path/pathbuilder.cpp | 2 +- llarp/router/route_poker.cpp | 4 +- llarp/router/router.cpp | 55 ++-- llarp/rpc/endpoint_rpc.cpp | 10 +- llarp/rpc/endpoint_rpc.hpp | 4 +- llarp/rpc/rpc_server.cpp | 8 +- llarp/service/auth.cpp | 84 ++--- llarp/service/auth.hpp | 46 +-- llarp/service/context.cpp | 2 +- llarp/service/endpoint.cpp | 22 +- llarp/service/endpoint_state.cpp | 10 +- 23 files changed, 823 insertions(+), 813 deletions(-) diff --git a/daemon/lokinet.cpp b/daemon/lokinet.cpp index 67ac4a671..89b3d155a 100644 --- a/daemon/lokinet.cpp +++ b/daemon/lokinet.cpp @@ -450,7 +450,7 @@ namespace { try { - llarp::ensureConfig(basedir, *configFile, options.overwrite, opts.isSNode); + llarp::ensure_config(basedir, *configFile, options.overwrite, opts.isSNode); } catch (std::exception& ex) { @@ -479,7 +479,7 @@ namespace { try { - llarp::ensureConfig( + llarp::ensure_config( llarp::GetDefaultDataDir(), llarp::GetDefaultConfigPath(), options.overwrite, @@ -562,7 +562,7 @@ namespace { conf = std::make_shared(llarp::GetDefaultDataDir()); } - if (not conf->Load(confFile, opts.isSNode)) + if (not conf->load(confFile, opts.isSNode)) { llarp::LogError("failed to parse configuration"); exit_code.set_value(1); @@ -570,7 +570,7 @@ namespace } // change cwd to dataDir to support relative paths in config - fs::current_path(conf->router.m_dataDir); + fs::current_path(conf->router.data_dir); ctx = std::make_shared(); ctx->Configure(std::move(conf)); diff --git a/llarp/config/config.cpp b/llarp/config/config.cpp index c4d3035da..a586ee680 100644 --- a/llarp/config/config.cpp +++ b/llarp/config/config.cpp @@ -41,21 +41,21 @@ namespace llarp } // namespace void - RouterConfig::defineConfigOptions(ConfigDefinition& conf, const ConfigGenParameters& params) + RouterConfig::define_config_options(ConfigDefinition& conf, const ConfigGenParameters& params) { constexpr Default DefaultJobQueueSize{1024 * 8}; constexpr Default DefaultWorkerThreads{0}; constexpr Default DefaultBlockBogons{true}; - conf.defineOption( + conf.define_option( "router", "job-queue-size", DefaultJobQueueSize, Hidden, [this](int arg) { if (arg < 1024) throw std::invalid_argument("job-queue-size must be 1024 or greater"); - m_JobQueueSize = arg; + job_que_size = arg; }); - conf.defineOption( + conf.define_option( "router", "netid", Default{llarp::LOKINET_DEFAULT_NETID}, @@ -68,12 +68,12 @@ namespace llarp throw std::invalid_argument{ fmt::format("netid is too long, max length is {}", NETID_SIZE)}; - m_netId = std::move(arg); + net_id = std::move(arg); }); int minConnections = - (params.isRelay ? DefaultMinConnectionsForRouter : DefaultMinConnectionsForClient); - conf.defineOption( + (params.is_relay ? DefaultMinConnectionsForRouter : DefaultMinConnectionsForClient); + conf.define_option( "router", "min-connections", Default{minConnections}, @@ -85,12 +85,12 @@ namespace llarp throw std::invalid_argument{ fmt::format("min-connections must be >= {}", minConnections)}; - m_minConnectedRouters = arg; + min_connected_routers = arg; }); int maxConnections = - (params.isRelay ? DefaultMaxConnectionsForRouter : DefaultMaxConnectionsForClient); - conf.defineOption( + (params.is_relay ? DefaultMaxConnectionsForRouter : DefaultMaxConnectionsForClient); + conf.define_option( "router", "max-connections", Default{maxConnections}, @@ -102,15 +102,15 @@ namespace llarp throw std::invalid_argument{ fmt::format("max-connections must be >= {}", maxConnections)}; - m_maxConnectedRouters = arg; + max_connected_routers = arg; }); - conf.defineOption("router", "nickname", Deprecated); + conf.define_option("router", "nickname", Deprecated); - conf.defineOption( + conf.define_option( "router", "data-dir", - Default{params.defaultDataDir}, + Default{params.default_data_dir}, Comment{ "Optional directory for containing lokinet runtime data. This includes generated", "private keys.", @@ -122,10 +122,10 @@ namespace llarp throw std::runtime_error{ fmt::format("Specified [router]:data-dir {} does not exist", arg)}; - m_dataDir = std::move(arg); + data_dir = std::move(arg); }); - conf.defineOption( + conf.define_option( "router", "public-ip", RelayOnly, @@ -145,16 +145,16 @@ namespace llarp throw std::invalid_argument{ fmt::format("{} is not a publicly routable ip address", addr)}; - PublicIP = addr; + public_ip = addr; }); - conf.defineOption("router", "public-address", Hidden, [](std::string) { + conf.define_option("router", "public-address", Hidden, [](std::string) { throw std::invalid_argument{ "[router]:public-address option no longer supported, use [router]:public-ip and " "[router]:public-port instead"}; }); - conf.defineOption( + conf.define_option( "router", "public-port", RelayOnly, @@ -166,10 +166,10 @@ namespace llarp [this](int arg) { if (arg <= 0 || arg > std::numeric_limits::max()) throw std::invalid_argument("public-port must be >= 0 and <= 65536"); - PublicPort = ToNet(huint16_t{static_cast(arg)}); + public_port = ToNet(huint16_t{static_cast(arg)}); }); - conf.defineOption( + conf.define_option( "router", "worker-threads", DefaultWorkerThreads, @@ -183,56 +183,56 @@ namespace llarp if (arg < 0) throw std::invalid_argument("worker-threads must be >= 0"); - m_workerThreads = arg; + worker_threads = arg; }); // Hidden option because this isn't something that should ever be turned off occasionally when // doing dev/testing work. - conf.defineOption( - "router", "block-bogons", DefaultBlockBogons, Hidden, AssignmentAcceptor(m_blockBogons)); + conf.define_option( + "router", "block-bogons", DefaultBlockBogons, Hidden, assignment_acceptor(block_bogons)); constexpr auto relative_to_datadir = "An absolute path is used as-is, otherwise relative to 'data-dir'."; - conf.defineOption( + conf.define_option( "router", "contact-file", RelayOnly, Default{llarp::our_rc_filename}, - AssignmentAcceptor(m_routerContactFile), + assignment_acceptor(rc_file), Comment{ "Filename in which to store the router contact file", relative_to_datadir, }); - conf.defineOption( + conf.define_option( "router", "encryption-privkey", RelayOnly, Default{llarp::our_enc_key_filename}, - AssignmentAcceptor(m_encryptionKeyFile), + assignment_acceptor(enckey_file), Comment{ "Filename in which to store the encryption private key", relative_to_datadir, }); - conf.defineOption( + conf.define_option( "router", "ident-privkey", RelayOnly, Default{llarp::our_identity_filename}, - AssignmentAcceptor(m_identityKeyFile), + assignment_acceptor(idkey_file), Comment{ "Filename in which to store the identity private key", relative_to_datadir, }); - conf.defineOption( + conf.define_option( "router", "transport-privkey", RelayOnly, Default{llarp::our_transport_key_filename}, - AssignmentAcceptor(m_transportKeyFile), + assignment_acceptor(transkey_file), Comment{ "Filename in which to store the transport private key.", relative_to_datadir, @@ -241,18 +241,18 @@ namespace llarp // Deprecated options: // these weren't even ever used! - conf.defineOption("router", "max-routers", Deprecated); - conf.defineOption("router", "min-routers", Deprecated); + conf.define_option("router", "max-routers", Deprecated); + conf.define_option("router", "min-routers", Deprecated); // TODO: this may have been a synonym for [router]worker-threads - conf.defineOption("router", "threads", Deprecated); - conf.defineOption("router", "net-threads", Deprecated); + conf.define_option("router", "threads", Deprecated); + conf.define_option("router", "net-threads", Deprecated); - m_isRelay = params.isRelay; + is_relay = params.is_relay; } void - NetworkConfig::defineConfigOptions(ConfigDefinition& conf, const ConfigGenParameters& params) + NetworkConfig::define_config_options(ConfigDefinition& conf, const ConfigGenParameters& params) { (void)params; @@ -263,26 +263,26 @@ namespace llarp static constexpr Default PathsDefault{6}; static constexpr Default IP6RangeDefault{"fd00::"}; - conf.defineOption( - "network", "type", Default{"tun"}, Hidden, AssignmentAcceptor(m_endpointType)); + conf.define_option( + "network", "type", Default{"tun"}, Hidden, assignment_acceptor(endpoint_type)); - conf.defineOption( + conf.define_option( "network", "save-profiles", SaveProfilesDefault, Hidden, - AssignmentAcceptor(m_saveProfiles)); + assignment_acceptor(save_profiles)); - conf.defineOption( + conf.define_option( "network", "profiling", ProfilingValueDefault, Hidden, - AssignmentAcceptor(m_enableProfiling)); + assignment_acceptor(enable_profiling)); - conf.defineOption("network", "profiles", Deprecated); + conf.define_option("network", "profiles", Deprecated); - conf.defineOption( + conf.define_option( "network", "strict-connect", ClientOnly, @@ -291,7 +291,7 @@ namespace llarp RouterID router; if (not router.FromString(value)) throw std::invalid_argument{"bad snode value: " + value}; - if (not m_strictConnect.insert(router).second) + if (not strict_connect.insert(router).second) throw std::invalid_argument{"duplicate strict connect snode: " + value}; }, Comment{ @@ -300,17 +300,17 @@ namespace llarp "first hop). This REQUIRES two or more nodes to be specified.", }); - conf.defineOption( + conf.define_option( "network", "keyfile", ClientOnly, - AssignmentAcceptor(m_keyfile), + assignment_acceptor(keyfile), Comment{ "The private key to persist address with. If not specified the address will be", "ephemeral.", }); - conf.defineOption( + conf.define_option( "network", "auth", ClientOnly, @@ -321,21 +321,21 @@ namespace llarp [this](std::string arg) { if (arg.empty()) return; - m_AuthType = service::ParseAuthType(arg); + auth_type = service::parse_auth_type(arg); }); - conf.defineOption( + conf.define_option( "network", "auth-lmq", ClientOnly, - AssignmentAcceptor(m_AuthUrl), + assignment_acceptor(auth_url), Comment{ "lmq endpoint to talk to for authenticating new sessions", "ipc:///var/lib/lokinet/auth.socket", "tcp://127.0.0.1:5555", }); - conf.defineOption( + conf.define_option( "network", "auth-lmq-method", ClientOnly, @@ -347,10 +347,10 @@ namespace llarp [this](std::string arg) { if (arg.empty()) return; - m_AuthMethod = std::move(arg); + auth_method = std::move(arg); }); - conf.defineOption( + conf.define_option( "network", "auth-whitelist", ClientOnly, @@ -362,10 +362,10 @@ namespace llarp service::Address addr; if (not addr.FromString(arg)) throw std::invalid_argument{fmt::format("bad loki address: {}", arg)}; - m_AuthWhitelist.emplace(std::move(addr)); + auth_whitelist.emplace(std::move(addr)); }); - conf.defineOption( + conf.define_option( "network", "auth-file", ClientOnly, @@ -378,9 +378,9 @@ namespace llarp if (not fs::exists(arg)) throw std::invalid_argument{ fmt::format("cannot load auth file {}: file does not exist", arg)}; - m_AuthFiles.emplace(std::move(arg)); + auth_files.emplace(std::move(arg)); }); - conf.defineOption( + conf.define_option( "network", "auth-file-type", ClientOnly, @@ -388,9 +388,11 @@ namespace llarp "How to interpret the contents of an auth file.", "Possible values: hashes, plaintext", }, - [this](std::string arg) { m_AuthFileType = service::ParseAuthFileType(std::move(arg)); }); + [this](std::string arg) { + auth_file_type = service::parse_auth_file_type(std::move(arg)); + }); - conf.defineOption( + conf.define_option( "network", "auth-static", ClientOnly, @@ -399,19 +401,19 @@ namespace llarp "Manually add a static auth code to accept for endpoint auth", "Can be provided multiple times", }, - [this](std::string arg) { m_AuthStaticTokens.emplace(std::move(arg)); }); + [this](std::string arg) { auth_static_tokens.emplace(std::move(arg)); }); - conf.defineOption( + conf.define_option( "network", "reachable", ClientOnly, ReachableDefault, - AssignmentAcceptor(m_reachable), + assignment_acceptor(is_reachable), Comment{ "Determines whether we will pubish our snapp's introset to the DHT.", }); - conf.defineOption( + conf.define_option( "network", "hops", HopsDefault, @@ -421,10 +423,10 @@ namespace llarp [this](int arg) { if (arg < 1 or arg > 8) throw std::invalid_argument("[endpoint]:hops must be >= 1 and <= 8"); - m_Hops = arg; + hops = arg; }); - conf.defineOption( + conf.define_option( "network", "paths", ClientOnly, @@ -435,21 +437,21 @@ namespace llarp [this](int arg) { if (arg < 3 or arg > 8) throw std::invalid_argument("[endpoint]:paths must be >= 3 and <= 8"); - m_Paths = arg; + paths = arg; }); - conf.defineOption( + conf.define_option( "network", "exit", ClientOnly, Default{false}, - AssignmentAcceptor(m_AllowExit), + assignment_acceptor(allow_exit), Comment{ "Whether or not we should act as an exit node. Beware that this increases demand", "on the server and may pose liability concerns. Enable at your own risk.", }); - conf.defineOption( + conf.define_option( "network", "owned-range", MultiValue, @@ -461,10 +463,10 @@ namespace llarp IPRange range; if (not range.FromString(arg)) throw std::invalid_argument{"bad ip range: '" + arg + "'"}; - m_OwnedRanges.insert(range); + owned_ranges.insert(range); }); - conf.defineOption( + conf.define_option( "network", "traffic-whitelist", MultiValue, @@ -482,14 +484,14 @@ namespace llarp "would allow TCP traffic on the standard smtp port (21).", }, [this](std::string arg) { - if (not m_TrafficPolicy) - m_TrafficPolicy = net::TrafficPolicy{}; + if (not traffic_policy) + traffic_policy = net::TrafficPolicy{}; // this will throw on error - m_TrafficPolicy->protocols.emplace(arg); + traffic_policy->protocols.emplace(arg); }); - conf.defineOption( + conf.define_option( "network", "exit-node", ClientOnly, @@ -524,7 +526,7 @@ namespace llarp if (service::is_valid_name(arg)) { - m_LNSExitMap.Insert(range, arg); + ons_exit_map.Insert(range, arg); return; } @@ -532,10 +534,10 @@ namespace llarp { throw std::invalid_argument{fmt::format("[network]:exit-node bad address: {}", arg)}; } - m_ExitMap.Insert(range, exit); + exit_map.Insert(range, exit); }); - conf.defineOption( + conf.define_option( "network", "exit-auth", ClientOnly, @@ -564,7 +566,7 @@ namespace llarp if (service::is_valid_name(exit_str)) { - m_LNSExitAuths.emplace(exit_str, auth); + ons_exit_auths.emplace(exit_str, auth); return; } @@ -572,10 +574,10 @@ namespace llarp { throw std::invalid_argument("[network]:exit-auth invalid exit address"); } - m_ExitAuths.emplace(exit, auth); + exit_auths.emplace(exit, auth); }); - conf.defineOption( + conf.define_option( "network", "auto-routing", ClientOnly, @@ -586,9 +588,9 @@ namespace llarp "operating system routes to route public internet traffic through the exit node.", "This is enabled by default, but can be disabled if advanced/manual exit routing", "configuration is desired."}, - AssignmentAcceptor(m_EnableRoutePoker)); + assignment_acceptor(enable_route_poker)); - conf.defineOption( + conf.define_option( "network", "blackhole-routes", ClientOnly, @@ -597,18 +599,18 @@ namespace llarp "Enable / disable route configuration blackholes.", "When enabled lokinet will drop IPv4 and IPv6 traffic (when in exit mode) that is not", "handled in the exit configuration. Enabled by default."}, - AssignmentAcceptor(m_BlackholeRoutes)); + assignment_acceptor(blackhole_routes)); - conf.defineOption( + conf.define_option( "network", "ifname", Comment{ "Interface name for lokinet traffic. If unset lokinet will look for a free name", "matching 'lokitunN', starting at N=0 (e.g. lokitun0, lokitun1, ...).", }, - AssignmentAcceptor(m_ifname)); + assignment_acceptor(if_name)); - conf.defineOption( + conf.define_option( "network", "ifaddr", Comment{ @@ -617,13 +619,13 @@ namespace llarp "lokinet will attempt to find an unused private range.", }, [this](std::string arg) { - if (not m_ifaddr.FromString(arg)) + if (not if_addr.FromString(arg)) { throw std::invalid_argument{fmt::format("[network]:ifaddr invalid value: '{}'", arg)}; } }); - conf.defineOption( + conf.define_option( "network", "ip6-range", ClientOnly, @@ -641,17 +643,17 @@ namespace llarp LogError( "!!! Disabling ipv6 tunneling when you have ipv6 routes WILL lead to " "de-anonymization as lokinet will no longer carry your ipv6 traffic !!!"); - m_baseV6Address = std::nullopt; + base_ipv6_addr = std::nullopt; return; } - m_baseV6Address = huint128_t{}; - if (not m_baseV6Address->FromString(arg)) + base_ipv6_addr = huint128_t{}; + if (not base_ipv6_addr->FromString(arg)) throw std::invalid_argument{ fmt::format("[network]:ip6-range invalid value: '{}'", arg)}; }); // TODO: could be useful for snodes in the future, but currently only implemented for clients: - conf.defineOption( + conf.define_option( "network", "mapaddr", ClientOnly, @@ -688,15 +690,15 @@ namespace llarp throw std::invalid_argument{ fmt::format("[endpoint]:mapaddr invalid addresss: {}", addrstr)}; } - if (m_mapAddrs.find(ip) != m_mapAddrs.end()) + if (map_addrs.find(ip) != map_addrs.end()) { throw std::invalid_argument{ fmt::format("[endpoint]:mapaddr ip already mapped: {}", ipstr)}; } - m_mapAddrs[ip] = addr; + map_addrs[ip] = addr; }); - conf.defineOption( + conf.define_option( "network", "blacklist-snode", ClientOnly, @@ -710,13 +712,13 @@ namespace llarp if (not id.FromString(arg)) throw std::invalid_argument{fmt::format("Invalid RouterID: {}", arg)}; - auto itr = m_snodeBlacklist.emplace(std::move(id)); + auto itr = snode_blacklist.emplace(std::move(id)); if (not itr.second) throw std::invalid_argument{fmt::format("Duplicate blacklist-snode: {}", arg)}; }); // TODO: support SRV records for routers, but for now client only - conf.defineOption( + conf.define_option( "network", "srv", ClientOnly, @@ -735,10 +737,10 @@ namespace llarp if (not newSRV.fromString(arg)) throw std::invalid_argument{fmt::format("Invalid SRV Record string: {}", arg)}; - m_SRVRecords.push_back(std::move(newSRV)); + srv_records.push_back(std::move(newSRV)); }); - conf.defineOption( + conf.define_option( "network", "path-alignment-timeout", ClientOnly, @@ -750,14 +752,14 @@ namespace llarp if (val <= 0) throw std::invalid_argument{ "invalid path alignment timeout: " + std::to_string(val) + " <= 0"}; - m_PathAlignmentTimeout = std::chrono::seconds{val}; + path_alignment_timeout = std::chrono::seconds{val}; }); - conf.defineOption( + conf.define_option( "network", "persist-addrmap-file", ClientOnly, - Default{fs::path{params.defaultDataDir / "addrmap.dat"}}, + Default{fs::path{params.default_data_dir / "addrmap.dat"}}, Comment{ "If given this specifies a file in which to record mapped local tunnel addresses so", "the same local address will be used for the same lokinet address on reboot. If this", @@ -767,15 +769,15 @@ namespace llarp [this](fs::path arg) { if (arg.empty()) throw std::invalid_argument("persist-addrmap-file cannot be empty"); - m_AddrMapPersistFile = arg; + addr_map_persist_file = arg; }); // Deprecated options: - conf.defineOption("network", "enabled", Deprecated); + conf.define_option("network", "enabled", Deprecated); } void - DnsConfig::defineConfigOptions(ConfigDefinition& conf, const ConfigGenParameters& params) + DnsConfig::define_config_options(ConfigDefinition& conf, const ConfigGenParameters& params) { (void)params; @@ -797,9 +799,9 @@ namespace llarp // Default, but if we get any upstream (including upstream=, i.e. empty string) we clear it constexpr Default DefaultUpstreamDNS{"9.9.9.10:53"}; - m_upstreamDNS.emplace_back(DefaultUpstreamDNS.val); + upstream_dns.emplace_back(DefaultUpstreamDNS.val); - conf.defineOption( + conf.define_option( "dns", "upstream", MultiValue, @@ -810,18 +812,18 @@ namespace llarp [=, first = true](std::string arg) mutable { if (first) { - m_upstreamDNS.clear(); + upstream_dns.clear(); first = false; } if (not arg.empty()) { - auto& entry = m_upstreamDNS.emplace_back(std::move(arg)); + auto& entry = upstream_dns.emplace_back(std::move(arg)); if (not entry.getPort()) entry.setPort(53); } }); - conf.defineOption( + conf.define_option( "dns", "l3-intercept", Default{ @@ -829,9 +831,9 @@ namespace llarp or (platform::is_macos and not platform::is_apple_sysex)}, Comment{"Intercept all dns traffic (udp/53) going into our lokinet network interface " "instead of binding a local udp socket"}, - AssignmentAcceptor(m_raw_dns)); + assignment_acceptor(raw)); - conf.defineOption( + conf.define_option( "dns", "query-bind", #if defined(_WIN32) @@ -842,9 +844,9 @@ namespace llarp Comment{ "Address to bind to for sending upstream DNS requests.", }, - [this](std::string arg) { m_QueryBind = SockAddr{arg}; }); + [this](std::string arg) { query_bind = SockAddr{arg}; }); - conf.defineOption( + conf.define_option( "dns", "bind", DefaultDNSBind, @@ -858,10 +860,10 @@ namespace llarp // explicit :0 allowed if (not addr.getPort() and not ends_with(arg, ":0")) addr.setPort(53); - m_bind.emplace_back(addr); + bind_addr.emplace_back(addr); }); - conf.defineOption( + conf.define_option( "dns", "add-hosts", ClientOnly, @@ -872,11 +874,11 @@ namespace llarp if (not fs::exists(path)) throw std::invalid_argument{ fmt::format("cannot add hosts file {} as it does not exist", path)}; - m_hostfiles.emplace_back(std::move(path)); + hostfiles.emplace_back(std::move(path)); }); // Ignored option (used by the systemd service file to disable resolvconf configuration). - conf.defineOption( + conf.define_option( "dns", "no-resolvconf", ClientOnly, @@ -887,15 +889,15 @@ namespace llarp }); // forward the rest to libunbound - conf.addUndeclaredHandler("dns", [this](auto, std::string_view key, std::string_view val) { - m_ExtraOpts.emplace(key, val); + conf.add_undeclared_handler("dns", [this](auto, std::string_view key, std::string_view val) { + extra_opts.emplace(key, val); }); } void - LinksConfig::defineConfigOptions(ConfigDefinition& conf, const ConfigGenParameters& params) + LinksConfig::define_config_options(ConfigDefinition& conf, const ConfigGenParameters& params) { - conf.addSectionComments( + conf.add_section_comments( "bind", { "This section allows specifying the IPs that lokinet uses for incoming and outgoing", @@ -910,7 +912,7 @@ namespace llarp static constexpr Default DefaultInboundPort{uint16_t{1090}}; static constexpr Default DefaultOutboundPort{uint16_t{0}}; - conf.defineOption( + conf.define_option( "bind", "public-ip", RelayOnly, @@ -921,9 +923,9 @@ namespace llarp }, [this](std::string_view arg) { SockAddr pubaddr{arg}; - PublicAddress = pubaddr.getIP(); + public_addr = pubaddr.getIP(); }); - conf.defineOption( + conf.define_option( "bind", "public-port", RelayOnly, @@ -932,7 +934,7 @@ namespace llarp "This is typically required only when incoming= is used to listen on an internal", "private range IP address/port that received traffic forwarded from the public IP.", }, - [this](uint16_t arg) { PublicPort = net::port_t::from_host(arg); }); + [this](uint16_t arg) { public_port = net::port_t::from_host(arg); }); auto parse_addr_for_link = [net_ptr]( const std::string& arg, net::port_t default_port, bool inbound) { @@ -970,7 +972,7 @@ namespace llarp return addr; }; - conf.defineOption( + conf.define_option( "bind", "inbound", RelayOnly, @@ -994,14 +996,14 @@ namespace llarp [this, parse_addr_for_link](const std::string& arg) { auto default_port = net::port_t::from_host(DefaultInboundPort.val); if (auto addr = parse_addr_for_link(arg, default_port, /*inbound=*/true)) - InboundListenAddrs.emplace_back(std::move(*addr)); + inbound_listen_addrs.emplace_back(std::move(*addr)); }); - conf.defineOption( + conf.define_option( "bind", "outbound", MultiValue, - params.isRelay ? Comment{ + params.is_relay ? Comment{ "IP and/or port to use for outbound socket connections to other lokinet routers.", "", "If no outbound bind IP is configured, or the 0.0.0.0 wildcard IP is given, then", @@ -1038,10 +1040,10 @@ namespace llarp auto addr = parse_addr_for_link(arg, default_port, /*inbound=*/false); if (not addr) addr = net_ptr->WildcardWithPort(default_port); - OutboundLinks.emplace_back(std::move(*addr)); + outbound_links.emplace_back(std::move(*addr)); }); - conf.addUndeclaredHandler( + conf.add_undeclared_handler( "bind", [this, net_ptr](std::string_view, std::string_view key, std::string_view val) { LogWarn( "using the [bind] section with *=/IP=/INTERFACE= is deprecated; use the inbound= " @@ -1059,7 +1061,7 @@ namespace llarp } else throw std::invalid_argument{fmt::format("invalid port value: '{}'", val)}; - OutboundLinks.emplace_back(std::move(*addr)); + outbound_links.emplace_back(std::move(*addr)); return; } // try as interface name first @@ -1082,16 +1084,16 @@ namespace llarp else throw std::invalid_argument{fmt::format("invalid port value: '{}'", val)}; - InboundListenAddrs.emplace_back(std::move(*addr)); + inbound_listen_addrs.emplace_back(std::move(*addr)); }); } void - ConnectConfig::defineConfigOptions(ConfigDefinition& conf, const ConfigGenParameters& params) + ConnectConfig::define_config_options(ConfigDefinition& conf, const ConfigGenParameters& params) { (void)params; - conf.addUndeclaredHandler( + conf.add_undeclared_handler( "connect", [this](std::string_view section, std::string_view name, std::string_view value) { fs::path file{value.begin(), value.end()}; if (not fs::exists(file)) @@ -1107,7 +1109,7 @@ namespace llarp } void - ApiConfig::defineConfigOptions(ConfigDefinition& conf, const ConfigGenParameters& params) + ApiConfig::define_config_options(ConfigDefinition& conf, const ConfigGenParameters& params) { constexpr std::array DefaultRPCBind{ Default{"tcp://127.0.0.1:1190"}, @@ -1116,16 +1118,16 @@ namespace llarp #endif }; - conf.defineOption( + conf.define_option( "api", "enabled", - Default{not params.isRelay}, - AssignmentAcceptor(m_enableRPCServer), + Default{not params.is_relay}, + assignment_acceptor(enable_rpc_server), Comment{ "Determines whether or not the LMQ JSON API is enabled. Defaults ", }); - conf.defineOption( + conf.define_option( "api", "bind", DefaultRPCBind, @@ -1133,34 +1135,34 @@ namespace llarp [this, first = true](std::string arg) mutable { if (first) { - m_rpcBindAddresses.clear(); + rpc_bind_addrs.clear(); first = false; } if (arg.find("://") == std::string::npos) { arg = "tcp://" + arg; } - m_rpcBindAddresses.emplace_back(arg); + rpc_bind_addrs.emplace_back(arg); }, Comment{ "IP addresses and ports to bind to.", "Recommend localhost-only for security purposes.", }); - conf.defineOption("api", "authkey", Deprecated); + conf.define_option("api", "authkey", Deprecated); // TODO: this was from pre-refactor: // TODO: add pubkey to whitelist } void - LokidConfig::defineConfigOptions(ConfigDefinition& conf, const ConfigGenParameters& params) + LokidConfig::define_config_options(ConfigDefinition& conf, const ConfigGenParameters& params) { (void)params; - conf.defineOption("lokid", "enabled", RelayOnly, Deprecated); + conf.define_option("lokid", "enabled", RelayOnly, Deprecated); - conf.defineOption("lokid", "jsonrpc", RelayOnly, [](std::string arg) { + conf.define_option("lokid", "jsonrpc", RelayOnly, [](std::string arg) { if (arg.empty()) return; throw std::invalid_argument( @@ -1169,7 +1171,7 @@ namespace llarp "rpc=ipc:///var/lib/oxen/oxend.sock or rpc=ipc:///home/snode/.oxen/oxend.sock"); }); - conf.defineOption( + conf.define_option( "lokid", "rpc", RelayOnly, @@ -1183,28 +1185,28 @@ namespace llarp "but can use (non-default) TCP if oxend is configured that way:", " rpc=tcp://127.0.0.1:5678", }, - [this](std::string arg) { lokidRPCAddr = oxenmq::address(arg); }); + [this](std::string arg) { rpc_addr = oxenmq::address(arg); }); // Deprecated options: - conf.defineOption("lokid", "username", Deprecated); - conf.defineOption("lokid", "password", Deprecated); - conf.defineOption("lokid", "service-node-seed", Deprecated); + conf.define_option("lokid", "username", Deprecated); + conf.define_option("lokid", "password", Deprecated); + conf.define_option("lokid", "service-node-seed", Deprecated); } void - BootstrapConfig::defineConfigOptions(ConfigDefinition& conf, const ConfigGenParameters& params) + BootstrapConfig::define_config_options(ConfigDefinition& conf, const ConfigGenParameters& params) { (void)params; - conf.defineOption( + conf.define_option( "bootstrap", "seed-node", Default{false}, Comment{"Whether or not to run as a seed node. We will not have any bootstrap routers " "configured."}, - AssignmentAcceptor(seednode)); + assignment_acceptor(seednode)); - conf.defineOption( + conf.define_option( "bootstrap", "add-node", MultiValue, @@ -1226,7 +1228,7 @@ namespace llarp } void - LoggingConfig::defineConfigOptions(ConfigDefinition& conf, const ConfigGenParameters& params) + LoggingConfig::define_config_options(ConfigDefinition& conf, const ConfigGenParameters& params) { (void)params; @@ -1234,13 +1236,13 @@ namespace llarp platform::is_android or platform::is_apple ? "system" : "print"}; constexpr Default DefaultLogFile{""}; - const Default DefaultLogLevel{params.isRelay ? "warn" : "info"}; + const Default DefaultLogLevel{params.is_relay ? "warn" : "info"}; - conf.defineOption( + conf.define_option( "logging", "type", DefaultLogType, - [this](std::string arg) { m_logType = log::type_from_string(arg); }, + [this](std::string arg) { type = log::type_from_string(arg); }, Comment{ "Log type (format). Valid options are:", " print - print logs to standard output", @@ -1248,11 +1250,11 @@ namespace llarp " file - plaintext formatting to a file", }); - conf.defineOption( + conf.define_option( "logging", "level", DefaultLogLevel, - [this](std::string arg) { m_logLevel = log::level_from_string(arg); }, + [this](std::string arg) { level = log::level_from_string(arg); }, Comment{ "Minimum log level to print. Logging below this level will be ignored.", "Valid log levels, in ascending order, are:", @@ -1265,24 +1267,24 @@ namespace llarp " none", }); - conf.defineOption( + conf.define_option( "logging", "file", DefaultLogFile, - AssignmentAcceptor(m_logFile), + assignment_acceptor(file), Comment{ "When using type=file this is the output filename.", }); } void - PeerSelectionConfig::defineConfigOptions( + PeerSelectionConfig::define_config_options( ConfigDefinition& conf, const ConfigGenParameters& params) { (void)params; constexpr Default DefaultUniqueCIDR{32}; - conf.defineOption( + conf.define_option( "paths", "unique-range-size", DefaultUniqueCIDR, @@ -1290,13 +1292,13 @@ namespace llarp [=](int arg) { if (arg == 0) { - m_UniqueHopsNetmaskSize = arg; + unique_hop_netmask = arg; } else if (arg > 32 or arg < 4) { throw std::invalid_argument{"[paths]:unique-range-size must be between 4 and 32"}; } - m_UniqueHopsNetmaskSize = arg; + unique_hop_netmask = arg; }, Comment{ "Netmask for router path selection; each router must be from a distinct IPv4 subnet", @@ -1322,11 +1324,11 @@ namespace llarp } bool - PeerSelectionConfig::Acceptable(const std::set& rcs) const + PeerSelectionConfig::check_rcs(const std::set& rcs) const { - if (m_UniqueHopsNetmaskSize == 0) + if (unique_hop_netmask == 0) return true; - const auto netmask = netmask_ipv6_bits(96 + m_UniqueHopsNetmaskSize); + const auto netmask = netmask_ipv6_bits(96 + unique_hop_netmask); std::set seenRanges; for (const auto& hop : rcs) { @@ -1340,50 +1342,50 @@ namespace llarp } std::unique_ptr - Config::MakeGenParams() const + Config::make_gen_params() const { return std::make_unique(); } Config::Config(std::optional datadir) - : m_DataDir{datadir ? std::move(*datadir) : fs::current_path()} + : data_dir{datadir ? std::move(*datadir) : fs::current_path()} {} constexpr auto GetOverridesDir = [](auto datadir) -> fs::path { return datadir / "conf.d"; }; void - Config::Save() + Config::save() { - const auto overridesDir = GetOverridesDir(m_DataDir); + const auto overridesDir = GetOverridesDir(data_dir); if (not fs::exists(overridesDir)) fs::create_directory(overridesDir); - m_Parser.Save(); + parser.save(); } void - Config::Override(std::string section, std::string key, std::string value) + Config::override(std::string section, std::string key, std::string value) { - m_Parser.AddOverride(GetOverridesDir(m_DataDir) / "overrides.ini", section, key, value); + parser.add_override(GetOverridesDir(data_dir) / "overrides.ini", section, key, value); } void - Config::LoadOverrides(ConfigDefinition& conf) const + Config::load_overrides(ConfigDefinition& conf) const { ConfigParser parser; - const auto overridesDir = GetOverridesDir(m_DataDir); + const auto overridesDir = GetOverridesDir(data_dir); if (fs::exists(overridesDir)) { util::IterDir(overridesDir, [&](const fs::path& overrideFile) { if (overrideFile.extension() == ".ini") { ConfigParser parser; - if (not parser.LoadFile(overrideFile)) + if (not parser.load_file(overrideFile)) throw std::runtime_error{"cannot load '" + overrideFile.u8string() + "'"}; - parser.IterAll([&](std::string_view section, const SectionValues_t& values) { + parser.iter_all_sections([&](std::string_view section, const SectionValues& values) { for (const auto& pair : values) { - conf.addConfigValue(section, pair.first, pair.second); + conf.add_config_value(section, pair.first, pair.second); } }); } @@ -1393,44 +1395,44 @@ namespace llarp } void - Config::AddDefault(std::string section, std::string key, std::string val) + Config::add_default(std::string section, std::string key, std::string val) { - m_Additional.emplace_back(std::array{section, key, val}); + additional.emplace_back(std::array{section, key, val}); } bool - Config::LoadConfigData(std::string_view ini, std::optional filename, bool isRelay) + Config::load_config_data(std::string_view ini, std::optional filename, bool isRelay) { - auto params = MakeGenParams(); - params->isRelay = isRelay; - params->defaultDataDir = m_DataDir; + auto params = make_gen_params(); + params->is_relay = isRelay; + params->default_data_dir = data_dir; ConfigDefinition conf{isRelay}; - addBackwardsCompatibleConfigOptions(conf); - initializeConfig(conf, *params); + add_backcompat_opts(conf); + init_config(conf, *params); - for (const auto& item : m_Additional) + for (const auto& item : additional) { - conf.addConfigValue(item[0], item[1], item[2]); + conf.add_config_value(item[0], item[1], item[2]); } - m_Parser.Clear(); + parser.clear(); if (filename) - m_Parser.Filename(*filename); + parser.set_filename(*filename); else - m_Parser.Filename(fs::path{}); + parser.set_filename(fs::path{}); - if (not m_Parser.LoadFromStr(ini)) + if (not parser.load_from_str(ini)) return false; - m_Parser.IterAll([&](std::string_view section, const SectionValues_t& values) { + parser.iter_all_sections([&](std::string_view section, const SectionValues& values) { for (const auto& pair : values) { - conf.addConfigValue(section, pair.first, pair.second); + conf.add_config_value(section, pair.first, pair.second); } }); - LoadOverrides(conf); + load_overrides(conf); conf.process(); @@ -1438,7 +1440,7 @@ namespace llarp } bool - Config::Load(std::optional fname, bool isRelay) + Config::load(std::optional fname, bool isRelay) { std::string ini; if (fname) @@ -1452,52 +1454,52 @@ namespace llarp return false; } } - return LoadConfigData(ini, fname, isRelay); + return load_config_data(ini, fname, isRelay); } bool - Config::LoadString(std::string_view ini, bool isRelay) + Config::load_string(std::string_view ini, bool isRelay) { - return LoadConfigData(ini, std::nullopt, isRelay); + return load_config_data(ini, std::nullopt, isRelay); } bool - Config::LoadDefault(bool isRelay) + Config::load_default_config(bool isRelay) { - return LoadString("", isRelay); + return load_string("", isRelay); } void - Config::initializeConfig(ConfigDefinition& conf, const ConfigGenParameters& params) + Config::init_config(ConfigDefinition& conf, const ConfigGenParameters& params) { - router.defineConfigOptions(conf, params); - network.defineConfigOptions(conf, params); - paths.defineConfigOptions(conf, params); - connect.defineConfigOptions(conf, params); - dns.defineConfigOptions(conf, params); - links.defineConfigOptions(conf, params); - api.defineConfigOptions(conf, params); - lokid.defineConfigOptions(conf, params); - bootstrap.defineConfigOptions(conf, params); - logging.defineConfigOptions(conf, params); + router.define_config_options(conf, params); + network.define_config_options(conf, params); + paths.define_config_options(conf, params); + connect.define_config_options(conf, params); + dns.define_config_options(conf, params); + links.define_config_options(conf, params); + api.define_config_options(conf, params); + lokid.define_config_options(conf, params); + bootstrap.define_config_options(conf, params); + logging.define_config_options(conf, params); } void - Config::addBackwardsCompatibleConfigOptions(ConfigDefinition& conf) + Config::add_backcompat_opts(ConfigDefinition& conf) { // These config sections don't exist anymore: - conf.defineOption("system", "user", Deprecated); - conf.defineOption("system", "group", Deprecated); - conf.defineOption("system", "pidfile", Deprecated); + conf.define_option("system", "user", Deprecated); + conf.define_option("system", "group", Deprecated); + conf.define_option("system", "pidfile", Deprecated); - conf.defineOption("netdb", "dir", Deprecated); + conf.define_option("netdb", "dir", Deprecated); - conf.defineOption("metrics", "json-metrics-path", Deprecated); + conf.define_option("metrics", "json-metrics-path", Deprecated); } void - ensureConfig(fs::path dataDir, fs::path confFile, bool overwrite, bool asRouter) + ensure_config(fs::path dataDir, fs::path confFile, bool overwrite, bool asRouter) { // fail to overwrite if not instructed to do so if (fs::exists(confFile) && !overwrite) @@ -1523,9 +1525,9 @@ namespace llarp llarp::Config config{dataDir}; std::string confStr; if (asRouter) - confStr = config.generateBaseRouterConfig(); + confStr = config.generate_router_config_base(); else - confStr = config.generateBaseClientConfig(); + confStr = config.generate_client_config_base(); // open a filestream try @@ -1542,45 +1544,45 @@ namespace llarp } void - generateCommonConfigComments(ConfigDefinition& def) + generate_common_config_comments(ConfigDefinition& def) { // router - def.addSectionComments( + def.add_section_comments( "router", { "Configuration for routing activity.", }); // logging - def.addSectionComments( + def.add_section_comments( "logging", { "logging settings", }); // api - def.addSectionComments( + def.add_section_comments( "api", { "JSON API settings", }); // dns - def.addSectionComments( + def.add_section_comments( "dns", { "DNS configuration", }); // bootstrap - def.addSectionComments( + def.add_section_comments( "bootstrap", { "Configure nodes that will bootstrap us onto the network", }); // network - def.addSectionComments( + def.add_section_comments( "network", { "Network settings", @@ -1588,60 +1590,60 @@ namespace llarp } std::string - Config::generateBaseClientConfig() + Config::generate_client_config_base() { - auto params = MakeGenParams(); - params->isRelay = false; - params->defaultDataDir = m_DataDir; + auto params = make_gen_params(); + params->is_relay = false; + params->default_data_dir = data_dir; llarp::ConfigDefinition def{false}; - initializeConfig(def, *params); - generateCommonConfigComments(def); - def.addSectionComments( + init_config(def, *params); + generate_common_config_comments(def); + def.add_section_comments( "paths", { "path selection algorithm options", }); - def.addSectionComments( + def.add_section_comments( "network", { "Snapp settings", }); - return def.generateINIConfig(true); + return def.generate_ini_config(true); } std::string - Config::generateBaseRouterConfig() + Config::generate_router_config_base() { - auto params = MakeGenParams(); - params->isRelay = true; - params->defaultDataDir = m_DataDir; + auto params = make_gen_params(); + params->is_relay = true; + params->default_data_dir = data_dir; llarp::ConfigDefinition def{true}; - initializeConfig(def, *params); - generateCommonConfigComments(def); + init_config(def, *params); + generate_common_config_comments(def); // oxend - def.addSectionComments( + def.add_section_comments( "lokid", { "Settings for communicating with oxend", }); - return def.generateINIConfig(true); + return def.generate_ini_config(true); } std::shared_ptr - Config::EmbeddedConfig() + Config::make_embedded_config() { auto config = std::make_shared(); - config->Load(); - config->logging.m_logLevel = log::Level::off; - config->api.m_enableRPCServer = false; - config->network.m_endpointType = "null"; - config->network.m_saveProfiles = false; + config->load(); + config->logging.level = log::Level::off; + config->api.enable_rpc_server = false; + config->network.endpoint_type = "null"; + config->network.save_profiles = false; config->bootstrap.files.clear(); return config; } diff --git a/llarp/config/config.hpp b/llarp/config/config.hpp index 9ee7f2e6b..ecee74bbf 100644 --- a/llarp/config/config.hpp +++ b/llarp/config/config.hpp @@ -31,8 +31,8 @@ namespace llarp { - using SectionValues_t = llarp::ConfigParser::SectionValues_t; - using Config_impl_t = llarp::ConfigParser::Config_impl_t; + using SectionValues = llarp::ConfigParser::SectionValues; + using ConfigMap = llarp::ConfigParser::ConfigMap; // TODO: don't use these maps. they're sloppy and difficult to follow /// Small struct to gather all parameters needed for config generation to reduce the number of @@ -45,8 +45,8 @@ namespace llarp ConfigGenParameters(const ConfigGenParameters&) = delete; ConfigGenParameters(ConfigGenParameters&&) = delete; - bool isRelay = false; - fs::path defaultDataDir; + bool is_relay = false; + fs::path default_data_dir; /// get network platform (virtual for unit test mocks) virtual const llarp::net::Platform* @@ -55,33 +55,33 @@ namespace llarp struct RouterConfig { - size_t m_minConnectedRouters = 0; - size_t m_maxConnectedRouters = 0; + size_t min_connected_routers = 0; + size_t max_connected_routers = 0; - std::string m_netId; + std::string net_id; - fs::path m_dataDir; + fs::path data_dir; - bool m_blockBogons = false; + bool block_bogons = false; - int m_workerThreads = -1; - int m_numNetThreads = -1; + int worker_threads = -1; + int net_threads = -1; - size_t m_JobQueueSize = 0; + size_t job_que_size = 0; - std::string m_routerContactFile; - std::string m_encryptionKeyFile; - std::string m_identityKeyFile; - std::string m_transportKeyFile; + std::string rc_file; + std::string enckey_file; + std::string idkey_file; + std::string transkey_file; - bool m_isRelay = false; + bool is_relay = false; /// deprecated - std::optional PublicIP; + std::optional public_ip; /// deprecated - std::optional PublicPort; + std::optional public_port; void - defineConfigOptions(ConfigDefinition& conf, const ConfigGenParameters& params); + define_config_options(ConfigDefinition& conf, const ConfigGenParameters& params); }; /// config for path hop selection @@ -90,91 +90,91 @@ namespace llarp /// in our hops what netmask will we use for unique ips for hops /// i.e. 32 for every hop unique ip, 24 unique /24 per hop, etc /// - int m_UniqueHopsNetmaskSize; + int unique_hop_netmask; /// set of countrys to exclude from path building (2 char country code) - std::unordered_set m_ExcludeCountries; + std::unordered_set exclude_countries; void - defineConfigOptions(ConfigDefinition& conf, const ConfigGenParameters& params); + define_config_options(ConfigDefinition& conf, const ConfigGenParameters& params); /// return true if this set of router contacts is acceptable against this config bool - Acceptable(const std::set& hops) const; + check_rcs(const std::set& hops) const; }; struct NetworkConfig { - std::optional m_enableProfiling; - bool m_saveProfiles; - std::set m_strictConnect; - std::string m_ifname; - IPRange m_ifaddr; + std::optional enable_profiling; + bool save_profiles; + std::set strict_connect; + std::string if_name; + IPRange if_addr; - std::optional m_keyfile; - std::string m_endpointType; - bool m_reachable = false; - std::optional m_Hops; - std::optional m_Paths; - bool m_AllowExit = false; - std::set m_snodeBlacklist; - net::IPRangeMap m_ExitMap; - net::IPRangeMap m_LNSExitMap; + std::optional keyfile; + std::string endpoint_type; + bool is_reachable = false; + std::optional hops; + std::optional paths; + bool allow_exit = false; + std::set snode_blacklist; + net::IPRangeMap exit_map; + net::IPRangeMap ons_exit_map; - std::unordered_map m_ExitAuths; - std::unordered_map m_LNSExitAuths; + std::unordered_map exit_auths; + std::unordered_map ons_exit_auths; - std::unordered_map m_mapAddrs; + std::unordered_map map_addrs; - service::AuthType m_AuthType = service::AuthType::eAuthTypeNone; - service::AuthFileType m_AuthFileType = service::AuthFileType::eAuthFileHashes; - std::optional m_AuthUrl; - std::optional m_AuthMethod; - std::unordered_set m_AuthWhitelist; - std::unordered_set m_AuthStaticTokens; - std::set m_AuthFiles; + service::AuthType auth_type = service::AuthType::NONE; + service::AuthFileType auth_file_type = service::AuthFileType::HASHES; + std::optional auth_url; + std::optional auth_method; + std::unordered_set auth_whitelist; + std::unordered_set auth_static_tokens; + std::set auth_files; - std::vector m_SRVRecords; + std::vector srv_records; - std::optional m_baseV6Address; + std::optional base_ipv6_addr; - std::set m_OwnedRanges; - std::optional m_TrafficPolicy; + std::set owned_ranges; + std::optional traffic_policy; - std::optional m_PathAlignmentTimeout; + std::optional path_alignment_timeout; - std::optional m_AddrMapPersistFile; + std::optional addr_map_persist_file; - bool m_EnableRoutePoker; - bool m_BlackholeRoutes; + bool enable_route_poker; + bool blackhole_routes; void - defineConfigOptions(ConfigDefinition& conf, const ConfigGenParameters& params); + define_config_options(ConfigDefinition& conf, const ConfigGenParameters& params); }; struct DnsConfig { - bool m_raw_dns; - std::vector m_bind; - std::vector m_upstreamDNS; - std::vector m_hostfiles; - std::optional m_QueryBind; + bool raw; + std::vector bind_addr; + std::vector upstream_dns; + std::vector hostfiles; + std::optional query_bind; - std::unordered_multimap m_ExtraOpts; + std::unordered_multimap extra_opts; void - defineConfigOptions(ConfigDefinition& conf, const ConfigGenParameters& params); + define_config_options(ConfigDefinition& conf, const ConfigGenParameters& params); }; struct LinksConfig { - std::optional PublicAddress; - std::optional PublicPort; - std::vector OutboundLinks; - std::vector InboundListenAddrs; + std::optional public_addr; + std::optional public_port; + std::vector outbound_links; + std::vector inbound_listen_addrs; void - defineConfigOptions(ConfigDefinition& conf, const ConfigGenParameters& params); + define_config_options(ConfigDefinition& conf, const ConfigGenParameters& params); }; struct ConnectConfig @@ -182,26 +182,26 @@ namespace llarp std::vector routers; void - defineConfigOptions(ConfigDefinition& conf, const ConfigGenParameters& params); + define_config_options(ConfigDefinition& conf, const ConfigGenParameters& params); }; // TODO: remove oxenmq from this header struct ApiConfig { - bool m_enableRPCServer = false; - std::vector m_rpcBindAddresses; + bool enable_rpc_server = false; + std::vector rpc_bind_addrs; void - defineConfigOptions(ConfigDefinition& conf, const ConfigGenParameters& params); + define_config_options(ConfigDefinition& conf, const ConfigGenParameters& params); }; struct LokidConfig { - fs::path ident_keyfile; - oxenmq::address lokidRPCAddr; + fs::path id_keyfile; + oxenmq::address rpc_addr; void - defineConfigOptions(ConfigDefinition& conf, const ConfigGenParameters& params); + define_config_options(ConfigDefinition& conf, const ConfigGenParameters& params); }; struct BootstrapConfig @@ -209,18 +209,19 @@ namespace llarp std::vector files; BootstrapList routers; bool seednode; + void - defineConfigOptions(ConfigDefinition& conf, const ConfigGenParameters& params); + define_config_options(ConfigDefinition& conf, const ConfigGenParameters& params); }; struct LoggingConfig { - log::Type m_logType = log::Type::Print; - log::Level m_logLevel = log::Level::off; - std::string m_logFile; + log::Type type = log::Type::Print; + log::Level level = log::Level::off; + std::string file; void - defineConfigOptions(ConfigDefinition& conf, const ConfigGenParameters& params); + define_config_options(ConfigDefinition& conf, const ConfigGenParameters& params); }; struct Config @@ -231,7 +232,7 @@ namespace llarp /// create generation params (virtual for unit test mock) virtual std::unique_ptr - MakeGenParams() const; + make_gen_params() const; RouterConfig router; NetworkConfig network; @@ -246,41 +247,41 @@ namespace llarp // Initialize config definition void - initializeConfig(ConfigDefinition& conf, const ConfigGenParameters& params); + init_config(ConfigDefinition& conf, const ConfigGenParameters& params); /// Insert config entries for backwards-compatibility (e.g. so that the config system will /// tolerate old values that are no longer accepted) /// /// @param conf is the config to modify void - addBackwardsCompatibleConfigOptions(ConfigDefinition& conf); + add_backcompat_opts(ConfigDefinition& conf); // Load a config from the given file if the config file is not provided LoadDefault is called bool - Load(std::optional fname = std::nullopt, bool isRelay = false); + load(std::optional fname = std::nullopt, bool isRelay = false); // Load a config from a string of ini, same effects as Config::Load bool - LoadString(std::string_view ini, bool isRelay = false); + load_string(std::string_view ini, bool isRelay = false); std::string - generateBaseClientConfig(); + generate_client_config_base(); std::string - generateBaseRouterConfig(); + generate_router_config_base(); void - Save(); + save(); void - Override(std::string section, std::string key, std::string value); + override(std::string section, std::string key, std::string value); void - AddDefault(std::string section, std::string key, std::string value); + add_default(std::string section, std::string key, std::string value); /// create a config with the default parameters for an embedded lokinet static std::shared_ptr - EmbeddedConfig(); + make_embedded_config(); private: /// Load (initialize) a default config. @@ -295,21 +296,21 @@ namespace llarp /// @param dataDir is a path representing a directory to be used as the data dir /// @return true on success, false otherwise bool - LoadDefault(bool isRelay); + load_default_config(bool isRelay); bool - LoadConfigData( + load_config_data( std::string_view ini, std::optional fname = std::nullopt, bool isRelay = false); void - LoadOverrides(ConfigDefinition& conf) const; + load_overrides(ConfigDefinition& conf) const; - std::vector> m_Additional; - ConfigParser m_Parser; - const fs::path m_DataDir; + std::vector> additional; + ConfigParser parser; + const fs::path data_dir; }; void - ensureConfig(fs::path dataDir, fs::path confFile, bool overwrite, bool asRouter); + ensure_config(fs::path dataDir, fs::path confFile, bool overwrite, bool asRouter); } // namespace llarp diff --git a/llarp/config/definition.cpp b/llarp/config/definition.cpp index b27e4b2e5..b4e1adac1 100644 --- a/llarp/config/definition.cpp +++ b/llarp/config/definition.cpp @@ -10,25 +10,24 @@ namespace llarp { template <> bool - OptionDefinition::fromString(const std::string& input) + OptionDefinition::from_string(const std::string& input) { if (input == "false" || input == "off" || input == "0" || input == "no") return false; - else if (input == "true" || input == "on" || input == "1" || input == "yes") + if (input == "true" || input == "on" || input == "1" || input == "yes") return true; - else - throw std::invalid_argument{fmt::format("{} is not a valid bool", input)}; + throw std::invalid_argument{fmt::format("{} is not a valid bool", input)}; } ConfigDefinition& - ConfigDefinition::defineOption(OptionDefinition_ptr def) + ConfigDefinition::define_option(std::unique_ptr def) { using namespace config; // If explicitly deprecated or is a {client,relay} option in a {relay,client} config then add a // dummy, warning option instead of this one. - if (def->deprecated || (relay ? def->clientOnly : def->relayOnly)) + if (def->deprecated || (relay ? def->clientOnly : def->relay_only)) { - return defineOption( + return define_option( def->section, def->name, MultiValue, @@ -46,36 +45,36 @@ namespace llarp }); } - auto [sectionItr, newSect] = m_definitions.try_emplace(def->section); + auto [sectionItr, newSect] = definitions.try_emplace(def->section); if (newSect) - m_sectionOrdering.push_back(def->section); + section_ordering.push_back(def->section); auto& section = sectionItr->first; - auto [it, added] = m_definitions[section].try_emplace(std::string{def->name}, std::move(def)); + auto [it, added] = definitions[section].try_emplace(std::string{def->name}, std::move(def)); if (!added) throw std::invalid_argument{ fmt::format("definition for [{}]:{} already exists", def->section, def->name)}; - m_definitionOrdering[section].push_back(it->first); + definition_ordering[section].push_back(it->first); if (!it->second->comments.empty()) - addOptionComments(section, it->first, std::move(it->second->comments)); + add_option_comments(section, it->first, std::move(it->second->comments)); return *this; } ConfigDefinition& - ConfigDefinition::addConfigValue( + ConfigDefinition::add_config_value( std::string_view section, std::string_view name, std::string_view value) { // see if we have an undeclared handler to fall back to in case section or section:name is // absent - auto undItr = m_undeclaredHandlers.find(std::string(section)); - bool haveUndeclaredHandler = (undItr != m_undeclaredHandlers.end()); + auto undItr = undeclared_handlers.find(std::string(section)); + bool haveUndeclaredHandler = (undItr != undeclared_handlers.end()); // get section, falling back to undeclared handler if needed - auto secItr = m_definitions.find(std::string(section)); - if (secItr == m_definitions.end()) + auto secItr = definitions.find(std::string(section)); + if (secItr == definitions.end()) { // fallback to undeclared handler if available if (not haveUndeclaredHandler) @@ -91,8 +90,8 @@ namespace llarp auto defItr = sectionDefinitions.find(std::string(name)); if (defItr != sectionDefinitions.end()) { - OptionDefinition_ptr& definition = defItr->second; - definition->parseValue(std::string(value)); + std::unique_ptr& definition = defItr->second; + definition->parse_value(std::string(value)); return *this; } @@ -105,63 +104,67 @@ namespace llarp } void - ConfigDefinition::addUndeclaredHandler(const std::string& section, UndeclaredValueHandler handler) + ConfigDefinition::add_undeclared_handler( + const std::string& section, UndeclaredValueHandler handler) { - auto itr = m_undeclaredHandlers.find(section); - if (itr != m_undeclaredHandlers.end()) + auto itr = undeclared_handlers.find(section); + if (itr != undeclared_handlers.end()) throw std::logic_error{fmt::format("section {} already has a handler", section)}; - m_undeclaredHandlers[section] = std::move(handler); + undeclared_handlers[section] = std::move(handler); } void - ConfigDefinition::removeUndeclaredHandler(const std::string& section) + ConfigDefinition::remove_undeclared_handler(const std::string& section) { - auto itr = m_undeclaredHandlers.find(section); - if (itr != m_undeclaredHandlers.end()) - m_undeclaredHandlers.erase(itr); + auto itr = undeclared_handlers.find(section); + if (itr != undeclared_handlers.end()) + undeclared_handlers.erase(itr); } void - ConfigDefinition::validateRequiredFields() + ConfigDefinition::validate_required_fields() { - visitSections([&](const std::string& section, const DefinitionMap&) { - visitDefinitions(section, [&](const std::string&, const OptionDefinition_ptr& def) { - if (def->required and def->getNumberFound() < 1) - { - throw std::invalid_argument{ - fmt::format("[{}]:{} is required but missing", section, def->name)}; - } - - // should be handled earlier in OptionDefinition::parseValue() - assert(def->getNumberFound() <= 1 or def->multiValued); - }); + visit_sections([&](const std::string& section, const DefinitionMap&) { + visit_definitions( + section, [&](const std::string&, const std::unique_ptr& def) { + if (def->required and def->get_number_found() < 1) + { + throw std::invalid_argument{ + fmt::format("[{}]:{} is required but missing", section, def->name)}; + } + + // should be handled earlier in OptionDefinition::parse_value() + assert(def->get_number_found() <= 1 or def->multi_valued); + }); }); } void - ConfigDefinition::acceptAllOptions() + ConfigDefinition::accept_all_options() { - visitSections([this](const std::string& section, const DefinitionMap&) { - visitDefinitions( - section, [](const std::string&, const OptionDefinition_ptr& def) { def->tryAccept(); }); + visit_sections([this](const std::string& section, const DefinitionMap&) { + visit_definitions( + section, [](const std::string&, const std::unique_ptr& def) { + def->try_accept(); + }); }); } void - ConfigDefinition::addSectionComments( + ConfigDefinition::add_section_comments( const std::string& section, std::vector comments) { - auto& sectionComments = m_sectionComments[section]; + auto& sectionComments = section_comments[section]; for (auto& c : comments) sectionComments.emplace_back(std::move(c)); } void - ConfigDefinition::addOptionComments( + ConfigDefinition::add_option_comments( const std::string& section, const std::string& name, std::vector comments) { - auto& defComments = m_definitionComments[section][name]; + auto& defComments = definition_comments[section][name]; if (defComments.empty()) defComments = std::move(comments); else @@ -172,48 +175,49 @@ namespace llarp } std::string - ConfigDefinition::generateINIConfig(bool useValues) + ConfigDefinition::generate_ini_config(bool useValues) { std::string ini; auto ini_append = std::back_inserter(ini); int sectionsVisited = 0; - visitSections([&](const std::string& section, const DefinitionMap&) { + visit_sections([&](const std::string& section, const DefinitionMap&) { std::string sect_str; auto sect_append = std::back_inserter(sect_str); - visitDefinitions(section, [&](const std::string& name, const OptionDefinition_ptr& def) { - bool has_comment = false; - // TODO: as above, this will create empty objects - // TODO: as above (but more important): this won't handle definitions with no entries - // (i.e. those handled by UndeclaredValueHandler's) - for (const std::string& comment : m_definitionComments[section][name]) - { - fmt::format_to(sect_append, "\n# {}", comment); - has_comment = true; - } - - if (useValues and def->getNumberFound() > 0) - { - for (const auto& val : def->valuesAsString()) - fmt::format_to(sect_append, "\n{}={}", name, val); - *sect_append = '\n'; - } - else if (not def->hidden) - { - if (auto defaults = def->defaultValuesAsString(); not defaults.empty()) - for (const auto& val : defaults) - fmt::format_to(sect_append, "\n{}{}={}", def->required ? "" : "#", name, val); - else - // We have no defaults so we append it as "#opt-name=" so that we show the option name, - // and make it simple to uncomment and edit to the desired value. - fmt::format_to(sect_append, "\n#{}=", name); - *sect_append = '\n'; - } - else if (has_comment) - *sect_append = '\n'; - }); + visit_definitions( + section, [&](const std::string& name, const std::unique_ptr& def) { + bool has_comment = false; + // TODO: as above, this will create empty objects + // TODO: as above (but more important): this won't handle definitions with no entries + // (i.e. those handled by UndeclaredValueHandler's) + for (const std::string& comment : definition_comments[section][name]) + { + fmt::format_to(sect_append, "\n# {}", comment); + has_comment = true; + } + + if (useValues and def->get_number_found() > 0) + { + for (const auto& val : def->values_as_string()) + fmt::format_to(sect_append, "\n{}={}", name, val); + *sect_append = '\n'; + } + else if (not def->hidden) + { + if (auto defaults = def->default_values_as_string(); not defaults.empty()) + for (const auto& val : defaults) + fmt::format_to(sect_append, "\n{}{}={}", def->required ? "" : "#", name, val); + else + // We have no defaults so we append it as "#opt-name=" so that we show the option + // name, and make it simple to uncomment and edit to the desired value. + fmt::format_to(sect_append, "\n#{}=", name); + *sect_append = '\n'; + } + else if (has_comment) + *sect_append = '\n'; + }); if (sect_str.empty()) return; // Skip sections with no options @@ -225,7 +229,7 @@ namespace llarp // TODO: this will create empty objects as a side effect of map's operator[] // TODO: this also won't handle sections which have no definition - for (const std::string& comment : m_sectionComments[section]) + for (const std::string& comment : section_comments[section]) { fmt::format_to(ini_append, "# {}\n", comment); } @@ -238,11 +242,12 @@ namespace llarp return ini; } - const OptionDefinition_ptr& - ConfigDefinition::lookupDefinitionOrThrow(std::string_view section, std::string_view name) const + const std::unique_ptr& + ConfigDefinition::lookup_definition_or_throw( + std::string_view section, std::string_view name) const { - const auto sectionItr = m_definitions.find(std::string(section)); - if (sectionItr == m_definitions.end()) + const auto sectionItr = definitions.find(std::string(section)); + if (sectionItr == definitions.end()) throw std::invalid_argument{fmt::format("No config section [{}]", section)}; auto& sectionDefinitions = sectionItr->second; @@ -254,28 +259,28 @@ namespace llarp return definitionItr->second; } - OptionDefinition_ptr& - ConfigDefinition::lookupDefinitionOrThrow(std::string_view section, std::string_view name) + std::unique_ptr& + ConfigDefinition::lookup_definition_or_throw(std::string_view section, std::string_view name) { - return const_cast( - const_cast(this)->lookupDefinitionOrThrow(section, name)); + return const_cast&>( + const_cast(this)->lookup_definition_or_throw(section, name)); } void - ConfigDefinition::visitSections(SectionVisitor visitor) const + ConfigDefinition::visit_sections(SectionVisitor visitor) const { - for (const std::string& section : m_sectionOrdering) + for (const std::string& section : section_ordering) { - const auto itr = m_definitions.find(section); - assert(itr != m_definitions.end()); + const auto itr = definitions.find(section); + assert(itr != definitions.end()); visitor(section, itr->second); } }; void - ConfigDefinition::visitDefinitions(const std::string& section, DefVisitor visitor) const + ConfigDefinition::visit_definitions(const std::string& section, DefVisitor visitor) const { - const auto& defs = m_definitions.at(section); - const auto& defOrdering = m_definitionOrdering.at(section); + const auto& defs = definitions.at(section); + const auto& defOrdering = definition_ordering.at(section); for (const std::string& name : defOrdering) { const auto itr = defs.find(name); diff --git a/llarp/config/definition.hpp b/llarp/config/definition.hpp index 2d0ed0818..7b777f056 100644 --- a/llarp/config/definition.hpp +++ b/llarp/config/definition.hpp @@ -22,42 +22,45 @@ namespace llarp { namespace config { - // Base class for the following option flag types - struct option_flag - {}; - - struct Required_t : option_flag - {}; - struct Hidden_t : option_flag - {}; - struct MultiValue_t : option_flag - {}; - struct RelayOnly_t : option_flag - {}; - struct ClientOnly_t : option_flag - {}; - struct Deprecated_t : option_flag - {}; + namespace flag + { + // Base class for the following option flag types + struct opt + {}; + + struct REQUIRED : opt + {}; + struct HIDDEN : opt + {}; + struct MULTIVALUE : opt + {}; + struct RELAYONLY : opt + {}; + struct CLIENTONLY : opt + {}; + struct DEPRECATED : opt + {}; + } // namespace flag /// Value to pass for an OptionDefinition to indicate that the option is required - inline constexpr Required_t Required{}; + inline constexpr flag::REQUIRED Required{}; /// Value to pass for an OptionDefinition to indicate that the option should be hidden from the /// generate config file if it is unset (and has no comment). Typically for deprecated, renamed /// options that still do something, and for internal dev options that aren't usefully exposed. /// (For do-nothing deprecated options use Deprecated instead). - inline constexpr Hidden_t Hidden{}; + inline constexpr flag::HIDDEN Hidden{}; /// Value to pass for an OptionDefinition to indicate that the option takes multiple values - inline constexpr MultiValue_t MultiValue{}; + inline constexpr flag::MULTIVALUE MultiValue{}; /// Value to pass for an option that should only be set for relay configs. If found in a client /// config it be ignored (but will produce a warning). - inline constexpr RelayOnly_t RelayOnly{}; + inline constexpr flag::RELAYONLY RelayOnly{}; /// Value to pass for an option that should only be set for client configs. If found in a relay /// config it will be ignored (but will produce a warning). - inline constexpr ClientOnly_t ClientOnly{}; + inline constexpr flag::CLIENTONLY ClientOnly{}; /// Value to pass for an option that is deprecated and does nothing and should be ignored (with /// a deprecation warning) if specified. Note that Deprecated implies Hidden, and that /// {client,relay}-only options in a {relay,client} config are also considered Deprecated. - inline constexpr Deprecated_t Deprecated{}; + inline constexpr flag::DEPRECATED Deprecated{}; /// Wrapper to specify a default value to an OptionDefinition template @@ -82,7 +85,7 @@ namespace llarp /// particular, a reference to a local variable may be problematic. template auto - AssignmentAcceptor(T& ref) + assignment_acceptor(T& ref) { return [&ref](T arg) { ref = std::move(arg); }; } @@ -106,7 +109,7 @@ namespace llarp constexpr bool is_default_array = is_default_array>; template - constexpr bool is_option = std::is_base_of_v> + constexpr bool is_option = std::is_base_of_v> or std::is_same_v or is_default