#include "router.hpp" #include #include #include #include #include #include "buffer.hpp" #include "encode.hpp" #include "llarp/net.hpp" #include "logger.hpp" #include "str.hpp" #include #include #if defined(RPI) || defined(ANDROID) #include #endif namespace llarp { void router_iter_config(llarp_config_iterator *iter, const char *section, const char *key, const char *val); struct async_verify_context { llarp_router *router; TryConnectJob *establish_job; }; } // namespace llarp struct TryConnectJob { llarp::RouterContact rc; llarp::ILinkLayer *link; llarp_router *router; uint16_t triesLeft; TryConnectJob(const llarp::RouterContact &remote, llarp::ILinkLayer *l, uint16_t tries, llarp_router *r) : rc(remote), link(l), router(r), triesLeft(tries) { } void Failed() { llarp::LogInfo("session to ", rc.pubkey, " closed"); link->CloseSessionTo(rc.pubkey); } void Success() { llarp::LogInfo("established session with ", rc.pubkey); router->FlushOutboundFor(rc.pubkey, link); } void AttemptTimedout() { router->routerProfiling.MarkTimeout(rc.pubkey); if(ShouldRetry()) { Attempt(); return; } if(!router->IsServiceNode()) { if(router->routerProfiling.IsBad(rc.pubkey)) llarp_nodedb_del_rc(router->nodedb, rc.pubkey); } // delete this router->pendingEstablishJobs.erase(rc.pubkey); } void Attempt() { --triesLeft; if(!link->TryEstablishTo(rc)) llarp::LogError("did not attempt connection to ", rc.pubkey, " and it has ", rc.addrs.size(), " advertised addresses"); } bool ShouldRetry() const { return triesLeft > 0; } }; static void on_try_connecting(void *u) { TryConnectJob *j = static_cast< TryConnectJob * >(u); j->Attempt(); } bool llarp_router_try_connect(struct llarp_router *router, const llarp::RouterContact &remote, uint16_t numretries) { // do we already have a pending job for this remote? if(router->HasPendingConnectJob(remote.pubkey)) { llarp::LogDebug("We have pending connect jobs to ", remote.pubkey); return false; } auto link = router->outboundLink.get(); auto itr = router->pendingEstablishJobs.insert(std::make_pair( remote.pubkey, std::make_unique< TryConnectJob >(remote, link, numretries, router))); TryConnectJob *job = itr.first->second.get(); // try establishing async llarp_logic_queue_job(router->logic, {job, &on_try_connecting}); return true; } void llarp_router::HandleLinkSessionEstablished(llarp::RouterContact rc, llarp::ILinkLayer *link) { async_verify_RC(rc, link); } llarp_router::llarp_router() : ready(false) , paths(this) , exitContext(this) , dht(llarp_dht_context_new(this)) , inbound_link_msg_parser(this) , hiddenServiceContext(this) { // set rational defaults this->ip4addr.sin_family = AF_INET; this->ip4addr.sin_port = htons(1090); } llarp_router::~llarp_router() { llarp_dht_context_free(dht); } bool llarp_router::HandleRecvLinkMessageBuffer(llarp::ILinkSession *session, llarp_buffer_t buf) { if(!session) { llarp::LogWarn("no link session"); return false; } return inbound_link_msg_parser.ProcessFrom(session, buf); } void llarp_router::PersistSessionUntil(const llarp::RouterID &remote, llarp_time_t until) { llarp::LogDebug("persist session to ", remote, " until ", until); m_PersistingSessions[remote] = std::max(until, m_PersistingSessions[remote]); } constexpr size_t MaxPendingSendQueueSize = 8; bool llarp_router::SendToOrQueue(const llarp::RouterID &remote, const llarp::ILinkMessage *msg) { for(const auto &link : inboundLinks) { if(link->HasSessionTo(remote)) { SendTo(remote, msg, link.get()); return true; } } if(outboundLink && outboundLink->HasSessionTo(remote)) { SendTo(remote, msg, outboundLink.get()); return true; } // no link available // this will create an entry in the obmq if it's not already there auto itr = outboundMessageQueue.find(remote); if(itr == outboundMessageQueue.end()) { outboundMessageQueue.insert(std::make_pair(remote, MessageQueue())); } // encode llarp_buffer_t buf = llarp::StackBuffer< decltype(linkmsg_buffer) >(linkmsg_buffer); if(!msg->BEncode(&buf)) return false; // queue buffer auto &q = outboundMessageQueue[remote]; if(q.size() < MaxPendingSendQueueSize) { buf.sz = buf.cur - buf.base; q.emplace(buf.sz); memcpy(q.back().data(), buf.base, buf.sz); } else { llarp::LogWarn("tried to queue a message to ", remote, " but the queue is full so we drop it like it's hawt"); } llarp::RouterContact remoteRC; // we don't have an open session to that router right now if(llarp_nodedb_get_rc(nodedb, remote, remoteRC)) { // try connecting directly as the rc is loaded from disk llarp_router_try_connect(this, remoteRC, 10); return true; } // we don't have the RC locally so do a dht lookup dht->impl.LookupRouter(remote, std::bind(&llarp_router::HandleDHTLookupForSendTo, this, remote, std::placeholders::_1)); return true; } void llarp_router::HandleDHTLookupForSendTo( llarp::RouterID remote, const std::vector< llarp::RouterContact > &results) { if(results.size()) { if(whitelistRouters && lokinetRouters.find(remote) == lokinetRouters.end()) { return; } if(results[0].Verify(&crypto)) { llarp_nodedb_put_rc(nodedb, results[0]); llarp_router_try_connect(this, results[0], 10); } } else { DiscardOutboundFor(remote); } } void llarp_router::ForEachPeer( std::function< void(const llarp::ILinkSession *, bool) > visit) const { outboundLink->ForEachSession( [visit](const llarp::ILinkSession *peer) { visit(peer, true); }); for(const auto &link : inboundLinks) { link->ForEachSession( [visit](const llarp::ILinkSession *peer) { visit(peer, false); }); } } void llarp_router::try_connect(fs::path rcfile) { llarp::RouterContact remote; if(!remote.Read(rcfile.string().c_str())) { llarp::LogError("failure to decode or verify of remote RC"); return; } if(remote.Verify(&crypto)) { llarp::LogDebug("verified signature"); // store into filesystem if(!llarp_nodedb_put_rc(nodedb, remote)) { llarp::LogWarn("failed to store"); } if(!llarp_router_try_connect(this, remote, 10)) { // or error? llarp::LogWarn("session already made"); } } else llarp::LogError(rcfile, " contains invalid RC"); } bool llarp_router::EnsureIdentity() { if(!EnsureEncryptionKey()) return false; return llarp_findOrCreateIdentity(&crypto, ident_keyfile.string().c_str(), identity); } bool llarp_router::EnsureEncryptionKey() { return llarp_findOrCreateEncryption( &crypto, encryption_keyfile.string().c_str(), encryption); } void llarp_router::AddInboundLink(std::unique_ptr< llarp::ILinkLayer > &link) { inboundLinks.push_back(std::move(link)); } bool llarp_router::Ready() { return outboundLink != nullptr; } bool llarp_router::SaveRC() { llarp::LogDebug("verify RC signature"); if(!rc().Verify(&crypto)) { rc().Dump< MAX_RC_SIZE >(); llarp::LogError("RC is invalid, not saving"); return false; } return rc().Write(our_rc_file.string().c_str()); } bool llarp_router::IsServiceNode() const { return inboundLinks.size() > 0; } void llarp_router::Close() { for(const auto &link : inboundLinks) { link->Stop(); } inboundLinks.clear(); if(outboundLink) { outboundLink->Stop(); outboundLink.reset(nullptr); } } void llarp_router::on_verify_client_rc(llarp_async_verify_rc *job) { llarp::async_verify_context *ctx = static_cast< llarp::async_verify_context * >(job->user); ctx->router->pendingEstablishJobs.erase(job->rc.pubkey); auto router = ctx->router; llarp::PubKey pk(job->rc.pubkey); router->FlushOutboundFor(pk, router->GetLinkWithSessionByPubkey(pk)); delete ctx; router->pendingVerifyRC.erase(pk); } void llarp_router::on_verify_server_rc(llarp_async_verify_rc *job) { llarp::async_verify_context *ctx = static_cast< llarp::async_verify_context * >(job->user); auto router = ctx->router; llarp::PubKey pk(job->rc.pubkey); if(!job->valid) { if(ctx->establish_job) { // was an outbound attempt ctx->establish_job->Failed(); } delete ctx; router->DiscardOutboundFor(pk); router->pendingVerifyRC.erase(pk); return; } // we're valid, which means it's already been committed to the nodedb llarp::LogDebug("rc verified and saved to nodedb"); if(router->validRouters.count(pk)) { router->validRouters.erase(pk); } llarp::RouterContact rc = job->rc; router->validRouters.insert(std::make_pair(pk, rc)); // track valid router in dht router->dht->impl.nodes->PutNode(rc); // mark success in profile router->routerProfiling.MarkSuccess(pk); // this was an outbound establish job if(ctx->establish_job) { ctx->establish_job->Success(); } else router->FlushOutboundFor(pk, router->GetLinkWithSessionByPubkey(pk)); delete ctx; router->pendingVerifyRC.erase(pk); } void llarp_router::handle_router_ticker(void *user, uint64_t orig, uint64_t left) { if(left) return; llarp_router *self = static_cast< llarp_router * >(user); self->ticker_job_id = 0; self->Tick(); self->ScheduleTicker(orig); } bool llarp_router::ConnectionToRouterAllowed(const llarp::RouterID &router) const { if(strictConnectPubkeys.size() && strictConnectPubkeys.count(router) == 0) return false; else if(IsServiceNode() && whitelistRouters) return lokinetRouters.count(router) != 0; else return true; } void llarp_router::HandleDHTLookupForExplore( llarp::RouterID remote, const std::vector< llarp::RouterContact > &results) { if(results.size() == 0) return; for(const auto &rc : results) { if(rc.Verify(&crypto)) llarp_nodedb_put_rc(nodedb, rc); else return; } if(ConnectionToRouterAllowed(remote)) { TryEstablishTo(remote); } } void llarp_router::TryEstablishTo(const llarp::RouterID &remote) { if(!ConnectionToRouterAllowed(remote)) { llarp::LogWarn("not connecting to ", remote, " as it's not permitted by config"); return; } llarp::RouterContact rc; if(llarp_nodedb_get_rc(nodedb, remote, rc)) { // try connecting async llarp_router_try_connect(this, rc, 5); } else if(IsServiceNode() || !routerProfiling.IsBad(remote)) { if(dht->impl.HasRouterLookup(remote)) return; llarp::LogInfo("looking up router ", remote); // dht lookup as we don't know it dht->impl.LookupRouter( remote, std::bind(&llarp_router::HandleDHTLookupForTryEstablishTo, this, remote, std::placeholders::_1)); } else { llarp::LogWarn("not connecting to ", remote, " as it's unreliable"); } } void llarp_router::OnConnectTimeout(const llarp::RouterID &remote) { auto itr = pendingEstablishJobs.find(remote); if(itr != pendingEstablishJobs.end()) { itr->second->AttemptTimedout(); } } void llarp_router::HandleDHTLookupForTryEstablishTo( llarp::RouterID remote, const std::vector< llarp::RouterContact > &results) { if(results.size() == 0) { if(!IsServiceNode()) routerProfiling.MarkTimeout(remote); } for(const auto &result : results) { if(whitelistRouters && lokinetRouters.find(result.pubkey) == lokinetRouters.end()) continue; llarp_nodedb_put_rc(nodedb, result); llarp_router_try_connect(this, result, 10); } } size_t llarp_router::NumberOfConnectedRouters() const { return validRouters.size(); } void llarp_router::Tick() { // llarp::LogDebug("tick router"); auto now = llarp_ev_loop_time_now_ms(netloop); paths.TickPaths(now); paths.ExpirePaths(now); { auto itr = m_PersistingSessions.begin(); while(itr != m_PersistingSessions.end()) { auto link = GetLinkWithSessionByPubkey(itr->first); if(now < itr->second) { if(link) { llarp::LogDebug("keepalive to ", itr->first); link->KeepAliveSessionTo(itr->first); } else { llarp::LogDebug("establish to ", itr->first); TryEstablishTo(itr->first); } ++itr; } else { llarp::LogInfo("commit to ", itr->first, " expired"); itr = m_PersistingSessions.erase(itr); } } } if(inboundLinks.size() == 0) { size_t N = llarp_nodedb_num_loaded(nodedb); if(N < minRequiredRouters) { llarp::LogInfo("We need at least ", minRequiredRouters, " service nodes to build paths but we have ", N); // TODO: only connect to random subset if(bootstrapRCList.size()) { for(const auto &rc : bootstrapRCList) { llarp_router_try_connect(this, rc, 4); dht->impl.ExploreNetworkVia(rc.pubkey.data()); } } else llarp::LogError("we have no bootstrap nodes specified"); } paths.BuildPaths(now); hiddenServiceContext.Tick(now); } if(NumberOfConnectedRouters() < minConnectedRouters) { ConnectToRandomRouters(minConnectedRouters); } exitContext.Tick(now); if(rpcCaller) rpcCaller->Tick(now); } void llarp_router::SendTo(llarp::RouterID remote, const llarp::ILinkMessage *msg, llarp::ILinkLayer *selected) { llarp_buffer_t buf = llarp::StackBuffer< decltype(linkmsg_buffer) >(linkmsg_buffer); if(!msg->BEncode(&buf)) { llarp::LogWarn("failed to encode outbound message, buffer size left: ", llarp_buffer_size_left(buf)); return; } // set size of message buf.sz = buf.cur - buf.base; buf.cur = buf.base; llarp::LogDebug("send ", buf.sz, " bytes to ", remote); if(selected) { if(selected->SendTo(remote, buf)) return; } bool sent = outboundLink->SendTo(remote, buf); if(!sent) { for(const auto &link : inboundLinks) { if(!sent) { sent = link->SendTo(remote, buf); } } } if(!sent) llarp::LogWarn("message to ", remote, " was dropped"); } void llarp_router::ScheduleTicker(uint64_t ms) { ticker_job_id = llarp_logic_call_later(logic, {ms, this, &handle_router_ticker}); } void llarp_router::SessionClosed(const llarp::RouterID &remote) { __llarp_dht_remove_peer(dht, remote); // remove from valid routers if it's a valid router validRouters.erase(remote); llarp::LogInfo("Session to ", remote, " fully closed"); } llarp::ILinkLayer * llarp_router::GetLinkWithSessionByPubkey(const llarp::RouterID &pubkey) { if(outboundLink->HasSessionTo(pubkey)) return outboundLink.get(); for(const auto &link : inboundLinks) { if(link->HasSessionTo(pubkey)) return link.get(); } return nullptr; } void llarp_router::FlushOutboundFor(llarp::RouterID remote, llarp::ILinkLayer *chosen) { llarp::LogDebug("Flush outbound for ", remote); auto itr = outboundMessageQueue.find(remote); if(itr == outboundMessageQueue.end()) { pendingEstablishJobs.erase(remote); return; } if(!chosen) { DiscardOutboundFor(remote); pendingEstablishJobs.erase(remote); return; } while(itr->second.size()) { auto buf = llarp::ConstBuffer(itr->second.front()); if(!chosen->SendTo(remote, buf)) llarp::LogWarn("failed to send outboud message to ", remote, " via ", chosen->Name()); itr->second.pop(); } pendingEstablishJobs.erase(remote); } void llarp_router::DiscardOutboundFor(const llarp::RouterID &remote) { outboundMessageQueue.erase(remote); } bool llarp_router::GetRandomConnectedRouter(llarp::RouterContact &result) const { auto sz = validRouters.size(); if(sz) { auto itr = validRouters.begin(); if(sz > 1) std::advance(itr, llarp_randint() % sz); result = itr->second; return true; } return false; } void llarp_router::async_verify_RC(const llarp::RouterContact &rc, llarp::ILinkLayer *link) { if(pendingVerifyRC.count(rc.pubkey)) return; if(rc.IsPublicRouter() && whitelistRouters) { if(lokinetRouters.find(rc.pubkey) == lokinetRouters.end()) { llarp::LogInfo(rc.pubkey, " is NOT a valid service node, rejecting"); link->CloseSessionTo(rc.pubkey); return; } } llarp_async_verify_rc *job = &pendingVerifyRC[rc.pubkey]; llarp::async_verify_context *ctx = new llarp::async_verify_context(); ctx->router = this; ctx->establish_job = nullptr; auto itr = pendingEstablishJobs.find(rc.pubkey); if(itr != pendingEstablishJobs.end()) ctx->establish_job = itr->second.get(); job->user = ctx; job->rc = rc; job->valid = false; job->hook = nullptr; job->nodedb = nodedb; job->logic = logic; // job->crypto = &crypto; // we already have this job->cryptoworker = tp; job->diskworker = disk; if(rc.IsPublicRouter()) job->hook = &llarp_router::on_verify_server_rc; else job->hook = &llarp_router::on_verify_client_rc; llarp_nodedb_async_verify(job); } bool llarp_router::Run() { if(enableRPCServer) { if(rpcBindAddr.empty()) { rpcBindAddr = DefaultRPCBindAddr; } rpcServer = std::make_unique< llarp::rpc::Server >(this); while(!rpcServer->Start(rpcBindAddr)) { llarp::LogError("failed to bind jsonrpc to ", rpcBindAddr); #if defined(ANDROID) || defined(RPI) sleep(1); #else std::this_thread::sleep_for(std::chrono::seconds(1)); #endif } llarp::LogInfo("Bound RPC server to ", rpcBindAddr); } llarp_threadpool_start(tp); llarp_threadpool_start(disk); routerProfiling.Load(routerProfilesFile.c_str()); llarp::Addr publicAddr(this->addrInfo); if(this->publicOverride) { llarp::LogDebug("public address:port ", publicAddr); } llarp::LogInfo("You have ", inboundLinks.size(), " inbound links"); for(const auto &link : inboundLinks) { llarp::AddressInfo addr; if(!link->GetOurAddressInfo(addr)) continue; llarp::Addr a(addr); if(this->publicOverride && a.sameAddr(publicAddr)) { llarp::LogInfo("Found adapter for public address"); } if(!llarp::IsBogon(*a.addr6())) { llarp::LogInfo("Loading Addr: ", a, " into our RC"); _rc.addrs.push_back(addr); } }; if(this->publicOverride) { llarp::ILinkLayer *link = nullptr; // llarp::LogWarn("Need to load our public IP into RC!"); if(inboundLinks.size() == 1) { link = inboundLinks[0].get(); } else { if(inboundLinks.size()) { link = inboundLinks[0].get(); } else { llarp::LogWarn( "No need to set public ipv4 and port if no external interface " "binds, turning off public override"); this->publicOverride = false; link = nullptr; } } if(link && link->GetOurAddressInfo(this->addrInfo)) { // override ip and port this->addrInfo.ip = *publicAddr.addr6(); this->addrInfo.port = publicAddr.port(); llarp::LogInfo("Loaded our public ", publicAddr, " override into RC!"); _rc.addrs.push_back(this->addrInfo); } } // set public encryption key _rc.enckey = llarp::seckey_topublic(encryption); llarp::LogInfo("Your Encryption pubkey ", rc().enckey); // set public signing key _rc.pubkey = llarp::seckey_topublic(identity); llarp::LogInfo("Your Identity pubkey ", rc().pubkey); if(ExitEnabled()) { llarp::nuint32_t a = publicAddr.xtonl(); // TODO: enable this once the network can serialize xi //_rc.exits.emplace_back(_rc.pubkey, a); llarp::LogInfo( "Neato tehl33toh, You are a freaking exit relay. w00t!!!!! your exit " "is advertised as exiting at ", a); } llarp::LogInfo("Signing rc..."); if(!_rc.Sign(&crypto, identity)) { llarp::LogError("failed to sign rc"); return false; } if(!SaveRC()) { llarp::LogError("failed to save RC"); return false; } llarp::LogInfo("have ", llarp_nodedb_num_loaded(nodedb), " routers"); llarp::LogDebug("starting outbound link"); if(!outboundLink->Start(logic)) { llarp::LogWarn("outbound link failed to start"); return false; } int IBLinksStarted = 0; // start links for(const auto &link : inboundLinks) { if(link->Start(logic)) { llarp::LogDebug("Link ", link->Name(), " started"); IBLinksStarted++; } else llarp::LogWarn("Link ", link->Name(), " failed to start"); } if(IBLinksStarted > 0) { // initialize as service node if(!InitServiceNode()) { llarp::LogError("Failed to initialize service node"); return false; } } else { // we are a client // regenerate keys and resign rc before everything else crypto.identity_keygen(identity); crypto.encryption_keygen(encryption); _rc.pubkey = llarp::seckey_topublic(identity); _rc.enckey = llarp::seckey_topublic(encryption); if(!_rc.Sign(&crypto, identity)) { llarp::LogError("failed to regenerate keys and sign RC"); return false; } // generate default hidden service llarp::LogInfo("setting up default network endpoint"); if(!CreateDefaultHiddenService()) { llarp::LogError("failed to set up default network endpoint"); return false; } } llarp::LogInfo("starting hidden service context..."); if(!hiddenServiceContext.StartAll()) { llarp::LogError("Failed to start hidden service context"); return false; } llarp::PubKey ourPubkey = pubkey(); llarp::LogInfo("starting dht context as ", ourPubkey); llarp_dht_context_start(dht, ourPubkey); ScheduleTicker(1000); return true; } bool llarp_router::InitServiceNode() { llarp::LogInfo("accepting transit traffic"); paths.AllowTransit(); llarp_dht_allow_transit(dht); return exitContext.AddExitEndpoint("default-connectivity", netConfig); } bool llarp_router::HasSessionTo(const llarp::RouterID &remote) const { return validRouters.find(remote) != validRouters.end(); } void llarp_router::ConnectToRandomRouters(int want) { int wanted = want; llarp_router *self = this; llarp_nodedb_visit_loaded( self->nodedb, [self, &want](const llarp::RouterContact &other) -> bool { // check if we really want to if(!self->ConnectionToRouterAllowed(other.pubkey)) return want > 0; if(llarp_randint() % 2 == 0 && !(self->HasSessionTo(other.pubkey) || self->HasPendingConnectJob(other.pubkey))) { llarp_router_try_connect(self, other, 5); --want; } return want > 0; }); if(wanted != want) llarp::LogInfo("connecting to ", abs(want - wanted), " out of ", wanted, " random routers"); } bool llarp_router::ReloadConfig(__attribute__((unused)) const llarp_config *conf) { // TODO: implement me return true; } bool llarp_router::InitOutboundLink() { if(outboundLink) return true; auto link = llarp::utp::NewServer(this); if(!link->EnsureKeys(transport_keyfile.string().c_str())) { llarp::LogError("failed to load ", transport_keyfile); return false; } auto afs = {AF_INET, AF_INET6}; for(auto af : afs) { if(link->Configure(netloop, "*", af, 0)) { outboundLink = std::move(link); llarp::LogInfo("outbound link ready"); return true; } } return false; } bool llarp_router::CreateDefaultHiddenService() { // fallback defaults static const std::unordered_map< std::string, std::function< std::string(void) > > netConfigDefaults = { {"ifname", llarp::findFreeLokiTunIfName}, {"ifaddr", llarp::findFreePrivateRange}, {"local-dns", []() -> std::string { return "127.0.0.1:53"; }}, {"upstream-dns", []() -> std::string { return "1.1.1.1:53"; }}}; // populate with fallback defaults if values not present auto itr = netConfigDefaults.begin(); while(itr != netConfigDefaults.end()) { if(netConfig.count(itr->first) == 0) { netConfig.emplace(std::make_pair(itr->first, itr->second())); } ++itr; } // add endpoint return hiddenServiceContext.AddDefaultEndpoint(netConfig); } bool llarp_router::HasPendingConnectJob(const llarp::RouterID &remote) { return pendingEstablishJobs.find(remote) != pendingEstablishJobs.end(); } struct llarp_router * llarp_init_router(struct llarp_threadpool *tp, struct llarp_ev_loop *netloop, struct llarp_logic *logic) { llarp_router *router = new llarp_router(); if(router) { router->netloop = netloop; router->tp = tp; router->logic = logic; // TODO: make disk io threadpool count configurable (?) #ifdef TESTNET router->disk = tp; #else router->disk = llarp_init_threadpool(1, "llarp-diskio"); #endif llarp_crypto_init(&router->crypto); } return router; } bool llarp_configure_router(struct llarp_router *router, struct llarp_config *conf) { llarp_config_iterator iter; iter.user = router; iter.visit = llarp::router_iter_config; llarp_config_iter(conf, &iter); if(!router->InitOutboundLink()) return false; if(!router->Ready()) { return false; } return router->EnsureIdentity(); } bool llarp_run_router(struct llarp_router *router, struct llarp_nodedb *nodedb) { router->nodedb = nodedb; return router->Run(); } void llarp_stop_router(struct llarp_router *router) { if(router) { router->Close(); router->routerProfiling.Save(router->routerProfilesFile.c_str()); } } void llarp_free_router(struct llarp_router **router) { if(*router) { delete *router; } *router = nullptr; } bool llarp_findOrCreateIdentity(llarp_crypto *crypto, const char *fpath, byte_t *secretkey) { llarp::LogDebug("find or create ", fpath); fs::path path(fpath); std::error_code ec; if(!fs::exists(path, ec)) { llarp::LogInfo("generating new identity key"); crypto->identity_keygen(secretkey); std::ofstream f(path.string(), std::ios::binary); if(f.is_open()) { f.write((char *)secretkey, SECKEYSIZE); } } std::ifstream f(path.string(), std::ios::binary); if(f.is_open()) { f.read((char *)secretkey, SECKEYSIZE); return true; } llarp::LogInfo("failed to get identity key"); return false; } // C++ ... bool llarp_findOrCreateEncryption(llarp_crypto *crypto, const char *fpath, llarp::SecretKey &encryption) { llarp::LogDebug("find or create ", fpath); fs::path path(fpath); std::error_code ec; if(!fs::exists(path, ec)) { llarp::LogInfo("generating new encryption key"); crypto->encryption_keygen(encryption); std::ofstream f(path.string(), std::ios::binary); if(f.is_open()) { f.write((char *)encryption.data(), SECKEYSIZE); } } std::ifstream f(path.string(), std::ios::binary); if(f.is_open()) { f.read((char *)encryption.data(), SECKEYSIZE); return true; } llarp::LogInfo("failed to get encryption key"); return false; } bool llarp_router::LoadHiddenServiceConfig(const char *fname) { llarp::LogDebug("opening hidden service config ", fname); llarp::service::Config conf; if(!conf.Load(fname)) return false; for(const auto &config : conf.services) { llarp::service::Config::section_t filteredConfig; mergeHiddenServiceConfig(config.second, filteredConfig.second); filteredConfig.first = config.first; if(!hiddenServiceContext.AddEndpoint(filteredConfig)) return false; } return true; } namespace llarp { void router_iter_config(llarp_config_iterator *iter, const char *section, const char *key, const char *val) { llarp::LogDebug(section, " ", key, "=", val); llarp_router *self = static_cast< llarp_router * >(iter->user); int af; uint16_t proto; if(StrEq(val, "eth")) { #ifdef AF_LINK af = AF_LINK; #endif #ifdef AF_PACKET af = AF_PACKET; #endif proto = LLARP_ETH_PROTO; } else { // try IPv4 first af = AF_INET; proto = std::atoi(val); } if(StrEq(section, "bind")) { if(!StrEq(key, "*")) { auto server = llarp::utp::NewServer(self); if(!server->EnsureKeys(self->transport_keyfile.string().c_str())) { llarp::LogError("failed to ensure keyfile ", self->transport_keyfile); return; } if(server->Configure(self->netloop, key, af, proto)) { self->AddInboundLink(server); return; } if(af == AF_INET6) { // we failed to configure IPv6 // try IPv4 llarp::LogInfo("link ", key, " failed to configure IPv6, trying IPv4"); af = AF_INET; if(server->Configure(self->netloop, key, af, proto)) { self->AddInboundLink(server); return; } } llarp::LogError("Failed to set up curvecp link"); } } else if(StrEq(section, "network")) { if(StrEq(key, "profiles")) { self->routerProfilesFile = val; self->routerProfiling.Load(val); llarp::LogInfo("setting profiles to ", self->routerProfilesFile); } else if(StrEq(key, "strict-connect")) { if(self->IsServiceNode()) { llarp::LogError("cannot use strict-connect option as service node"); return; } llarp::PubKey pk; if(llarp::HexDecode(val, pk.data(), pk.size())) { if(self->strictConnectPubkeys.insert(pk).second) llarp::LogInfo("added ", pk, " to strict connect list"); else llarp::LogWarn("duplicate key for strict connect: ", pk); } else llarp::LogError("invalid key for strict-connect: ", val); } else { self->netConfig.insert(std::make_pair(key, val)); } } else if(StrEq(section, "api")) { if(StrEq(key, "enabled")) { self->enableRPCServer = IsTrueValue(val); } if(StrEq(key, "bind")) { self->rpcBindAddr = val; } if(StrEq(key, "authkey")) { // TODO: add pubkey to whitelist } } else if(StrEq(section, "services")) { if(self->LoadHiddenServiceConfig(val)) { llarp::LogInfo("loaded hidden service config for ", key); } else { llarp::LogWarn("failed to load hidden service config for ", key); } } else if(StrEq(section, "lokid")) { if(StrEq(key, "enabled")) { self->whitelistRouters = IsTrueValue(val); } if(StrEq(key, "jsonrpc")) { self->lokidRPCAddr = val; } } else if(StrEq(section, "dns")) { if(StrEq(key, "upstream")) { llarp::LogInfo("add upstream resolver ", val); self->netConfig.emplace(std::make_pair("upstream-dns", val)); } if(StrEq(key, "bind")) { llarp::LogInfo("set local dns to ", val); self->netConfig.emplace(std::make_pair("local-dns", val)); } } else if(StrEq(section, "connect") || (StrEq(section, "bootstrap") && StrEq(key, "add-node"))) { self->bootstrapRCList.emplace_back(); auto &rc = self->bootstrapRCList.back(); if(rc.Read(val) && rc.Verify(&self->crypto)) { llarp::LogInfo("Added bootstrap node ", rc.pubkey); } else { llarp::LogError("malformed rc file: ", val); self->bootstrapRCList.pop_back(); } } else if(StrEq(section, "router")) { if(StrEq(key, "nickname")) { self->_rc.SetNick(val); // set logger name here _glog.nodeName = self->rc().Nick(); } if(StrEq(key, "encryption-privkey")) { self->encryption_keyfile = val; } if(StrEq(key, "contact-file")) { self->our_rc_file = val; } if(StrEq(key, "transport-privkey")) { self->transport_keyfile = val; } if(StrEq(key, "ident-privkey")) { self->ident_keyfile = val; } if(StrEq(key, "public-address")) { llarp::LogInfo("public ip ", val, " size ", strlen(val)); if(strlen(val) < 17) { // assume IPv4 // inet_pton(AF_INET, val, &self->ip4addr.sin_addr); // struct sockaddr dest; // sockaddr *dest = (sockaddr *)&self->ip4addr; llarp::Addr a(val); llarp::LogInfo("setting public ipv4 ", a); self->addrInfo.ip = *a.addr6(); self->publicOverride = true; } // llarp::Addr a(val); } if(StrEq(key, "public-port")) { llarp::LogInfo("Setting public port ", val); int p = atoi(val); // Not needed to flip upside-down - this is done in llarp::Addr(const // AddressInfo&) self->ip4addr.sin_port = p; self->addrInfo.port = p; self->publicOverride = true; } } } // namespace llarp } // namespace llarp