diff --git a/include/llarp.h b/include/llarp.h index 2db8b4808..53f097f74 100644 --- a/include/llarp.h +++ b/include/llarp.h @@ -37,7 +37,7 @@ extern "C" /// give main context a vpn file descriptor (android/ios) void - llarp_main_inject_vpn_fd(struct llarp_main * m, int fd); + llarp_main_inject_vpn_fd(struct llarp_main *m, int fd); /// setup main context int diff --git a/include/llarp.hpp b/include/llarp.hpp index e2b286d23..82119a3c5 100644 --- a/include/llarp.hpp +++ b/include/llarp.hpp @@ -16,7 +16,6 @@ namespace llarp int num_nethreads = 1; bool singleThreaded = false; - std::vector< std::thread > netio_threads; llarp_crypto crypto; llarp_router *router = nullptr; llarp_threadpool *worker = nullptr; diff --git a/include/llarp/dht/context.hpp b/include/llarp/dht/context.hpp index 90c2c4c88..62b331484 100644 --- a/include/llarp/dht/context.hpp +++ b/include/llarp/dht/context.hpp @@ -407,11 +407,10 @@ namespace llarp llarp_time_t Now(); - void ExploreNetworkVia(const Key_t& peer); - private: + private: void ScheduleCleanupTimer(); diff --git a/include/llarp/dns.hpp b/include/llarp/dns.hpp index 6a81acc00..663d74bed 100644 --- a/include/llarp/dns.hpp +++ b/include/llarp/dns.hpp @@ -49,7 +49,7 @@ struct dns_tracker struct dns_msg_header { uint16_t id; - + uint8_t qr : 1; uint8_t opcode : 4; uint8_t aa : 1; @@ -62,12 +62,13 @@ struct dns_msg_header uint8_t cd : 1; uint8_t rcode : 4; - uint16_t fields() const + uint16_t + fields() const { - return (qr << 15) | (opcode << 14) | (aa << 10) | (tc << 9) | (rd << 8) << (ra << 7) | (z << 6) | rcode; + return (qr << 15) | (opcode << 14) | (aa << 10) | (tc << 9) + | (rd << 8) << (ra << 7) | (z << 6) | rcode; } - uint16_t qdCount; uint16_t anCount; uint16_t nsCount; @@ -128,7 +129,7 @@ extern "C" get32bits(const char *&buffer) throw(); bool - decode_hdr(llarp_buffer_t * buffer, dns_msg_header * hdr); + decode_hdr(llarp_buffer_t *buffer, dns_msg_header *hdr); dns_msg_question * decode_question(const char *buffer, uint32_t *pos); diff --git a/include/llarp/dns_dotlokilookup.hpp b/include/llarp/dns_dotlokilookup.hpp index 7782b108a..cef0cb9e2 100644 --- a/include/llarp/dns_dotlokilookup.hpp +++ b/include/llarp/dns_dotlokilookup.hpp @@ -6,7 +6,7 @@ #include "dnsd.hpp" using map_address_hook_func = - std::function< bool(const byte_t* addr,bool isSNode, uint32_t ip) >; + std::function< bool(const byte_t *addr, bool isSNode, uint32_t ip) >; /// dotLokiLookup context/config struct dotLokiLookup @@ -35,6 +35,6 @@ struct dotLokiLookup dnsd_query_hook_response * llarp_dotlokilookup_handler(std::string name, - const dnsd_question_request * request); + const dnsd_question_request *request); #endif diff --git a/include/llarp/dnsd.hpp b/include/llarp/dnsd.hpp index 0e653c139..c2157174a 100644 --- a/include/llarp/dnsd.hpp +++ b/include/llarp/dnsd.hpp @@ -68,7 +68,8 @@ write404_dnss_response(const dnsd_question_request *request); /// for hook functions to use void -writecname_dnss_response(std::string cname, const dnsd_question_request *request); +writecname_dnss_response(std::string cname, + const dnsd_question_request *request); // FIXME: llarp::Addr /// send an A record found response @@ -79,7 +80,8 @@ writesend_dnss_response(llarp::huint32_t *hostRes, /// send an PTR record found response void -writesend_dnss_revresponse(std::string reverse, const dnsd_question_request *request); +writesend_dnss_revresponse(std::string reverse, + const dnsd_question_request *request); // FIXME: llarp::Addr // diff --git a/include/llarp/ev.h b/include/llarp/ev.h index f56c88a0d..910c6e939 100644 --- a/include/llarp/ev.h +++ b/include/llarp/ev.h @@ -167,13 +167,11 @@ llarp_tcp_acceptor_close(struct llarp_tcp_acceptor *); #define IFNAMSIZ (16) #endif - struct llarp_fd_promise; /// wait until the fd promise is set int -llarp_fd_promise_wait_for_value(struct llarp_fd_promise * promise); - +llarp_fd_promise_wait_for_value(struct llarp_fd_promise *promise); struct llarp_tun_io { @@ -185,9 +183,9 @@ struct llarp_tun_io void *user; void *impl; - /// functor for getting a promise that returns the vpn fd + /// functor for getting a promise that returns the vpn fd /// dont set me if you don't know how to use this - struct llarp_fd_promise * (*get_fd_promise)(struct llarp_tun_io *); + struct llarp_fd_promise *(*get_fd_promise)(struct llarp_tun_io *); struct llarp_ev_loop *parent; /// called when we are able to write right before we write @@ -203,7 +201,6 @@ struct llarp_tun_io bool llarp_ev_add_tun(struct llarp_ev_loop *ev, struct llarp_tun_io *tun); - /// async write a packet on tun interface /// returns true if queued, returns false on drop bool diff --git a/include/llarp/exit/endpoint.hpp b/include/llarp/exit/endpoint.hpp index ad0a54cac..2a7e4a392 100644 --- a/include/llarp/exit/endpoint.hpp +++ b/include/llarp/exit/endpoint.hpp @@ -39,7 +39,7 @@ namespace llarp ExpiresSoon(llarp_time_t now, llarp_time_t dlt = 5000) const; /// return true if this endpoint looks dead right now - bool + bool LooksDead(llarp_time_t now, llarp_time_t timeout = 10000) const; /// tick ourself, reset tx/rx rates @@ -105,27 +105,30 @@ namespace llarp uint64_t m_TxRate, m_RxRate; llarp_time_t m_LastActive; bool m_RewriteSource; - using InboundTrafficQueue_t = std::deque; - using TieredQueue = std::map; + using InboundTrafficQueue_t = + std::deque< llarp::routing::TransferTrafficMessage >; + using TieredQueue = std::map< uint8_t, InboundTrafficQueue_t >; // maps number of fragments the message will fit in to the queue for it TieredQueue m_DownstreamQueues; struct UpstreamBuffer { - UpstreamBuffer(const llarp::net::IPv4Packet & p, uint64_t c) : pkt(p), counter(c) + UpstreamBuffer(const llarp::net::IPv4Packet& p, uint64_t c) + : pkt(p), counter(c) { } llarp::net::IPv4Packet pkt; uint64_t counter; - bool operator<(const UpstreamBuffer & other) const + bool + operator<(const UpstreamBuffer& other) const { return counter < other.counter; } }; - using UpstreamQueue_t = std::priority_queue; + using UpstreamQueue_t = std::priority_queue< UpstreamBuffer >; UpstreamQueue_t m_UpstreamQueue; uint64_t m_Counter; }; diff --git a/include/llarp/exit/session.hpp b/include/llarp/exit/session.hpp index 43b35dfb4..764f4c118 100644 --- a/include/llarp/exit/session.hpp +++ b/include/llarp/exit/session.hpp @@ -10,7 +10,6 @@ namespace llarp { namespace exit { - /// a persisiting exit session with an exit router struct BaseSession : public llarp::path::Builder { @@ -38,16 +37,15 @@ namespace llarp bool FlushUpstreamTraffic(); - bool + bool IsReady() const; - protected: llarp::RouterID m_ExitRouter; std::function< bool(llarp_buffer_t) > m_WritePacket; - - virtual void - PopulateRequest(llarp::routing::ObtainExitMessage & msg) const = 0; + + virtual void + PopulateRequest(llarp::routing::ObtainExitMessage& msg) const = 0; bool HandleTrafficDrop(llarp::path::Path* p, const llarp::PathID_t& path, @@ -59,9 +57,10 @@ namespace llarp bool HandleTraffic(llarp::path::Path* p, llarp_buffer_t buf); - private: - using UpstreamTrafficQueue_t = std::deque; - using TieredQueue_t = std::map; + private: + using UpstreamTrafficQueue_t = + std::deque< llarp::routing::TransferTrafficMessage >; + using TieredQueue_t = std::map< uint8_t, UpstreamTrafficQueue_t >; TieredQueue_t m_Upstream; uint64_t m_Counter; llarp::SecretKey m_ExitIdentity; @@ -70,14 +69,15 @@ namespace llarp struct ExitSession final : public BaseSession { ExitSession(const llarp::RouterID& snodeRouter, - std::function< bool(llarp_buffer_t) > writepkt, - llarp_router* r, size_t numpaths, size_t hoplen) : BaseSession(snodeRouter, writepkt, r,numpaths, hoplen) {}; - - ~ExitSession() {}; - - protected: - virtual void - PopulateRequest(llarp::routing::ObtainExitMessage & msg) const override + std::function< bool(llarp_buffer_t) > writepkt, + llarp_router* r, size_t numpaths, size_t hoplen) + : BaseSession(snodeRouter, writepkt, r, numpaths, hoplen){}; + + ~ExitSession(){}; + + protected: + virtual void + PopulateRequest(llarp::routing::ObtainExitMessage& msg) const override { // TODO: set expiration time msg.X = 0; @@ -88,14 +88,15 @@ namespace llarp struct SNodeSession final : public BaseSession { SNodeSession(const llarp::RouterID& snodeRouter, - std::function< bool(llarp_buffer_t) > writepkt, - llarp_router* r, size_t numpaths, size_t hoplen) : BaseSession(snodeRouter, writepkt, r,numpaths, hoplen) {}; + std::function< bool(llarp_buffer_t) > writepkt, + llarp_router* r, size_t numpaths, size_t hoplen) + : BaseSession(snodeRouter, writepkt, r, numpaths, hoplen){}; - ~SNodeSession() {}; + ~SNodeSession(){}; - protected: - void - PopulateRequest(llarp::routing::ObtainExitMessage & msg) const override + protected: + void + PopulateRequest(llarp::routing::ObtainExitMessage& msg) const override { // TODO: set expiration time msg.X = 0; diff --git a/include/llarp/handlers/null.hpp b/include/llarp/handlers/null.hpp index 8a9b45fe6..b8b3aa4c8 100644 --- a/include/llarp/handlers/null.hpp +++ b/include/llarp/handlers/null.hpp @@ -2,30 +2,34 @@ #define LLARP_HANDLERS_NULL_HPP #include -namespace llarp +namespace llarp { - namespace handlers + namespace handlers { struct NullEndpoint final : public llarp::service::Endpoint { - NullEndpoint(const std::string & name, llarp_router *r) : llarp::service::Endpoint(name, r) {}; + NullEndpoint(const std::string &name, llarp_router *r) + : llarp::service::Endpoint(name, r){}; - bool HandleWriteIPPacket(llarp_buffer_t, std::function) override + bool HandleWriteIPPacket(llarp_buffer_t, + std::function< huint32_t(void) >) override { return true; } - huint32_t ObtainIPForAddr(const byte_t*, bool) override + huint32_t + ObtainIPForAddr(const byte_t *, bool) override { return {0}; } - - bool HasAddress(const byte_t *) const override + + bool + HasAddress(const byte_t *) const override { return false; } }; - } -} + } // namespace handlers +} // namespace llarp #endif \ No newline at end of file diff --git a/include/llarp/handlers/tun.hpp b/include/llarp/handlers/tun.hpp index a62450e89..a1a6ccdaf 100644 --- a/include/llarp/handlers/tun.hpp +++ b/include/llarp/handlers/tun.hpp @@ -13,7 +13,6 @@ namespace llarp { namespace handlers { - static const int DefaultTunNetmask = 16; static const char DefaultTunIfname[] = "lokinet0"; static const char DefaultTunDstAddr[] = "10.10.0.1"; @@ -39,7 +38,7 @@ namespace llarp bool Start(); - bool + bool IsSNode() const; /// set up tun interface, blocking @@ -53,7 +52,8 @@ namespace llarp /// overrides Endpoint /// handle inbound traffic bool - HandleWriteIPPacket(llarp_buffer_t buf, std::function getFromIP) override; + HandleWriteIPPacket(llarp_buffer_t buf, + std::function< huint32_t(void) > getFromIP) override; /// queue outbound packet to the world bool @@ -77,7 +77,7 @@ namespace llarp #endif llarp_tun_io tunif; - std::unique_ptr Promise; + std::unique_ptr< llarp_fd_promise > Promise; /// called before writing to tun interface static void @@ -155,8 +155,10 @@ namespace llarp AlignedBuffer< 32 >::Hash > m_AddrToIP; - /// maps key to true if key is a service node, maps key to false if key is a hidden service - std::unordered_map, bool, AlignedBuffer<32>::Hash> m_SNodes; + /// maps key to true if key is a service node, maps key to false if key is + /// a hidden service + std::unordered_map< AlignedBuffer< 32 >, bool, AlignedBuffer< 32 >::Hash > + m_SNodes; private: bool @@ -177,7 +179,7 @@ namespace llarp std::promise< bool > m_TunSetupResult; #endif - std::promise m_VPNPromise; + std::promise< int > m_VPNPromise; /// DNS server per tun struct dnsd_context dnsd; diff --git a/include/llarp/messages/transfer_traffic.hpp b/include/llarp/messages/transfer_traffic.hpp index c230526ac..3a18caf56 100644 --- a/include/llarp/messages/transfer_traffic.hpp +++ b/include/llarp/messages/transfer_traffic.hpp @@ -10,13 +10,14 @@ namespace llarp namespace routing { constexpr size_t ExitPadSize = 512 - 48; - constexpr size_t MaxExitMTU = 1500; + constexpr size_t MaxExitMTU = 1500; struct TransferTrafficMessage final : public IMessage { - std::vector X; + std::vector< llarp::Encrypted > X; size_t _size = 0; - size_t Size() const + size_t + Size() const { return _size; } diff --git a/include/llarp/net.hpp b/include/llarp/net.hpp index 05b5032bf..d8fb21bc1 100644 --- a/include/llarp/net.hpp +++ b/include/llarp/net.hpp @@ -254,9 +254,7 @@ namespace llarp constexpr uint32_t __netmask_ipv4_bits(uint32_t numset) { - return (32 - numset) - ? (1 << numset) | __netmask_ipv4_bits(numset + 1) - : 0; + return (32 - numset) ? (1 << numset) | __netmask_ipv4_bits(numset + 1) : 0; } /// get an ipv4 netmask given some /N range diff --git a/include/llarp/pathset.hpp b/include/llarp/pathset.hpp index dea417e28..dd9d214f5 100644 --- a/include/llarp/pathset.hpp +++ b/include/llarp/pathset.hpp @@ -190,8 +190,8 @@ namespace llarp return *i.first.data_l() ^ *i.second.data_l(); } }; - using Mtx_t = llarp::util::Mutex; - using Lock_t = llarp::util::Lock; + using Mtx_t = llarp::util::Mutex; + using Lock_t = llarp::util::Lock; using PathMap_t = std::unordered_map< PathInfo_t, Path*, PathInfoHash >; mutable Mtx_t m_PathsMutex; PathMap_t m_Paths; diff --git a/include/llarp/service/Info.hpp b/include/llarp/service/Info.hpp index 62c091c47..e31cc1eee 100644 --- a/include/llarp/service/Info.hpp +++ b/include/llarp/service/Info.hpp @@ -13,10 +13,10 @@ namespace llarp private: llarp::PubKey enckey; llarp::PubKey signkey; - + public: VanityNonce vanity; - + ServiceInfo() = default; ServiceInfo(ServiceInfo&& other) @@ -58,7 +58,8 @@ namespace llarp } bool - Update(const byte_t* enc, const byte_t* sign, const byte_t * nonce=nullptr) + Update(const byte_t* enc, const byte_t* sign, + const byte_t* nonce = nullptr) { enckey = enc; signkey = sign; diff --git a/include/llarp/service/context.hpp b/include/llarp/service/context.hpp index 58704837c..b312cce3d 100644 --- a/include/llarp/service/context.hpp +++ b/include/llarp/service/context.hpp @@ -28,7 +28,7 @@ namespace llarp getFirstEndpoint(); bool - FindBestAddressFor(const byte_t* addr, bool isSNode, huint32_t &); + FindBestAddressFor(const byte_t *addr, bool isSNode, huint32_t &); /// DRY refactor llarp::handlers::TunEndpoint * diff --git a/include/llarp/service/endpoint.hpp b/include/llarp/service/endpoint.hpp index ff78deb04..8d596dd39 100644 --- a/include/llarp/service/endpoint.hpp +++ b/include/llarp/service/endpoint.hpp @@ -128,8 +128,9 @@ namespace llarp bool HandleDataMessage(const PathID_t&, ProtocolMessage* msg); - virtual - bool HandleWriteIPPacket(llarp_buffer_t pkt, std::function getFromIP) = 0; + virtual bool + HandleWriteIPPacket(llarp_buffer_t pkt, + std::function< huint32_t(void) > getFromIP) = 0; bool ProcessDataMessage(ProtocolMessage* msg); @@ -154,10 +155,11 @@ namespace llarp HandlePathBuilt(path::Path* path); bool - SendToServiceOrQueue(const byte_t* addr, llarp_buffer_t payload, ProtocolType t); + SendToServiceOrQueue(const byte_t* addr, llarp_buffer_t payload, + ProtocolType t); bool - SendToSNodeOrQueue(const byte_t * addr, llarp_buffer_t payload); + SendToSNodeOrQueue(const byte_t* addr, llarp_buffer_t payload); struct PendingBuffer { @@ -329,14 +331,15 @@ namespace llarp EnsurePathToService(const Address& remote, PathEnsureHook h, uint64_t timeoutMS, bool lookupOnRandomPath = false); - using SNodeEnsureHook = std::function; + using SNodeEnsureHook = + std::function< void(RouterID, llarp::exit::BaseSession*) >; /// ensure a path to a service node by public key void - EnsurePathToSNode(const RouterID & remote); + EnsurePathToSNode(const RouterID& remote); bool - HasPathToSNode(const RouterID &remote) const; + HasPathToSNode(const RouterID& remote) const; void PutSenderFor(const ConvoTag& tag, const ServiceInfo& info); @@ -445,7 +448,10 @@ namespace llarp Sessions m_DeadSessions; - using SNodeSessions = std::unordered_multimap, RouterID::Hash>; + using SNodeSessions = + std::unordered_multimap< RouterID, + std::unique_ptr< llarp::exit::BaseSession >, + RouterID::Hash >; SNodeSessions m_SNodeSessions; diff --git a/include/tuntap.h b/include/tuntap.h index 7464eb449..2a21586d0 100644 --- a/include/tuntap.h +++ b/include/tuntap.h @@ -140,7 +140,7 @@ extern "C" /** set me on ios and android to block on a promise for the fd */ int (*obtain_fd)(struct device *); /** user data */ - void * user; + void *user; t_tun tun_fd; int ctrl_sock; int flags; /* ifr.ifr_flags on Unix */ diff --git a/llarp/android/ifaddrs.c b/llarp/android/ifaddrs.c index 3f6faf611..12dd7cc7a 100644 --- a/llarp/android/ifaddrs.c +++ b/llarp/android/ifaddrs.c @@ -326,8 +326,8 @@ interpretLink(struct nlmsghdr *p_hdr, struct ifaddrs **p_resultList) for(l_rta = IFLA_RTA(l_info); RTA_OK(l_rta, l_rtaSize); l_rta = RTA_NEXT(l_rta, l_rtaSize)) { - void *l_rtaData = RTA_DATA(l_rta); - (void) l_rtaData; + void *l_rtaData = RTA_DATA(l_rta); + (void)l_rtaData; size_t l_rtaDataSize = RTA_PAYLOAD(l_rta); switch(l_rta->rta_type) { @@ -454,8 +454,8 @@ interpretAddr(struct nlmsghdr *p_hdr, struct ifaddrs **p_resultList, for(l_rta = IFA_RTA(l_info); RTA_OK(l_rta, l_rtaSize); l_rta = RTA_NEXT(l_rta, l_rtaSize)) { - void *l_rtaData = RTA_DATA(l_rta); - (void) l_rtaData; + void *l_rtaData = RTA_DATA(l_rta); + (void)l_rtaData; size_t l_rtaDataSize = RTA_PAYLOAD(l_rta); switch(l_rta->rta_type) diff --git a/llarp/config.cpp b/llarp/config.cpp index 043471407..27625f963 100644 --- a/llarp/config.cpp +++ b/llarp/config.cpp @@ -182,7 +182,9 @@ llarp_generic_ensure_config(std::ofstream &f, std::string basepath) f << "# bootstrap settings" << std::endl; f << "[bootstrap]" << std::endl; - f << "# add a bootstrap node's signed identity to the list of nodes we want to bootstrap from" << std::endl; + f << "# add a bootstrap node's signed identity to the list of nodes we want " + "to bootstrap from" + << std::endl; f << "# if we don't have any peers we connect to this router" << std::endl; f << "add-node=" << basepath << "bootstrap.signed" << std::endl; f << "# add another bootstrap node" << std::endl; @@ -265,9 +267,12 @@ llarp_ensure_client_config(std::ofstream &f, std::string basepath) f << "# network settings " << std::endl; f << "[network]" << std::endl; f << "profiles=" << basepath << "profiles.dat" << std::endl; - f << "# uncomment next line to add router with pubkey to list of routers we connect directly to" << std::endl; + f << "# uncomment next line to add router with pubkey to list of routers we " + "connect directly to" + << std::endl; f << "#strict-connect=pubkey" << std::endl; - f << "# uncomment next line to use router with pubkey as an exit node" << std::endl; + f << "# uncomment next line to use router with pubkey as an exit node" + << std::endl; f << "#exit-node=pubkey" << std::endl; // pick ip std::string ip = llarp::findFreePrivateRange(); @@ -355,9 +360,9 @@ extern "C" { iter->conf = conf; std::map< std::string, llarp::Config::section_t & > sections = { - {"network", conf->impl.network}, {"connect", conf->impl.connect}, + {"network", conf->impl.network}, {"connect", conf->impl.connect}, {"bootstrap", conf->impl.bootstrap}, {"system", conf->impl.system}, - {"netdb", conf->impl.netdb}, {"api", conf->impl.api}, + {"netdb", conf->impl.netdb}, {"api", conf->impl.api}, {"services", conf->impl.services}}; for(const auto item : conf->impl.router) diff --git a/llarp/context.cpp b/llarp/context.cpp index c3bc09240..3c7020800 100644 --- a/llarp/context.cpp +++ b/llarp/context.cpp @@ -162,20 +162,15 @@ namespace llarp int Context::Run() { - // just check to make sure it's not already set up (either this or we add a - // bool and/or add another function) - if(!this->router) + if(router == nullptr) { - // set up all requirements - if(this->Setup()) - { - llarp::LogError("Failed to setup router"); - return 1; - } + // we are not set up so we should die + llarp::LogError("cannot run non configured context"); + return 1; } // run if(!llarp_run_router(router, nodedb)) - return 1; // success + return 1; // run net io thread llarp::LogInfo("running mainloop"); llarp_ev_loop_run_single_process(mainloop, worker, logic); @@ -208,6 +203,14 @@ namespace llarp void Context::Close() { + llarp::LogDebug("stopping logic"); + if(logic) + llarp_logic_stop(logic); + + llarp::LogDebug("stopping event loop"); + if(mainloop) + llarp_ev_loop_stop(mainloop); + llarp::LogDebug("stop router"); if(router) llarp_stop_router(router); @@ -220,11 +223,6 @@ namespace llarp if(worker) llarp_threadpool_join(worker); - llarp::LogDebug("stop logic"); - - if(logic) - llarp_logic_stop(logic); - llarp::LogDebug("free config"); llarp_free_config(&config); @@ -242,14 +240,6 @@ namespace llarp llarp::LogDebug("free logic"); llarp_free_logic(&logic); - - for(auto &t : netio_threads) - { - llarp::LogDebug("join netio thread"); - t.join(); - } - - netio_threads.clear(); } bool @@ -296,10 +286,11 @@ extern "C" ptr->ctx->HandleSignal(sig); } - void - llarp_main_inject_vpn_fd(struct llarp_main * ptr, int fd) + void + llarp_main_inject_vpn_fd(struct llarp_main *ptr, int fd) { - llarp::handlers::TunEndpoint * tun = ptr->ctx->router->hiddenServiceContext.getFirstTun(); + llarp::handlers::TunEndpoint *tun = + ptr->ctx->router->hiddenServiceContext.getFirstTun(); if(!tun) return; if(!tun->Promise) diff --git a/llarp/dht/context.cpp b/llarp/dht/context.cpp index 9c589f09a..9888936da 100644 --- a/llarp/dht/context.cpp +++ b/llarp/dht/context.cpp @@ -78,7 +78,10 @@ namespace llarp for(const auto &pk : valuesFound) { // lookup router - parent->LookupRouter(pk, std::bind(&llarp_router::HandleDHTLookupForExplore, parent->router, pk, std::placeholders::_1)); + parent->LookupRouter( + pk, + std::bind(&llarp_router::HandleDHTLookupForExplore, + parent->router, pk, std::placeholders::_1)); } } }; diff --git a/llarp/dns.cpp b/llarp/dns.cpp index 9e46ae02c..67b3cfee0 100644 --- a/llarp/dns.cpp +++ b/llarp/dns.cpp @@ -238,7 +238,7 @@ packet2bytes(dns_packet &in) int fields = (in.header.qr << 15); // QR => message type, 1 = response fields += (in.header.opcode << 14); // I think opcode is always 0 - fields += in.header.rcode; // response code (3 => not found, 0 = Ok) + fields += in.header.rcode; // response code (3 => not found, 0 = Ok) vput16bits(write_buffer, fields); // don't pull these from the header, trust what we actually have more @@ -308,14 +308,14 @@ extern "C" } bool - decode_hdr(llarp_buffer_t * buffer, dns_msg_header * hdr) + decode_hdr(llarp_buffer_t *buffer, dns_msg_header *hdr) { uint16_t fields; // reads as HOST byte order if(!llarp_buffer_read_uint16(buffer, &hdr->id)) return false; - if(!llarp_buffer_read_uint16(buffer, &fields)) + if(!llarp_buffer_read_uint16(buffer, &fields)) return false; if(!llarp_buffer_read_uint16(buffer, &hdr->qdCount)) return false; diff --git a/llarp/dns_dotlokilookup.cpp b/llarp/dns_dotlokilookup.cpp index 9d9f847d1..2d940729b 100644 --- a/llarp/dns_dotlokilookup.cpp +++ b/llarp/dns_dotlokilookup.cpp @@ -31,27 +31,30 @@ struct check_query_simple_request std::unordered_map< std::string, struct dnsd_query_hook_response * > loki_tld_lookup_cache; -static bool decode_request_name(const std::string & name, llarp::AlignedBuffer<32> & addr, bool &isSNode) +static bool +decode_request_name(const std::string &name, llarp::AlignedBuffer< 32 > &addr, + bool &isSNode) { llarp::service::Address serviceAddr; llarp::RouterID snodeAddr; auto pos = name.find(".snode"); if(pos != std::string::npos) { - if(!llarp::HexDecode(name.substr(0, pos).c_str(), serviceAddr.data(), serviceAddr.size())) + if(!llarp::HexDecode(name.substr(0, pos).c_str(), serviceAddr.data(), + serviceAddr.size())) { return false; } - addr = snodeAddr.data(); + addr = snodeAddr.data(); isSNode = true; } - else + else { if(!serviceAddr.FromString(name)) { return false; } - addr = serviceAddr.data(); + addr = serviceAddr.data(); isSNode = false; } return true; @@ -80,7 +83,7 @@ llarp_dotlokilookup_checkQuery(void *u, __attribute__((unused)) uint64_t orig, // if so send that // else // if we have a free private ip, send that - + /* // cache hit auto itr = loki_tld_lookup_cache.find(addr.ToString()); @@ -109,7 +112,7 @@ llarp_dotlokilookup_checkQuery(void *u, __attribute__((unused)) uint64_t orig, return; } llarp::huint32_t serviceIP; - llarp::AlignedBuffer<32> addr; + llarp::AlignedBuffer< 32 > addr; bool isSNode = false; if(!decode_request_name(qr->request->question.name, addr, isSNode)) { @@ -125,7 +128,6 @@ llarp_dotlokilookup_checkQuery(void *u, __attribute__((unused)) uint64_t orig, delete qr; return; } - /* bool mapResult = routerHiddenServiceContext->MapAddressAll( @@ -260,7 +262,7 @@ ReverseHandlerIter(struct llarp::service::Context::endpoint_iter *endpointCfg) llarp::iprange_ipv4(std::stoi(tokensCheck[0]), std::stoi(tokensCheck[1]), std::stoi(tokensCheck[2]), std::stoi(tokensCheck[3]), tunEndpoint->tunif.netmask); // create range - + llarp::huint32_t searchIPv4 = llarp::ipaddr_ipv4_bits( std::stoi(tokensSearch[searchTokens - 3]), std::stoi(tokensSearch[searchTokens - 4]), @@ -273,26 +275,25 @@ ReverseHandlerIter(struct llarp::service::Context::endpoint_iter *endpointCfg) llarp::Addr searchAddr(searchIp); llarp::Addr checkAddr(checkIp); llarp::LogInfo(searchIPv4, " vs ", range, " = ", - inRange ? "inRange" : "not match"); + inRange ? "inRange" : "not match"); if(inRange) { - llarp::AlignedBuffer<32> addr = - tunEndpoint->ObtainAddrForIP< llarp::AlignedBuffer<32> >( - searchIPv4, false); + llarp::AlignedBuffer< 32 > addr = + tunEndpoint->ObtainAddrForIP< llarp::AlignedBuffer< 32 > >(searchIPv4, + false); if(addr.IsZero()) { - addr = - tunEndpoint->ObtainAddrForIP< llarp::AlignedBuffer<32> >( - searchIPv4, true); + addr = tunEndpoint->ObtainAddrForIP< llarp::AlignedBuffer< 32 > >( + searchIPv4, true); if(!addr.IsZero()) { - char stack[128] = {0}; + char stack[128] = {0}; std::string saddr = llarp::HexEncode(addr, stack); saddr += ".snode"; writesend_dnss_revresponse(saddr, context->request); } - else + else write404_dnss_response(context->request); } else @@ -306,11 +307,13 @@ ReverseHandlerIter(struct llarp::service::Context::endpoint_iter *endpointCfg) return true; // we don't do anything with the result yet } -static bool should_intercept_query_with_name(const std::string & lName) +static bool +should_intercept_query_with_name(const std::string &lName) { // null terminated list - static const char * const matches[] = { ".loki", ".snode", ".loki.", ".snode.", 0}; - size_t idx = 0; + static const char *const matches[] = {".loki", ".snode", ".loki.", ".snode.", + 0}; + size_t idx = 0; while(matches[idx]) { std::string match_str(matches[idx]); @@ -323,7 +326,7 @@ static bool should_intercept_query_with_name(const std::string & lName) dnsd_query_hook_response * llarp_dotlokilookup_handler(std::string name, - const dnsd_question_request * request) + const dnsd_question_request *request) { dnsd_query_hook_response *response = new dnsd_query_hook_response; response->dontLookUp = false; @@ -362,7 +365,7 @@ llarp_dotlokilookup_handler(std::string name, if(!res) { llarp::LogDebug("Reverse is ours"); - response->dontLookUp = true; + response->dontLookUp = true; response->dontSendResponse = true; // should have already sent it } else @@ -384,11 +387,11 @@ llarp_dotlokilookup_handler(std::string name, } // decode address - llarp::AlignedBuffer<32> addr; + llarp::AlignedBuffer< 32 > addr; bool isSNode = false; if(!decode_request_name(lName, addr, isSNode)) { - response->dontLookUp = true; + response->dontLookUp = true; return response; } diff --git a/llarp/dnsc.cpp b/llarp/dnsc.cpp index 270403d61..7bcdfb774 100644 --- a/llarp/dnsc.cpp +++ b/llarp/dnsc.cpp @@ -647,8 +647,8 @@ raw_resolve_host(struct dnsc_context *const dnsc, const char *url, if(request) { request->packet.header = hdr; - generic_handle_dnsc_recvfrom(tracker->client_request[hdr.id].get(), - lbuffer, &hdr); + generic_handle_dnsc_recvfrom(tracker->client_request[hdr.id].get(), lbuffer, + &hdr); } else { @@ -672,7 +672,7 @@ llarp_handle_dnsc_recvfrom(struct llarp_udp_io *const udp, llarp::LogError("failed to decode dns header"); return; } - buf.cur = buf.base; // reset cursor to beginning + buf.cur = buf.base; // reset cursor to beginning llarp::LogDebug("Header got client responses for id: ", hdr.id); diff --git a/llarp/dnsd.cpp b/llarp/dnsd.cpp index f4df41604..eadc84ca5 100644 --- a/llarp/dnsd.cpp +++ b/llarp/dnsd.cpp @@ -48,7 +48,7 @@ write404_dnss_response(const dnsd_question_request *request) // build header put16bits(write_buffer, request->hdr.id); // not found flag set - put16bits(write_buffer, (1 << 15) | request->hdr.fields() | 3); + put16bits(write_buffer, (1 << 15) | request->hdr.fields() | 3); put16bits(write_buffer, 1); // QD (number of questions) put16bits(write_buffer, 0); // AN (number of answers) @@ -63,11 +63,13 @@ write404_dnss_response(const dnsd_question_request *request) uint32_t out_bytes = write_buffer - bufferBegin; llarp::LogDebug("Sending 404, ", out_bytes, " bytes"); // struct llarp_udp_io *udp = (struct llarp_udp_io *)request->user; - request->sendto_hook(request->user, request->from, llarp::InitBuffer(buf, out_bytes)); + request->sendto_hook(request->user, request->from, + llarp::InitBuffer(buf, out_bytes)); } void -writecname_dnss_response(std::string cname, const dnsd_question_request *request) +writecname_dnss_response(std::string cname, + const dnsd_question_request *request) { char buf[BUFFER_SIZE] = {0}; @@ -127,11 +129,13 @@ writecname_dnss_response(std::string cname, const dnsd_question_request *request uint32_t out_bytes = write_buffer - bufferBegin; llarp::LogDebug("Sending cname, ", out_bytes, " bytes"); // struct llarp_udp_io *udp = (struct llarp_udp_io *)request->user; - request->sendto_hook(request->user, request->from, llarp::InitBuffer(buf, out_bytes)); + request->sendto_hook(request->user, request->from, + llarp::InitBuffer(buf, out_bytes)); } void -writesend_dnss_revresponse(std::string reverse, const dnsd_question_request *request) +writesend_dnss_revresponse(std::string reverse, + const dnsd_question_request *request) { char buf[BUFFER_SIZE] = {0}; @@ -140,7 +144,7 @@ writesend_dnss_revresponse(std::string reverse, const dnsd_question_request *req // build header put16bits(write_buffer, request->hdr.id); // response - put16bits(write_buffer,request->hdr.fields() | (1 << 15) | (1 << 10)); + put16bits(write_buffer, request->hdr.fields() | (1 << 15) | (1 << 10)); put16bits(write_buffer, 1); // QD (number of questions) put16bits(write_buffer, 1); // AN (number of answers) @@ -156,14 +160,15 @@ writesend_dnss_revresponse(std::string reverse, const dnsd_question_request *req code_domain(write_buffer, request->question.name); // com, type=6, ttl=0 put16bits(write_buffer, request->question.type); put16bits(write_buffer, request->question.qClass); - put32bits(write_buffer, 1); // ttl + put32bits(write_buffer, 1); // ttl put16bits(write_buffer, reverse.size() + 2); // rdLength code_domain(write_buffer, reverse); uint32_t out_bytes = write_buffer - bufferBegin; llarp::LogDebug("Sending reverse: ", reverse, " ", out_bytes, " bytes"); // struct llarp_udp_io *udp = (struct llarp_udp_io *)request->user; - request->sendto_hook(request->user, request->from, llarp::InitBuffer(buf, out_bytes)); + request->sendto_hook(request->user, request->from, + llarp::InitBuffer(buf, out_bytes)); } // FIXME: we need an DNS answer not a sockaddr @@ -228,7 +233,8 @@ writesend_dnss_response(llarp::huint32_t *hostRes, uint32_t out_bytes = write_buffer - bufferBegin; llarp::LogDebug("Sending found, ", out_bytes, " bytes"); // struct llarp_udp_io *udp = (struct llarp_udp_io *)request->user; - request->sendto_hook(request->user, request->from, llarp::InitBuffer(buf, out_bytes)); + request->sendto_hook(request->user, request->from, + llarp::InitBuffer(buf, out_bytes)); } void @@ -323,7 +329,7 @@ handle_dnsc_result(dnsc_answer_request *client_request) } client_request->packet.header.id = server_request->hdr.id; // stomp ID - std::vector< byte_t > test = packet2bytes(client_request->packet); + std::vector< byte_t > test = packet2bytes(client_request->packet); // llarp::LogInfo("packet2bytes figures we should send ", test.size(), " // bytes"); @@ -371,7 +377,7 @@ handle_dnsc_result(dnsc_answer_request *client_request) // our generic version void -handle_recvfrom(llarp_buffer_t * buffer, dnsd_question_request *request) +handle_recvfrom(llarp_buffer_t *buffer, dnsd_question_request *request) { const size_t HDR_OFFSET = 12; const char *p_buffer = (const char *)buffer->base; @@ -379,7 +385,6 @@ handle_recvfrom(llarp_buffer_t * buffer, dnsd_question_request *request) int rcode = (buffer->base[3] & 0x0F); llarp::LogDebug("dnsd rcode ", rcode); - if(!decode_hdr(buffer, &request->hdr)) { llarp::LogError("failed to decode dns header"); diff --git a/llarp/encrypted_frame.cpp b/llarp/encrypted_frame.cpp index 1d91fd537..ec53e2fda 100644 --- a/llarp/encrypted_frame.cpp +++ b/llarp/encrypted_frame.cpp @@ -10,7 +10,7 @@ namespace llarp UpdateBuffer(); } - Encrypted::Encrypted(Encrypted && other) + Encrypted::Encrypted(Encrypted&& other) { _data = std::move(other._data); UpdateBuffer(); diff --git a/llarp/ev.cpp b/llarp/ev.cpp index 29e8d8410..aa40ee831 100644 --- a/llarp/ev.cpp +++ b/llarp/ev.cpp @@ -20,7 +20,6 @@ #error No async event loop for your platform, subclass llarp_ev_loop #endif - void llarp_ev_loop_alloc(struct llarp_ev_loop **ev) { @@ -58,7 +57,8 @@ llarp_ev_loop_run(struct llarp_ev_loop *ev, struct llarp_logic *logic) return 0; } -int llarp_fd_promise_wait_for_value(struct llarp_fd_promise * p) +int +llarp_fd_promise_wait_for_value(struct llarp_fd_promise *p) { return p->Get(); } diff --git a/llarp/ev.hpp b/llarp/ev.hpp index f0b7ec56c..bc4011b4e 100644 --- a/llarp/ev.hpp +++ b/llarp/ev.hpp @@ -612,15 +612,19 @@ namespace llarp struct llarp_fd_promise { - llarp_fd_promise(std::promise * p) : _impl(p) {} - std::promise * _impl; - - void Set(int fd) + llarp_fd_promise(std::promise< int >* p) : _impl(p) + { + } + std::promise< int >* _impl; + + void + Set(int fd) { _impl->set_value(fd); } - int Get() + int + Get() { auto future = _impl->get_future(); future.wait(); diff --git a/llarp/ev_epoll.hpp b/llarp/ev_epoll.hpp index 40cb81ba5..baae57b5f 100644 --- a/llarp/ev_epoll.hpp +++ b/llarp/ev_epoll.hpp @@ -138,7 +138,7 @@ namespace llarp { llarp_buffer_t b; b.base = buf; - b.cur = b.base; + b.cur = b.base; sockaddr_in6 src; socklen_t slen = sizeof(sockaddr_in6); sockaddr* addr = (sockaddr*)&src; @@ -217,7 +217,7 @@ namespace llarp } int - read(byte_t * buf, size_t sz) + read(byte_t* buf, size_t sz) { ssize_t ret = tuntap_read(tunif, buf, sz); if(ret > 0 && t->recvpkt) @@ -228,12 +228,13 @@ namespace llarp return ret; } - static int wait_for_fd_promise(struct device * dev) + static int + wait_for_fd_promise(struct device* dev) { - llarp::tun *t = static_cast(dev->user); + llarp::tun* t = static_cast< llarp::tun* >(dev->user); if(t->t->get_fd_promise) { - struct llarp_fd_promise * promise = t->t->get_fd_promise(t->t); + struct llarp_fd_promise* promise = t->t->get_fd_promise(t->t); if(promise) return llarp_fd_promise_wait_for_value(promise); } @@ -247,7 +248,7 @@ namespace llarp if(t->get_fd_promise) { tunif->obtain_fd = &wait_for_fd_promise; - tunif->user = this; + tunif->user = this; } llarp::LogDebug("set ifname to ", t->ifname); strncpy(tunif->if_name, t->ifname, sizeof(tunif->if_name)); @@ -513,8 +514,8 @@ struct llarp_epoll_loop : public llarp_ev_loop llarp::tun* t = new llarp::tun(tun, this); if(tun->get_fd_promise) { - - } else if(t->setup()) + } + else if(t->setup()) { return t; } @@ -577,6 +578,14 @@ struct llarp_epoll_loop : public llarp_ev_loop void stop() { + // close all handlers before closing the epoll fd + auto itr = handlers.begin(); + while(itr != handler.end()) + { + close_ev(itr->get()); + itr = handlers.erase(itr); + } + if(epollfd != -1) close(epollfd); epollfd = -1; diff --git a/llarp/exit/endpoint.cpp b/llarp/exit/endpoint.cpp index 9d9be1f2a..ea6bcd6b1 100644 --- a/llarp/exit/endpoint.cpp +++ b/llarp/exit/endpoint.cpp @@ -67,11 +67,12 @@ namespace llarp return true; } - bool Endpoint::LooksDead(llarp_time_t now, llarp_time_t timeout) const + bool + Endpoint::LooksDead(llarp_time_t now, llarp_time_t timeout) const { if(ExpiresSoon(now, timeout)) return true; - if (now > m_LastActive) + if(now > m_LastActive) return now - m_LastActive > timeout; return true; } @@ -82,11 +83,11 @@ namespace llarp // queue overflow if(m_UpstreamQueue.size() > MaxUpstreamQueueSize) return false; - + llarp::net::IPv4Packet pkt; if(!pkt.Load(buf)) return false; - + huint32_t dst; if(m_RewriteSource) dst = m_Parent->GetIfAddr(); @@ -103,8 +104,8 @@ namespace llarp Endpoint::QueueInboundTraffic(llarp_buffer_t buf) { llarp::net::IPv4Packet pkt; - if(!pkt.Load(buf)) - return false; + if(!pkt.Load(buf)) + return false; huint32_t src; if(m_RewriteSource) @@ -112,15 +113,15 @@ namespace llarp else src = pkt.src(); pkt.UpdateIPv4PacketOnDst(src, m_IP); - auto pktbuf = pkt.Buffer(); + auto pktbuf = pkt.Buffer(); uint8_t queue_idx = pktbuf.sz / llarp::routing::ExitPadSize; - auto & queue = m_DownstreamQueues[queue_idx]; + auto& queue = m_DownstreamQueues[queue_idx]; if(queue.size() == 0) { queue.emplace_back(); return queue.back().PutBuffer(buf, m_Counter++); } - auto & msg = queue.back(); + auto& msg = queue.back(); if(msg.Size() + pktbuf.sz > llarp::routing::ExitPadSize) { queue.emplace_back(); @@ -130,7 +131,7 @@ namespace llarp return msg.PutBuffer(pktbuf, m_Counter++); } - bool + bool Endpoint::Flush() { // flush upstream queue @@ -144,13 +145,13 @@ namespace llarp bool sent = path != nullptr; if(path) { - for(auto & item : m_DownstreamQueues) + for(auto& item : m_DownstreamQueues) { - auto & queue = item.second; + auto& queue = item.second; while(queue.size()) { - auto & msg = queue.front(); - msg.S = path->NextSeqNo(); + auto& msg = queue.front(); + msg.S = path->NextSeqNo(); if(path->SendRoutingMessage(&msg, m_Parent->Router())) { m_RxRate += msg.Size(); @@ -160,7 +161,7 @@ namespace llarp } } } - for(auto & item : m_DownstreamQueues) + for(auto& item : m_DownstreamQueues) item.second.clear(); return sent; } diff --git a/llarp/exit/session.cpp b/llarp/exit/session.cpp index 9fddd433b..c5ffcce5c 100644 --- a/llarp/exit/session.cpp +++ b/llarp/exit/session.cpp @@ -99,10 +99,11 @@ namespace llarp } bool - BaseSession::QueueUpstreamTraffic(llarp::net::IPv4Packet pkt, const size_t N) + BaseSession::QueueUpstreamTraffic(llarp::net::IPv4Packet pkt, + const size_t N) { - auto buf = pkt.Buffer(); - auto & queue = m_Upstream[buf.sz / N]; + auto buf = pkt.Buffer(); + auto& queue = m_Upstream[buf.sz / N]; // queue overflow if(queue.size() >= MaxUpstreamQueueLength) return false; @@ -111,41 +112,41 @@ namespace llarp queue.emplace_back(); return queue.back().PutBuffer(buf, m_Counter++); } - auto & back = queue.back(); + auto& back = queue.back(); // pack to nearest N if(back.Size() + buf.sz > N) { - queue.emplace_back(); - return queue.back().PutBuffer(buf, m_Counter++); + queue.emplace_back(); + return queue.back().PutBuffer(buf, m_Counter++); } else return back.PutBuffer(buf, m_Counter++); } bool - BaseSession::IsReady() const + BaseSession::IsReady() const { return AvailablePaths(llarp::path::ePathRoleExit) > 0; } - bool + bool BaseSession::FlushUpstreamTraffic() { auto path = PickRandomEstablishedPath(llarp::path::ePathRoleExit); if(!path) { // discard - for(auto & item : m_Upstream) + for(auto& item : m_Upstream) item.second.clear(); return false; } - for (auto & item : m_Upstream) + for(auto& item : m_Upstream) { - auto & queue = item.second; + auto& queue = item.second; while(queue.size()) { - auto & msg = queue.front(); - msg.S = path->NextSeqNo(); + auto& msg = queue.front(); + msg.S = path->NextSeqNo(); path->SendRoutingMessage(&msg, router); queue.pop_front(); } diff --git a/llarp/exit/transfer_traffic.cpp b/llarp/exit/transfer_traffic.cpp index d7d530d80..cc14df67a 100644 --- a/llarp/exit/transfer_traffic.cpp +++ b/llarp/exit/transfer_traffic.cpp @@ -21,7 +21,7 @@ namespace llarp if(buf.sz > MaxExitMTU) return false; X.emplace_back(buf.sz + 8); - byte_t * ptr = X.back().data(); + byte_t* ptr = X.back().data(); htobe64buf(ptr, counter); ptr += 8; memcpy(ptr, buf.base, buf.sz); diff --git a/llarp/handlers/exit.cpp b/llarp/handlers/exit.cpp index 00c5ed26c..0e1fe7762 100644 --- a/llarp/handlers/exit.cpp +++ b/llarp/handlers/exit.cpp @@ -36,7 +36,7 @@ namespace llarp { } - llarp_time_t + llarp_time_t ExitEndpoint::Now() const { return m_Router->Now(); @@ -73,17 +73,19 @@ namespace llarp } ++itr; } - + 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"); + llarp::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)"); + llarp::LogWarn(Name(), " dropped inbound traffic for session ", pk, + " as we are overloaded (probably)"); } } }); diff --git a/llarp/handlers/tun.cpp b/llarp/handlers/tun.cpp index 71217d10d..dbaaf92b0 100644 --- a/llarp/handlers/tun.cpp +++ b/llarp/handlers/tun.cpp @@ -14,10 +14,10 @@ namespace llarp { namespace handlers { - - static llarp_fd_promise * get_tun_fd_promise(llarp_tun_io * tun) + static llarp_fd_promise * + get_tun_fd_promise(llarp_tun_io *tun) { - return static_cast(tun->user)->Promise.get(); + return static_cast< TunEndpoint * >(tun->user)->Promise.get(); } TunEndpoint::TunEndpoint(const std::string &nickname, llarp_router *r) @@ -25,10 +25,10 @@ namespace llarp , m_UserToNetworkPktQueue(nickname + "_sendq", r->netloop, r->netloop) , m_NetworkToUserPktQueue(nickname + "_recvq", r->netloop, r->netloop) { -#ifdef ANDROID +#ifdef ANDROID tunif.get_fd_promise = &get_tun_fd_promise; Promise.reset(new llarp_fd_promise(&m_VPNPromise)); -#else +#else tunif.get_fd_promise = nullptr; #endif tunif.user = this; @@ -180,7 +180,8 @@ namespace llarp } bool - TunEndpoint::MapAddress(const service::Address &addr, huint32_t ip, bool SNode) + TunEndpoint::MapAddress(const service::Address &addr, huint32_t ip, + bool SNode) { auto itr = m_IPToAddr.find(ip); if(itr != m_IPToAddr.end()) @@ -192,9 +193,9 @@ namespace llarp } llarp::LogInfo(Name() + " map ", addr.ToString(), " to ", ip); - m_IPToAddr[ip] = addr.data(); + m_IPToAddr[ip] = addr.data(); m_AddrToIP[addr.data()] = ip; - m_SNodes[addr.data()] = SNode; + m_SNodes[addr.data()] = SNode; MarkIPActiveForever(ip); return true; } @@ -242,7 +243,8 @@ namespace llarp #endif } - bool TunEndpoint::IsSNode() const + bool + TunEndpoint::IsSNode() const { // TODO : implement me return false; @@ -365,30 +367,34 @@ namespace llarp TunEndpoint::FlushSend() { m_UserToNetworkPktQueue.Process([&](net::IPv4Packet &pkt) { - std::function sendFunc; + std::function< bool(llarp_buffer_t) > sendFunc; auto itr = m_IPToAddr.find(pkt.dst()); if(itr == m_IPToAddr.end()) { if(m_Exit) { pkt.UpdateIPv4PacketOnDst({0}, pkt.dst()); - m_Exit->QueueUpstreamTraffic(std::move(pkt), llarp::routing::ExitPadSize); + m_Exit->QueueUpstreamTraffic(std::move(pkt), + llarp::routing::ExitPadSize); return true; } else { llarp::LogWarn(Name(), " has no endpoint for ", pkt.dst()); - return true; + return true; } } if(m_SNodes.at(itr->second)) { - sendFunc = std::bind(&TunEndpoint::SendToSNodeOrQueue, this, itr->second.data(), std::placeholders::_1); + sendFunc = std::bind(&TunEndpoint::SendToSNodeOrQueue, this, + itr->second.data(), std::placeholders::_1); } - else + else { - sendFunc = std::bind(&TunEndpoint::SendToServiceOrQueue, this, itr->second.data(), std::placeholders::_1, service::eProtocolTraffic); + sendFunc = std::bind(&TunEndpoint::SendToServiceOrQueue, this, + itr->second.data(), std::placeholders::_1, + service::eProtocolTraffic); } // prepare packet for insertion into network // this includes clearing IP addresses, recalculating checksums, etc @@ -404,35 +410,36 @@ namespace llarp } bool - TunEndpoint::HandleWriteIPPacket(llarp_buffer_t buf, std::function getFromIP) + TunEndpoint::HandleWriteIPPacket(llarp_buffer_t buf, + std::function< huint32_t(void) > getFromIP) { // llarp::LogInfo("got packet from ", msg->sender.Addr()); auto themIP = getFromIP(); // llarp::LogInfo("themIP ", themIP); auto usIP = m_OurIP; return m_NetworkToUserPktQueue.EmplaceIf( - [buf, themIP, usIP](net::IPv4Packet &pkt) -> bool { - // load - if(!pkt.Load(buf)) - return false; - // filter out: - // - packets smaller than minimal IPv4 header - // - non-IPv4 packets - // - packets with weird src/dst addresses - // (0.0.0.0/8 but not 0.0.0.0) - // - packets with 0 src but non-0 dst and oposite - auto hdr = pkt.Header(); - if(pkt.sz < sizeof(*hdr) || hdr->version != 4 - || (hdr->saddr != 0 && *(byte_t *)&(hdr->saddr) == 0) - || (hdr->daddr != 0 && *(byte_t *)&(hdr->daddr) == 0) - || ((hdr->saddr == 0) != (hdr->daddr == 0))) - { - return false; - } - // update packet to use proper addresses, recalc checksums - pkt.UpdateIPv4PacketOnDst(themIP, usIP); - return true; - }); + [buf, themIP, usIP](net::IPv4Packet &pkt) -> bool { + // load + if(!pkt.Load(buf)) + return false; + // filter out: + // - packets smaller than minimal IPv4 header + // - non-IPv4 packets + // - packets with weird src/dst addresses + // (0.0.0.0/8 but not 0.0.0.0) + // - packets with 0 src but non-0 dst and oposite + auto hdr = pkt.Header(); + if(pkt.sz < sizeof(*hdr) || hdr->version != 4 + || (hdr->saddr != 0 && *(byte_t *)&(hdr->saddr) == 0) + || (hdr->daddr != 0 && *(byte_t *)&(hdr->daddr) == 0) + || ((hdr->saddr == 0) != (hdr->daddr == 0))) + { + return false; + } + // update packet to use proper addresses, recalc checksums + pkt.UpdateIPv4PacketOnDst(themIP, usIP); + return true; + }); } huint32_t @@ -469,7 +476,7 @@ namespace llarp { m_AddrToIP[ident] = nextIP; m_IPToAddr[nextIP] = ident; - m_SNodes[ident] = snode; + m_SNodes[ident] = snode; llarp::LogInfo(Name(), " mapped ", ident, " to ", nextIP); MarkIPActive(nextIP); return nextIP; @@ -498,7 +505,7 @@ namespace llarp // remap address m_IPToAddr[oldest.first] = ident; m_AddrToIP[ident] = oldest.first; - m_SNodes[ident] = snode; + m_SNodes[ident] = snode; nextIP = oldest.first; // mark ip active diff --git a/llarp/ip.cpp b/llarp/ip.cpp index 9ad9de41f..c78df043e 100644 --- a/llarp/ip.cpp +++ b/llarp/ip.cpp @@ -24,7 +24,7 @@ namespace llarp } llarp_buffer_t - IPv4Packet::ConstBuffer() const + IPv4Packet::ConstBuffer() const { return llarp::InitBuffer(buf, sz); } diff --git a/llarp/path.cpp b/llarp/path.cpp index e90f8687e..54b770ed4 100644 --- a/llarp/path.cpp +++ b/llarp/path.cpp @@ -801,12 +801,13 @@ namespace llarp if(!m_ExitTrafficHandler) return false; bool sent = msg->X.size() > 0; - for(const auto & pkt : msg->X) + for(const auto& pkt : msg->X) { if(pkt.size() <= 8) return false; uint64_t counter = bufbe64toh(pkt.data()); - m_ExitTrafficHandler(this, llarp::InitBuffer(pkt.data() +8, pkt.size()-8), counter); + m_ExitTrafficHandler( + this, llarp::InitBuffer(pkt.data() + 8, pkt.size() - 8), counter); } return sent; } diff --git a/llarp/pathbuilder.cpp b/llarp/pathbuilder.cpp index 29c4e537a..ec46c1ffc 100644 --- a/llarp/pathbuilder.cpp +++ b/llarp/pathbuilder.cpp @@ -180,7 +180,8 @@ namespace llarp { (void)roles; if(hop == 0) - return router->NumberOfConnectedRouters() && router->GetRandomConnectedRouter(cur); + return router->NumberOfConnectedRouters() + && router->GetRandomConnectedRouter(cur); size_t tries = 5; do diff --git a/llarp/pathset.cpp b/llarp/pathset.cpp index d2d3c81b2..9d27dc0d0 100644 --- a/llarp/pathset.cpp +++ b/llarp/pathset.cpp @@ -242,7 +242,7 @@ namespace llarp intros.clear(); size_t count = 0; Lock_t l(m_PathsMutex); - auto itr = m_Paths.begin(); + auto itr = m_Paths.begin(); while(itr != m_Paths.end()) { if(itr->second->IsReady() && filter(itr->second->intro)) @@ -262,7 +262,7 @@ namespace llarp intros.clear(); size_t count = 0; Lock_t l(m_PathsMutex); - auto itr = m_Paths.begin(); + auto itr = m_Paths.begin(); while(itr != m_Paths.end()) { if(itr->second->IsReady()) @@ -287,7 +287,7 @@ namespace llarp intro.Clear(); bool found = false; Lock_t l(m_PathsMutex); - auto itr = m_Paths.begin(); + auto itr = m_Paths.begin(); while(itr != m_Paths.end()) { if(itr->second->IsReady() diff --git a/llarp/router.cpp b/llarp/router.cpp index 4d82f12e3..78c8e0465 100644 --- a/llarp/router.cpp +++ b/llarp/router.cpp @@ -427,8 +427,8 @@ llarp_router::handle_router_ticker(void *user, uint64_t orig, uint64_t left) self->ScheduleTicker(orig); } -bool -llarp_router::ConnectionToRouterAllowed(const llarp::RouterID & router) const +bool +llarp_router::ConnectionToRouterAllowed(const llarp::RouterID &router) const { if(strictConnectPubkeys.size() && strictConnectPubkeys.count(router) == 0) return false; @@ -438,12 +438,13 @@ llarp_router::ConnectionToRouterAllowed(const llarp::RouterID & router) const return true; } -void -llarp_router::HandleDHTLookupForExplore(llarp::RouterID remote, const std::vector< llarp::RouterContact > &results) +void +llarp_router::HandleDHTLookupForExplore( + llarp::RouterID remote, const std::vector< llarp::RouterContact > &results) { if(results.size() == 0) return; - for(const auto & rc: results) + for(const auto &rc : results) { if(rc.Verify(&crypto)) llarp_nodedb_put_rc(nodedb, rc); @@ -461,7 +462,8 @@ llarp_router::TryEstablishTo(const llarp::RouterID &remote) { if(!ConnectionToRouterAllowed(remote)) { - llarp::LogWarn("not connecting to ", remote, " as it's not permitted by config"); + llarp::LogWarn("not connecting to ", remote, + " as it's not permitted by config"); return; } @@ -566,7 +568,7 @@ llarp_router::Tick() // TODO: only connect to random subset if(bootstrapRCList.size()) { - for(const auto & rc : bootstrapRCList) + for(const auto &rc : bootstrapRCList) { llarp_router_try_connect(this, rc, 4); dht->impl.ExploreNetworkVia(rc.pubkey.data()); @@ -935,7 +937,6 @@ llarp_router::InitServiceNode() return exitContext.AddExitEndpoint("default-connectivity", netConfig); } - bool llarp_router::HasSessionTo(const llarp::RouterID &remote) const { @@ -1309,10 +1310,11 @@ namespace llarp self->netConfig.emplace(std::make_pair("local-dns", val)); } } - else if(StrEq(section, "connect") || (StrEq(section, "bootstrap") && StrEq(key, "add-node"))) + else if(StrEq(section, "connect") + || (StrEq(section, "bootstrap") && StrEq(key, "add-node"))) { self->bootstrapRCList.emplace_back(); - auto & rc = self->bootstrapRCList.back(); + auto &rc = self->bootstrapRCList.back(); if(rc.Read(val) && rc.Verify(&self->crypto)) { llarp::LogInfo("Added bootstrap node ", rc.pubkey); diff --git a/llarp/router.hpp b/llarp/router.hpp index e5688e7ad..41b18329b 100644 --- a/llarp/router.hpp +++ b/llarp/router.hpp @@ -106,11 +106,12 @@ struct llarp_router /// default network config for default network interface NetConfig_t netConfig; - /// identity keys whitelist of routers we will connect to directly (not for service nodes) - std::set strictConnectPubkeys; + /// identity keys whitelist of routers we will connect to directly (not for + /// service nodes) + std::set< llarp::PubKey > strictConnectPubkeys; /// bootstrap RCs - std::list bootstrapRCList; + std::list< llarp::RouterContact > bootstrapRCList; bool ExitEnabled() const @@ -213,17 +214,14 @@ struct llarp_router void PersistSessionUntil(const llarp::RouterID &remote, llarp_time_t until); - - bool EnsureIdentity(); bool EnsureEncryptionKey(); - bool - ConnectionToRouterAllowed(const llarp::RouterID & router) const; - + bool + ConnectionToRouterAllowed(const llarp::RouterID &router) const; bool SaveRC(); @@ -271,8 +269,9 @@ struct llarp_router void TryEstablishTo(const llarp::RouterID &remote); - void - HandleDHTLookupForExplore(llarp::RouterID remote, const std::vector< llarp::RouterContact > &results); + void + HandleDHTLookupForExplore(llarp::RouterID remote, + const std::vector< llarp::RouterContact > &results); void ForEachPeer( diff --git a/llarp/service.cpp b/llarp/service.cpp index e2d563587..68d03ccda 100644 --- a/llarp/service.cpp +++ b/llarp/service.cpp @@ -262,8 +262,8 @@ namespace llarp inf.read((char*)buf.base, sz); if(!BDecode(&buf)) return false; - - const byte_t * ptr = nullptr; + + const byte_t* ptr = nullptr; if(!vanity.IsZero()) ptr = vanity.data(); // update pubkeys diff --git a/llarp/service/context.cpp b/llarp/service/context.cpp index 61406e144..1464deebf 100644 --- a/llarp/service/context.cpp +++ b/llarp/service/context.cpp @@ -46,7 +46,7 @@ namespace llarp llarp::LogError("No endpoints found"); return nullptr; } - auto itr = m_Endpoints.begin(); + auto itr = m_Endpoints.begin(); if(itr == m_Endpoints.end()) return nullptr; return itr->second.get(); @@ -101,8 +101,7 @@ namespace llarp } bool - Context::FindBestAddressFor(const byte_t * addr, bool isSNode, - huint32_t &ip) + Context::FindBestAddressFor(const byte_t *addr, bool isSNode, huint32_t &ip) { auto itr = m_Endpoints.begin(); while(itr != m_Endpoints.end()) @@ -142,7 +141,6 @@ namespace llarp 10000); } - bool MapAddressAllIter(struct Context::endpoint_iter *endpointCfg) { @@ -155,8 +153,8 @@ namespace llarp llarp::LogError("No tunnel endpoint found"); return true; // still continue } - return tunEndpoint->MapAddress(context->serviceAddr, - context->localPrivateIpAddr.xtohl(), false); + return tunEndpoint->MapAddress( + context->serviceAddr, context->localPrivateIpAddr.xtohl(), false); } bool diff --git a/llarp/service/endpoint.cpp b/llarp/service/endpoint.cpp index cf3a2313e..6162badb6 100644 --- a/llarp/service/endpoint.cpp +++ b/llarp/service/endpoint.cpp @@ -197,7 +197,8 @@ namespace llarp continue; byte_t tmp[1024] = {0}; auto buf = StackBuffer< decltype(tmp) >(tmp); - if(!SendToServiceOrQueue(introset.A.Addr().data(), buf, eProtocolText)) + if(!SendToServiceOrQueue(introset.A.Addr().data(), buf, + eProtocolText)) { llarp::LogWarn(Name(), " failed to send/queue data to ", introset.A.Addr(), " for tag ", tag.ToString()); @@ -784,12 +785,12 @@ namespace llarp } bool - Endpoint::HasPathToSNode(const llarp::RouterID & ident) const + Endpoint::HasPathToSNode(const llarp::RouterID& ident) const { auto range = m_SNodeSessions.equal_range(ident); - auto itr = range.first; + auto itr = range.first; while(itr != range.second) - { + { if(itr->second->IsReady()) { return true; @@ -800,14 +801,16 @@ namespace llarp } bool - Endpoint::ProcessDataMessage(ProtocolMessage *msg) + Endpoint::ProcessDataMessage(ProtocolMessage* msg) { if(msg->proto == eProtocolTraffic) { - auto buf = llarp::Buffer(msg->payload); - return HandleWriteIPPacket(buf, std::bind(&Endpoint::ObtainIPForAddr, this, msg->sender.Addr().data(), false)); + auto buf = llarp::Buffer(msg->payload); + return HandleWriteIPPacket(buf, + std::bind(&Endpoint::ObtainIPForAddr, this, + msg->sender.Addr().data(), false)); } - else if (msg->proto == eProtocolText) + else if(msg->proto == eProtocolText) { // TODO: implement me (?) return true; @@ -1064,29 +1067,38 @@ namespace llarp } void - Endpoint::EnsurePathToSNode(const RouterID & snode) + Endpoint::EnsurePathToSNode(const RouterID& snode) { auto range = m_SNodeSessions.equal_range(snode); if(range.first == range.second) { auto themIP = ObtainIPForAddr(snode, true); - m_SNodeSessions.emplace(std::make_pair(snode, std::unique_ptr(new llarp::exit::SNodeSession(snode, std::bind(&Endpoint::HandleWriteIPPacket, this, std::placeholders::_1, [themIP]() -> huint32_t {return themIP;}), m_Router, 2, numHops)))); + m_SNodeSessions.emplace(std::make_pair( + snode, + std::unique_ptr< llarp::exit::BaseSession >( + new llarp::exit::SNodeSession( + snode, + std::bind(&Endpoint::HandleWriteIPPacket, this, + std::placeholders::_1, + [themIP]() -> huint32_t { return themIP; }), + m_Router, 2, numHops)))); } } bool - Endpoint::SendToSNodeOrQueue(const byte_t * addr, llarp_buffer_t buf) + Endpoint::SendToSNodeOrQueue(const byte_t* addr, llarp_buffer_t buf) { llarp::net::IPv4Packet pkt; if(!pkt.Load(buf)) return false; auto range = m_SNodeSessions.equal_range(addr); - auto itr = range.first; + auto itr = range.first; while(itr != range.second) { if(itr->second->IsReady()) { - if(itr->second->QueueUpstreamTraffic(pkt, llarp::routing::ExitPadSize)) + if(itr->second->QueueUpstreamTraffic(pkt, + llarp::routing::ExitPadSize)) { return true; } @@ -1098,7 +1110,7 @@ namespace llarp bool Endpoint::SendToServiceOrQueue(const byte_t* addr, llarp_buffer_t data, - ProtocolType t) + ProtocolType t) { service::Address remote(addr); diff --git a/llarp/transit_hop.cpp b/llarp/transit_hop.cpp index f93d28017..9337a73d8 100644 --- a/llarp/transit_hop.cpp +++ b/llarp/transit_hop.cpp @@ -259,13 +259,14 @@ namespace llarp if(endpoint) { bool sent = true; - for(const auto & pkt : msg->X) + for(const auto& pkt : msg->X) { // check short packet buffer if(pkt.size() <= 8) continue; uint64_t counter = bufbe64toh(pkt.data()); - sent &= endpoint->QueueOutboundTraffic(llarp::InitBuffer(pkt.data() + 8, pkt.size() - 8), counter); + sent &= endpoint->QueueOutboundTraffic( + llarp::InitBuffer(pkt.data() + 8, pkt.size() - 8), counter); } return sent; }