From df4fd0ef5634fc2632a947242c09e91c93174728 Mon Sep 17 00:00:00 2001 From: Michael Date: Mon, 7 Jan 2019 22:15:31 +0000 Subject: [PATCH] Fix some low hanging performance issues --- llarp/dns/dns.hpp | 6 +- llarp/dns/server.hpp | 2 +- llarp/exit/endpoint.cpp | 6 +- llarp/handlers/exit.cpp | 139 ++++++++++++++++++------------------- llarp/handlers/exit.hpp | 94 +++++++++++-------------- llarp/handlers/tun.cpp | 17 ++--- llarp/handlers/tun.hpp | 5 +- llarp/nodedb.cpp | 8 +-- llarp/service/endpoint.cpp | 5 +- llarp/service/endpoint.hpp | 1 + 10 files changed, 131 insertions(+), 152 deletions(-) diff --git a/llarp/dns/dns.hpp b/llarp/dns/dns.hpp index 52c837eb0..d0f1b96e1 100644 --- a/llarp/dns/dns.hpp +++ b/llarp/dns/dns.hpp @@ -1,3 +1,5 @@ +#ifndef LLARP_DNS_DNS_HPP +#define LLARP_DNS_DNS_HPP #include #include #include @@ -17,4 +19,6 @@ namespace llarp constexpr uint16_t qClassIN = 1; } // namespace dns -} // namespace llarp \ No newline at end of file +} // namespace llarp + +#endif diff --git a/llarp/dns/server.hpp b/llarp/dns/server.hpp index da8e05c37..da7f053d4 100644 --- a/llarp/dns/server.hpp +++ b/llarp/dns/server.hpp @@ -23,7 +23,7 @@ namespace llarp /// handle a hooked message virtual bool - HandleHookedDNSMessage(Message query, + HandleHookedDNSMessage(dns::Message&& query, std::function< void(Message) > sendReply) = 0; }; diff --git a/llarp/exit/endpoint.cpp b/llarp/exit/endpoint.cpp index e41e79773..774615e84 100644 --- a/llarp/exit/endpoint.cpp +++ b/llarp/exit/endpoint.cpp @@ -78,7 +78,7 @@ namespace llarp if(!path) return true; auto lastPing = path->LastRemoteActivityAt(); - if(lastPing == 0 || ( now > lastPing && now - lastPing > timeout)) + if(lastPing == 0 || (now > lastPing && now - lastPing > timeout)) return now > m_LastActive && now - m_LastActive > timeout; else if(lastPing) return now > lastPing && now - lastPing > timeout; @@ -160,7 +160,7 @@ namespace llarp { auto& msg = queue.front(); msg.S = path->NextSeqNo(); - if(path->SendRoutingMessage(&msg, m_Parent->Router())) + if(path->SendRoutingMessage(&msg, m_Parent->GetRouter())) { m_RxRate += msg.Size(); sent = true; @@ -177,7 +177,7 @@ namespace llarp llarp::path::IHopHandler* Endpoint::GetCurrentPath() const { - auto router = m_Parent->Router(); + auto router = m_Parent->GetRouter(); return router->paths.GetByUpstream(router->pubkey(), m_CurrentPath); } } // namespace exit diff --git a/llarp/handlers/exit.cpp b/llarp/handlers/exit.cpp index ef4b0101f..d91837ad8 100644 --- a/llarp/handlers/exit.cpp +++ b/llarp/handlers/exit.cpp @@ -21,7 +21,7 @@ namespace llarp static_cast< ExitEndpoint * >(tun->user)->Flush(); } - ExitEndpoint::ExitEndpoint(const std::string &name, llarp::Router *r) + ExitEndpoint::ExitEndpoint(const std::string &name, Router *r) : m_Router(r) , m_Resolver(r->netloop, this) , m_Name(name) @@ -41,18 +41,18 @@ namespace llarp } bool - ExitEndpoint::ShouldHookDNSMessage(const llarp::dns::Message &msg) const + ExitEndpoint::ShouldHookDNSMessage(const dns::Message &msg) const { if(msg.questions.size() == 0) return false; - if(msg.questions[0].qtype == llarp::dns::qTypePTR) + if(msg.questions[0].qtype == dns::qTypePTR) { - llarp::huint32_t ip; - if(!llarp::dns::DecodePTR(msg.questions[0].qname, ip)) + huint32_t ip; + if(!dns::DecodePTR(msg.questions[0].qname, ip)) return false; return m_OurRange.Contains(ip); } - else if(msg.questions[0].qtype == llarp::dns::qTypeA) + else if(msg.questions[0].qtype == dns::qTypeA) { return msg.questions[0].qname.find(".snode.") == (msg.questions[0].qname.size() - 7); @@ -63,17 +63,16 @@ namespace llarp bool ExitEndpoint::HandleHookedDNSMessage( - llarp::dns::Message msg, - std::function< void(llarp::dns::Message) > reply) + dns::Message &&msg, std::function< void(dns::Message) > reply) { - if(msg.questions[0].qtype == llarp::dns::qTypePTR) + if(msg.questions[0].qtype == dns::qTypePTR) { - llarp::huint32_t ip; - if(!llarp::dns::DecodePTR(msg.questions[0].qname, ip)) + huint32_t ip; + if(!dns::DecodePTR(msg.questions[0].qname, ip)) return false; if(ip == m_IfAddr) { - RouterID us = Router()->pubkey(); + RouterID us = GetRouter()->pubkey(); msg.AddAReply(us.ToString(), 300); } else @@ -89,7 +88,7 @@ namespace llarp msg.AddNXReply(); } } - else if(msg.questions[0].qtype == llarp::dns::qTypeA) + else if(msg.questions[0].qtype == dns::qTypeA) { // forward dns for snode RouterID r; @@ -134,14 +133,13 @@ namespace llarp ExitEndpoint::Flush() { m_InetToNetwork.Process([&](Pkt_t &pkt) { - llarp::PubKey pk; + PubKey pk; { auto itr = m_IPToKey.find(pkt.dst()); if(itr == m_IPToKey.end()) { // drop - llarp::LogWarn(Name(), " dropping packet, has no session at ", - pkt.dst()); + LogWarn(Name(), " dropping packet, has no session at ", pkt.dst()); return; } pk = itr->second; @@ -155,25 +153,24 @@ namespace llarp auto itr = m_SNodeSessions.find(pk); if(itr != m_SNodeSessions.end()) { - if(itr->second->QueueUpstreamTraffic(pkt, - llarp::routing::ExitPadSize)) + if(itr->second->QueueUpstreamTraffic(pkt, routing::ExitPadSize)) return; } } - llarp::exit::Endpoint *ep = m_ChosenExits[pk]; + exit::Endpoint *ep = m_ChosenExits[pk]; if(ep == nullptr) { // we may have all dead sessions, wtf now? - llarp::LogWarn(Name(), " dropped inbound traffic for session ", pk, - " as we have no working endpoints"); + LogWarn(Name(), " dropped inbound traffic for session ", pk, + " as we have no working endpoints"); } else { if(!ep->QueueInboundTraffic(pkt.Buffer())) { - llarp::LogWarn(Name(), " dropped inbound traffic for session ", pk, - " as we are overloaded (probably)"); + LogWarn(Name(), " dropped inbound traffic for session ", pk, + " as we are overloaded (probably)"); } } }); @@ -183,8 +180,7 @@ namespace llarp { if(!itr->second->Flush()) { - llarp::LogWarn("exit session with ", itr->first, - " dropped packets"); + LogWarn("exit session with ", itr->first, " dropped packets"); } ++itr; } @@ -195,8 +191,8 @@ namespace llarp { if(!itr->second->Flush()) { - llarp::LogWarn("failed to flush snode traffic to ", itr->first, - " via outbound session"); + LogWarn("failed to flush snode traffic to ", itr->first, + " via outbound session"); } ++itr; } @@ -208,7 +204,7 @@ namespace llarp { if(m_ShouldInitTun) { - if(!llarp_ev_add_tun(Router()->netloop, &m_Tun)) + if(!llarp_ev_add_tun(GetRouter()->netloop, &m_Tun)) return false; if(m_UpstreamResolvers.size() == 0) m_UpstreamResolvers.emplace_back("8.8.8.8", 53); @@ -217,13 +213,13 @@ namespace llarp return true; } - llarp::Router * - ExitEndpoint::Router() + Router * + ExitEndpoint::GetRouter() { return m_Router; } - llarp::Crypto * + Crypto * ExitEndpoint::Crypto() { return &m_Router->crypto; @@ -253,13 +249,13 @@ namespace llarp } bool - ExitEndpoint::HasLocalMappedAddrFor(const llarp::PubKey &pk) const + ExitEndpoint::HasLocalMappedAddrFor(const PubKey &pk) const { return m_KeyToIP.find(pk) != m_KeyToIP.end(); } huint32_t - ExitEndpoint::GetIPForIdent(const llarp::PubKey pk) + ExitEndpoint::GetIPForIdent(const PubKey pk) { huint32_t found = {0}; if(!HasLocalMappedAddrFor(pk)) @@ -268,18 +264,18 @@ namespace llarp found.h = AllocateNewAddress().h; if(!m_KeyToIP.emplace(pk, found).second) { - llarp::LogError(Name(), "failed to map ", pk, " to ", found); + LogError(Name(), "failed to map ", pk, " to ", found); return found; } if(!m_IPToKey.emplace(found, pk).second) { - llarp::LogError(Name(), "failed to map ", found, " to ", pk); + LogError(Name(), "failed to map ", found, " to ", pk); return found; } if(HasLocalMappedAddrFor(pk)) - llarp::LogInfo(Name(), " mapping ", pk, " to ", found); + LogInfo(Name(), " mapping ", pk, " to ", found); else - llarp::LogError(Name(), "failed to map ", pk, " to ", found); + LogError(Name(), "failed to map ", pk, " to ", found); } else found.h = m_KeyToIP[pk].h; @@ -311,7 +307,7 @@ namespace llarp } // kick old ident off exit // TODO: DoS - llarp::PubKey pk = m_IPToKey[found]; + PubKey pk = m_IPToKey[found]; KickIdentOffExit(pk); return found; @@ -324,9 +320,9 @@ namespace llarp } void - ExitEndpoint::KickIdentOffExit(const llarp::PubKey &pk) + ExitEndpoint::KickIdentOffExit(const PubKey &pk) { - llarp::LogInfo(Name(), " kicking ", pk, " off exit"); + LogInfo(Name(), " kicking ", pk, " off exit"); huint32_t ip = m_KeyToIP[pk]; m_KeyToIP.erase(pk); m_IPToKey.erase(ip); @@ -337,9 +333,9 @@ namespace llarp } void - ExitEndpoint::MarkIPActive(llarp::huint32_t ip) + ExitEndpoint::MarkIPActive(huint32_t ip) { - m_IPActivity[ip] = Router()->Now(); + m_IPActivity[ip] = GetRouter()->Now(); } void @@ -350,9 +346,9 @@ namespace llarp } bool - ExitEndpoint::QueueSNodePacket(llarp_buffer_t buf, llarp::huint32_t from) + ExitEndpoint::QueueSNodePacket(llarp_buffer_t buf, huint32_t from) { - llarp::net::IPv4Packet pkt; + net::IPv4Packet pkt; if(!pkt.Load(buf)) return false; // rewrite ip @@ -360,11 +356,11 @@ namespace llarp return llarp_ev_tun_async_write(&m_Tun, pkt.Buffer()); } - llarp::exit::Endpoint * - ExitEndpoint::FindEndpointByPath(const llarp::PathID_t &path) + exit::Endpoint * + ExitEndpoint::FindEndpointByPath(const PathID_t &path) { - llarp::exit::Endpoint *endpoint = nullptr; - llarp::PubKey pk; + exit::Endpoint *endpoint = nullptr; + PubKey pk; { auto itr = m_Paths.find(path); if(itr == m_Paths.end()) @@ -383,8 +379,7 @@ namespace llarp } bool - ExitEndpoint::UpdateEndpointPath(const llarp::PubKey &remote, - const llarp::PathID_t &next) + ExitEndpoint::UpdateEndpointPath(const PubKey &remote, const PathID_t &next) { // check if already mapped auto itr = m_Paths.find(next); @@ -417,8 +412,8 @@ namespace llarp resolverAddr = v.substr(0, pos); dnsport = std::atoi(v.substr(pos + 1).c_str()); } - m_LocalResolverAddr = llarp::Addr(resolverAddr, dnsport); - llarp::LogInfo(Name(), " local dns set to ", m_LocalResolverAddr); + m_LocalResolverAddr = Addr(resolverAddr, dnsport); + LogInfo(Name(), " local dns set to ", m_LocalResolverAddr); } if(k == "upstream-dns") { @@ -431,15 +426,15 @@ namespace llarp dnsport = std::atoi(v.substr(pos + 1).c_str()); } m_UpstreamResolvers.emplace_back(resolverAddr, dnsport); - llarp::LogInfo(Name(), " adding upstream dns set to ", resolverAddr, - ":", dnsport); + LogInfo(Name(), " adding upstream dns set to ", resolverAddr, ":", + dnsport); } if(k == "ifaddr") { auto pos = v.find("/"); if(pos == std::string::npos) { - llarp::LogError(Name(), " ifaddr is not a cidr: ", v); + LogError(Name(), " ifaddr is not a cidr: ", v); return false; } std::string nmask_str = v.substr(1 + pos); @@ -448,24 +443,24 @@ namespace llarp strncpy(m_Tun.ifaddr, host_str.c_str(), sizeof(m_Tun.ifaddr) - 1); m_Tun.netmask = std::atoi(nmask_str.c_str()); - llarp::Addr ifaddr(host_str); + Addr ifaddr(host_str); m_IfAddr = ifaddr.xtohl(); m_OurRange.netmask_bits = netmask_ipv4_bits(m_Tun.netmask); m_OurRange.addr = m_IfAddr; m_NextAddr = m_IfAddr; m_HigestAddr = m_IfAddr | (~m_OurRange.netmask_bits); - llarp::LogInfo(Name(), " set ifaddr range to ", m_Tun.ifaddr, "/", - m_Tun.netmask, " lo=", m_IfAddr, " hi=", m_HigestAddr); + LogInfo(Name(), " set ifaddr range to ", m_Tun.ifaddr, "/", + m_Tun.netmask, " lo=", m_IfAddr, " hi=", m_HigestAddr); } if(k == "ifname") { if(v.length() >= sizeof(m_Tun.ifname)) { - llarp::LogError(Name() + " ifname '", v, "' is too long"); + LogError(Name() + " ifname '", v, "' is too long"); return false; } strncpy(m_Tun.ifname, v.c_str(), sizeof(m_Tun.ifname) - 1); - llarp::LogInfo(Name(), " set ifname to ", m_Tun.ifname); + LogInfo(Name(), " set ifname to ", m_Tun.ifname); } if(k == "exit-whitelist") { @@ -484,7 +479,7 @@ namespace llarp } huint32_t - ExitEndpoint::ObtainServiceNodeIP(const llarp::RouterID &other) + ExitEndpoint::ObtainServiceNodeIP(const RouterID &other) { PubKey pubKey(other); huint32_t ip = GetIPForIdent(pubKey); @@ -493,32 +488,30 @@ namespace llarp // this is a new service node make an outbound session to them m_SNodeSessions.emplace( other, - std::unique_ptr< llarp::exit::SNodeSession >( - new llarp::exit::SNodeSession( - other, - std::bind(&ExitEndpoint::QueueSNodePacket, this, - std::placeholders::_1, ip), - Router(), 2, 1, true))); + std::unique_ptr< exit::SNodeSession >(new exit::SNodeSession( + other, + std::bind(&ExitEndpoint::QueueSNodePacket, this, + std::placeholders::_1, ip), + GetRouter(), 2, 1, true))); } return ip; } bool - ExitEndpoint::AllocateNewExit(const llarp::PubKey pk, - const llarp::PathID_t &path, + ExitEndpoint::AllocateNewExit(const PubKey pk, const PathID_t &path, bool wantInternet) { if(wantInternet && !m_PermitExit) return false; huint32_t ip = GetIPForIdent(pk); - if(Router()->paths.TransitHopPreviousIsRouter(path, pk.as_array())) + if(GetRouter()->paths.TransitHopPreviousIsRouter(path, pk.as_array())) { // we think this path belongs to a service node // mark it as such so we don't make an outbound session to them m_SNodeKeys.emplace(pk.as_array()); } m_ActiveExits.emplace(pk, - std::make_unique< llarp::exit::Endpoint >( + std::make_unique< exit::Endpoint >( pk, path, !wantInternet, ip, this)); m_Paths[path] = pk; @@ -532,13 +525,13 @@ namespace llarp } void - ExitEndpoint::DelEndpointInfo(const llarp::PathID_t &path) + ExitEndpoint::DelEndpointInfo(const PathID_t &path) { m_Paths.erase(path); } void - ExitEndpoint::RemoveExit(const llarp::exit::Endpoint *ep) + ExitEndpoint::RemoveExit(const exit::Endpoint *ep) { auto range = m_ActiveExits.equal_range(ep->PubKey()); auto itr = range.first; diff --git a/llarp/handlers/exit.hpp b/llarp/handlers/exit.hpp index 319878b01..448c6c09c 100644 --- a/llarp/handlers/exit.hpp +++ b/llarp/handlers/exit.hpp @@ -8,11 +8,12 @@ namespace llarp { + struct Router; namespace handlers { - struct ExitEndpoint : public llarp::dns::IQueryHandler + struct ExitEndpoint : public dns::IQueryHandler { - ExitEndpoint(const std::string& name, llarp::Router* r); + ExitEndpoint(const std::string& name, Router* r); ~ExitEndpoint(); void @@ -25,38 +26,36 @@ namespace llarp Name() const; bool - ShouldHookDNSMessage(const llarp::dns::Message& msg) const override; + ShouldHookDNSMessage(const dns::Message& msg) const override; bool - HandleHookedDNSMessage( - llarp::dns::Message, - std::function< void(llarp::dns::Message) >) override; + HandleHookedDNSMessage(dns::Message&& msg, + std::function< void(dns::Message) >) override; bool - AllocateNewExit(const llarp::PubKey pk, const llarp::PathID_t& path, + AllocateNewExit(const PubKey pk, const PathID_t& path, bool permitInternet); - llarp::exit::Endpoint* - FindEndpointByPath(const llarp::PathID_t& path); + exit::Endpoint* + FindEndpointByPath(const PathID_t& path); - llarp::exit::Endpoint* + exit::Endpoint* FindEndpointByIP(huint32_t ip); bool - UpdateEndpointPath(const llarp::PubKey& remote, - const llarp::PathID_t& next); + UpdateEndpointPath(const PubKey& remote, const PathID_t& next); /// handle ip packet from outside void OnInetPacket(llarp_buffer_t buf); - llarp::Router* - Router(); + Router* + GetRouter(); llarp_time_t Now() const; - llarp::Crypto* + Crypto* Crypto(); template < typename Stats > @@ -74,11 +73,11 @@ namespace llarp /// DO NOT CALL ME void - DelEndpointInfo(const llarp::PathID_t& path); + DelEndpointInfo(const PathID_t& path); /// DO NOT CALL ME void - RemoveExit(const llarp::exit::Endpoint* ep); + RemoveExit(const exit::Endpoint* ep); bool QueueOutboundTraffic(llarp_buffer_t buf); @@ -94,7 +93,7 @@ namespace llarp ShouldRemove() const; bool - HasLocalMappedAddrFor(const llarp::PubKey& pk) const; + HasLocalMappedAddrFor(const PubKey& pk) const; huint32_t GetIfAddr() const; @@ -104,7 +103,7 @@ namespace llarp private: huint32_t - GetIPForIdent(const llarp::PubKey pk); + GetIPForIdent(const PubKey pk); huint32_t AllocateNewAddress(); @@ -112,75 +111,64 @@ namespace llarp /// obtain ip for service node session, creates a new session if one does /// not existing already huint32_t - ObtainServiceNodeIP(const llarp::RouterID& router); + ObtainServiceNodeIP(const RouterID& router); bool - QueueSNodePacket(llarp_buffer_t buf, llarp::huint32_t from); + QueueSNodePacket(llarp_buffer_t buf, huint32_t from); void - MarkIPActive(llarp::huint32_t ip); + MarkIPActive(huint32_t ip); void - KickIdentOffExit(const llarp::PubKey& pk); + KickIdentOffExit(const PubKey& pk); - llarp::Router* m_Router; - llarp::dns::Proxy m_Resolver; + Router* m_Router; + dns::Proxy m_Resolver; bool m_ShouldInitTun; std::string m_Name; bool m_PermitExit; - std::unordered_map< llarp::PathID_t, llarp::PubKey, - llarp::PathID_t::Hash > - m_Paths; + std::unordered_map< PathID_t, PubKey, PathID_t::Hash > m_Paths; - std::unordered_map< llarp::PubKey, llarp::exit::Endpoint*, - llarp::PubKey::Hash > - m_ChosenExits; + std::unordered_map< PubKey, exit::Endpoint*, PubKey::Hash > m_ChosenExits; - std::unordered_multimap< llarp::PubKey, - std::unique_ptr< llarp::exit::Endpoint >, - llarp::PubKey::Hash > + std::unordered_multimap< PubKey, std::unique_ptr< exit::Endpoint >, + PubKey::Hash > m_ActiveExits; - using KeyMap_t = std::unordered_map< llarp::PubKey, llarp::huint32_t, - llarp::PubKey::Hash >; + using KeyMap_t = std::unordered_map< PubKey, huint32_t, PubKey::Hash >; KeyMap_t m_KeyToIP; - using SNodes_t = std::set< llarp::PubKey >; + using SNodes_t = std::set< PubKey >; /// set of pubkeys we treat as snodes SNodes_t m_SNodeKeys; using SNodeSessions_t = - std::unordered_map< llarp::RouterID, - std::unique_ptr< llarp::exit::SNodeSession >, - llarp::RouterID::Hash >; + std::unordered_map< RouterID, std::unique_ptr< exit::SNodeSession >, + RouterID::Hash >; /// snode sessions we are talking to directly SNodeSessions_t m_SNodeSessions; - std::unordered_map< llarp::huint32_t, llarp::PubKey, - llarp::huint32_t::Hash > - m_IPToKey; + std::unordered_map< huint32_t, PubKey, huint32_t::Hash > m_IPToKey; huint32_t m_IfAddr; huint32_t m_HigestAddr; huint32_t m_NextAddr; - llarp::IPRange m_OurRange; + IPRange m_OurRange; - std::unordered_map< llarp::huint32_t, llarp_time_t, - llarp::huint32_t::Hash > + std::unordered_map< huint32_t, llarp_time_t, huint32_t::Hash > m_IPActivity; llarp_tun_io m_Tun; - llarp::Addr m_LocalResolverAddr; - std::vector< llarp::Addr > m_UpstreamResolvers; + Addr m_LocalResolverAddr; + std::vector< Addr > m_UpstreamResolvers; - using Pkt_t = llarp::net::IPv4Packet; + using Pkt_t = net::IPv4Packet; using PacketQueue_t = - llarp::util::CoDelQueue< Pkt_t, Pkt_t::GetTime, Pkt_t::PutTime, - Pkt_t::CompareOrder, Pkt_t::GetNow, - llarp::util::DummyMutex, - llarp::util::DummyLock, 5, 100, 1024 >; + util::CoDelQueue< Pkt_t, Pkt_t::GetTime, Pkt_t::PutTime, + Pkt_t::CompareOrder, Pkt_t::GetNow, + util::DummyMutex, util::DummyLock, 5, 100, 1024 >; /// internet to llarp packet queue PacketQueue_t m_InetToNetwork; diff --git a/llarp/handlers/tun.cpp b/llarp/handlers/tun.cpp index 69525d6b3..68de4d3f3 100644 --- a/llarp/handlers/tun.cpp +++ b/llarp/handlers/tun.cpp @@ -194,7 +194,7 @@ namespace llarp bool TunEndpoint::HandleHookedDNSMessage( - dns::Message msg, std::function< void(dns::Message) > reply) + dns::Message &&msg, std::function< void(dns::Message) > reply) { if(msg.questions.size() != 1) { @@ -232,12 +232,13 @@ namespace llarp msg.AddINReply(ip); } else - return EnsurePathToService( - addr, - std::bind(&TunEndpoint::SendDNSReply, this, - std::placeholders::_1, std::placeholders::_2, msg, - reply), - 2000); + { + service::Endpoint::PathEnsureHook hook = [&](service::Address addr, + OutboundContext *ctx) { + this->SendDNSReply(addr, ctx, std::move(msg), reply); + }; + return EnsurePathToService(addr, hook, 2000); + } } else if(addr.FromString(qname, ".snode")) { @@ -320,7 +321,7 @@ namespace llarp void TunEndpoint::SendDNSReply(service::Address addr, service::Endpoint::OutboundContext *ctx, - dns::Message request, + dns::Message &&request, std::function< void(dns::Message) > reply) { if(ctx) diff --git a/llarp/handlers/tun.hpp b/llarp/handlers/tun.hpp index 64b24f56a..d531dbf9d 100644 --- a/llarp/handlers/tun.hpp +++ b/llarp/handlers/tun.hpp @@ -34,7 +34,7 @@ namespace llarp bool HandleHookedDNSMessage( - dns::Message query, + dns::Message&& query, std::function< void(dns::Message) > sendreply) override; void @@ -181,7 +181,8 @@ namespace llarp void SendDNSReply(service::Address addr, - service::Endpoint::OutboundContext* ctx, dns::Message query, + service::Endpoint::OutboundContext* ctx, + dns::Message&& query, std::function< void(dns::Message) > reply); #ifndef WIN32 diff --git a/llarp/nodedb.cpp b/llarp/nodedb.cpp index 0f991bed4..6bb622d47 100644 --- a/llarp/nodedb.cpp +++ b/llarp/nodedb.cpp @@ -423,7 +423,7 @@ llarp_nodedb::select_random_hop(const llarp::RouterContact &prev, { /// checking for "guard" status for N = 0 is done by caller inside of /// pathbuilder's scope - auto sz = entries.size(); + size_t sz = entries.size(); if(sz < 3) return false; size_t tries = 5; @@ -433,12 +433,6 @@ llarp_nodedb::select_random_hop(const llarp::RouterContact &prev, do { auto itr = entries.begin(); - if(sz > 1) - { - auto idx = llarp::randint() % sz; - if(idx) - std::advance(itr, idx - 1); - } if(prev.pubkey == itr->second.pubkey) { if(tries--) diff --git a/llarp/service/endpoint.cpp b/llarp/service/endpoint.cpp index 5964bb2b5..b633ea32d 100644 --- a/llarp/service/endpoint.cpp +++ b/llarp/service/endpoint.cpp @@ -917,11 +917,8 @@ namespace llarp bool Endpoint::CheckPathIsDead(__attribute__((unused)) path::Path* p, - llarp_time_t latency) + __attribute__((unused)) llarp_time_t latency) { - if(latency >= m_MinPathLatency) - { - } return false; } diff --git a/llarp/service/endpoint.hpp b/llarp/service/endpoint.hpp index fbe8ad6bc..eaaa00e4c 100644 --- a/llarp/service/endpoint.hpp +++ b/llarp/service/endpoint.hpp @@ -7,6 +7,7 @@ #include #include #include +#include #include #include #include