mirror of https://github.com/oxen-io/lokinet
finish converting to shared_ptr
This commit is contained in:
parent
8484e29c9b
commit
6711296b26
|
@ -186,8 +186,8 @@ main(int argc, char *argv[])
|
|||
// does this file exist?
|
||||
if(genconfigOnly)
|
||||
{
|
||||
if(!llarp_ensure_config(conffname.c_str(), basedir.string().c_str(), overWrite,
|
||||
asRouter))
|
||||
if(!llarp_ensure_config(conffname.c_str(), basedir.string().c_str(),
|
||||
overWrite, asRouter))
|
||||
return 1;
|
||||
}
|
||||
else
|
||||
|
|
|
@ -25,8 +25,7 @@ namespace llarp
|
|||
{
|
||||
}
|
||||
|
||||
void
|
||||
BaseSession::HandlePathDied(path::Path_ptr)
|
||||
void BaseSession::HandlePathDied(path::Path_ptr)
|
||||
{
|
||||
}
|
||||
|
||||
|
@ -135,8 +134,9 @@ namespace llarp
|
|||
{
|
||||
if(success)
|
||||
{
|
||||
auto self = shared_from_this();
|
||||
for(auto& f : m_PendingCallbacks)
|
||||
f(this);
|
||||
f(self);
|
||||
}
|
||||
else
|
||||
{
|
||||
|
@ -161,6 +161,7 @@ namespace llarp
|
|||
}
|
||||
};
|
||||
ForEachPath(sendExitClose);
|
||||
router->pathContext().RemovePathSet(shared_from_this());
|
||||
return llarp::path::Builder::Stop();
|
||||
}
|
||||
|
||||
|
|
|
@ -15,10 +15,13 @@ namespace llarp
|
|||
{
|
||||
struct BaseSession;
|
||||
|
||||
using SessionReadyFunc = std::function< void(BaseSession*) >;
|
||||
using BaseSession_ptr = std::shared_ptr< BaseSession >;
|
||||
|
||||
using SessionReadyFunc = std::function< void(BaseSession_ptr) >;
|
||||
|
||||
/// a persisting exit session with an exit router
|
||||
struct BaseSession : public llarp::path::Builder
|
||||
struct BaseSession : public llarp::path::Builder,
|
||||
public std::enable_shared_from_this< BaseSession >
|
||||
{
|
||||
static constexpr size_t MaxUpstreamQueueLength = 256;
|
||||
static constexpr llarp_time_t LifeSpan = 60 * 10 * 1000;
|
||||
|
@ -29,6 +32,12 @@ namespace llarp
|
|||
|
||||
virtual ~BaseSession();
|
||||
|
||||
std::shared_ptr< path::PathSet >
|
||||
GetSelf() override
|
||||
{
|
||||
return shared_from_this();
|
||||
}
|
||||
|
||||
util::StatusObject
|
||||
ExtractStatus() const;
|
||||
|
||||
|
|
|
@ -552,14 +552,13 @@ namespace llarp
|
|||
huint32_t ip = GetIPForIdent(pubKey);
|
||||
if(m_SNodeKeys.emplace(pubKey).second)
|
||||
{
|
||||
// this is a new service node make an outbound session to them
|
||||
m_SNodeSessions.emplace(
|
||||
auto session = std::make_shared< exit::SNodeSession >(
|
||||
other,
|
||||
std::unique_ptr< exit::SNodeSession >(new exit::SNodeSession(
|
||||
other,
|
||||
std::bind(&ExitEndpoint::QueueSNodePacket, this,
|
||||
std::placeholders::_1, ip),
|
||||
GetRouter(), 2, 1, true)));
|
||||
std::bind(&ExitEndpoint::QueueSNodePacket, this,
|
||||
std::placeholders::_1, ip),
|
||||
GetRouter(), 2, 1, true);
|
||||
// this is a new service node make an outbound session to them
|
||||
m_SNodeSessions.emplace(other, session);
|
||||
}
|
||||
return ip;
|
||||
}
|
||||
|
@ -625,7 +624,10 @@ namespace llarp
|
|||
if(itr->second->IsExpired(now))
|
||||
itr = m_SNodeSessions.erase(itr);
|
||||
else
|
||||
{
|
||||
itr->second->Tick(now);
|
||||
++itr;
|
||||
}
|
||||
}
|
||||
}
|
||||
{
|
||||
|
|
|
@ -147,7 +147,7 @@ namespace llarp
|
|||
SNodes_t m_SNodeKeys;
|
||||
|
||||
using SNodeSessions_t =
|
||||
std::unordered_map< RouterID, std::unique_ptr< exit::SNodeSession >,
|
||||
std::unordered_map< RouterID, std::shared_ptr< exit::SNodeSession >,
|
||||
RouterID::Hash >;
|
||||
/// snode sessions we are talking to directly
|
||||
SNodeSessions_t m_SNodeSessions;
|
||||
|
|
|
@ -7,7 +7,9 @@ namespace llarp
|
|||
{
|
||||
namespace handlers
|
||||
{
|
||||
struct NullEndpoint final : public llarp::service::Endpoint
|
||||
struct NullEndpoint final
|
||||
: public llarp::service::Endpoint,
|
||||
public std::enable_shared_from_this< NullEndpoint >
|
||||
{
|
||||
NullEndpoint(const std::string &name, AbstractRouter *r,
|
||||
llarp::service::Context *parent)
|
||||
|
@ -20,6 +22,12 @@ namespace llarp
|
|||
return true;
|
||||
}
|
||||
|
||||
path::PathSet_ptr
|
||||
GetSelf() override
|
||||
{
|
||||
return shared_from_this();
|
||||
}
|
||||
|
||||
huint32_t
|
||||
ObtainIPForAddr(const AlignedBuffer< 32 > &, bool) override
|
||||
{
|
||||
|
|
|
@ -102,11 +102,11 @@ namespace llarp
|
|||
llarp::LogError(Name(), " bad exit router key: ", v);
|
||||
return false;
|
||||
}
|
||||
m_Exit.reset(new llarp::exit::ExitSession(
|
||||
m_Exit = std::make_shared< llarp::exit::ExitSession >(
|
||||
exitRouter,
|
||||
std::bind(&TunEndpoint::QueueInboundPacketForExit, this,
|
||||
std::placeholders::_1),
|
||||
router, m_NumPaths, numHops));
|
||||
router, m_NumPaths, numHops);
|
||||
llarp::LogInfo(Name(), " using exit at ", exitRouter);
|
||||
}
|
||||
if(k == "local-dns")
|
||||
|
@ -349,11 +349,11 @@ namespace llarp
|
|||
else if(addr.FromString(qname, ".snode"))
|
||||
{
|
||||
dns::Message *replyMsg = new dns::Message(std::move(msg));
|
||||
EnsurePathToSNode(addr.as_array(),
|
||||
[=](const RouterID &remote, exit::BaseSession *s) {
|
||||
SendDNSReply(remote, s, replyMsg, reply, true,
|
||||
isV6);
|
||||
});
|
||||
EnsurePathToSNode(
|
||||
addr.as_array(),
|
||||
[=](const RouterID &remote, exit::BaseSession_ptr s) {
|
||||
SendDNSReply(remote, s, replyMsg, reply, true, isV6);
|
||||
});
|
||||
return true;
|
||||
}
|
||||
else
|
||||
|
@ -580,7 +580,10 @@ namespace llarp
|
|||
// call tun code in endpoint logic in case of network isolation
|
||||
// EndpointLogic()->queue_job({this, handleTickTun});
|
||||
if(m_Exit)
|
||||
{
|
||||
EnsureRouterIsKnown(m_Exit->Endpoint());
|
||||
m_Exit->Tick(now);
|
||||
}
|
||||
Endpoint::Tick(now);
|
||||
}
|
||||
|
||||
|
|
|
@ -20,12 +20,20 @@ namespace llarp
|
|||
static const char DefaultTunDstAddr[] = "10.10.0.1";
|
||||
static const char DefaultTunSrcAddr[] = "10.10.0.2";
|
||||
|
||||
struct TunEndpoint : public service::Endpoint, public dns::IQueryHandler
|
||||
struct TunEndpoint : public service::Endpoint,
|
||||
public dns::IQueryHandler,
|
||||
public std::enable_shared_from_this< TunEndpoint >
|
||||
{
|
||||
TunEndpoint(const std::string& nickname, AbstractRouter* r,
|
||||
llarp::service::Context* parent);
|
||||
~TunEndpoint();
|
||||
|
||||
path::PathSet_ptr
|
||||
GetSelf() override
|
||||
{
|
||||
return shared_from_this();
|
||||
}
|
||||
|
||||
virtual bool
|
||||
SetOption(const std::string& k, const std::string& v) override;
|
||||
|
||||
|
@ -198,7 +206,7 @@ namespace llarp
|
|||
|
||||
template < typename Addr_t, typename Endpoint_t >
|
||||
void
|
||||
SendDNSReply(Addr_t addr, Endpoint_t* ctx, dns::Message* query,
|
||||
SendDNSReply(Addr_t addr, Endpoint_t ctx, dns::Message* query,
|
||||
std::function< void(dns::Message) > reply, bool snode,
|
||||
bool sendIPv6)
|
||||
{
|
||||
|
|
|
@ -270,50 +270,34 @@ namespace llarp
|
|||
void
|
||||
PathContext::ExpirePaths(llarp_time_t now)
|
||||
{
|
||||
util::Lock lock(&m_TransitPaths.first);
|
||||
auto& map = m_TransitPaths.second;
|
||||
auto itr = map.begin();
|
||||
while(itr != map.end())
|
||||
{
|
||||
if(itr->second->Expired(now))
|
||||
util::Lock lock(&m_TransitPaths.first);
|
||||
auto& map = m_TransitPaths.second;
|
||||
auto itr = map.begin();
|
||||
while(itr != map.end())
|
||||
{
|
||||
itr = map.erase(itr);
|
||||
if(itr->second->Expired(now))
|
||||
{
|
||||
itr = map.erase(itr);
|
||||
}
|
||||
else
|
||||
++itr;
|
||||
}
|
||||
else
|
||||
++itr;
|
||||
}
|
||||
|
||||
for(auto& builder : m_PathBuilders)
|
||||
{
|
||||
if(builder)
|
||||
builder->ExpirePaths(now);
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
PathContext::BuildPaths(llarp_time_t now)
|
||||
{
|
||||
for(auto& builder : m_PathBuilders)
|
||||
{
|
||||
if(builder->ShouldBuildMore(now))
|
||||
util::Lock lock(&m_OurPaths.first);
|
||||
auto& map = m_OurPaths.second;
|
||||
for(auto& item : map)
|
||||
{
|
||||
builder->BuildOne();
|
||||
item.second->ExpirePaths(now);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
PathContext::TickPaths(llarp_time_t now)
|
||||
{
|
||||
for(auto& builder : m_PathBuilders)
|
||||
builder->Tick(now, m_Router);
|
||||
}
|
||||
|
||||
routing::MessageHandler_ptr
|
||||
PathContext::GetHandler(const PathID_t& id)
|
||||
{
|
||||
routing::MessageHandler_ptr h = nullptr;
|
||||
auto pathset = GetLocalPathSet(id);
|
||||
auto pathset = GetLocalPathSet(id);
|
||||
if(pathset)
|
||||
{
|
||||
h = pathset->GetPathByID(id);
|
||||
|
@ -334,12 +318,6 @@ namespace llarp
|
|||
return nullptr;
|
||||
}
|
||||
|
||||
void
|
||||
PathContext::AddPathBuilder(Builder_ptr ctx)
|
||||
{
|
||||
m_PathBuilders.emplace_back(ctx);
|
||||
}
|
||||
|
||||
void
|
||||
PathContext::RemovePathSet(PathSet_ptr set)
|
||||
{
|
||||
|
@ -355,13 +333,6 @@ namespace llarp
|
|||
}
|
||||
}
|
||||
|
||||
void
|
||||
PathContext::RemovePathBuilder(Builder_ptr ctx)
|
||||
{
|
||||
m_PathBuilders.remove(ctx);
|
||||
RemovePathSet(ctx);
|
||||
}
|
||||
|
||||
std::ostream&
|
||||
TransitHop::print(std::ostream& stream, int level, int spaces) const
|
||||
{
|
||||
|
@ -906,7 +877,7 @@ namespace llarp
|
|||
bool
|
||||
Path::InformExitResult(llarp_time_t B)
|
||||
{
|
||||
auto self = shared_from_this();
|
||||
auto self = shared_from_this();
|
||||
bool result = true;
|
||||
for(const auto& hook : m_ObtainedExitHooks)
|
||||
result &= hook(self, B);
|
||||
|
|
|
@ -149,7 +149,7 @@ namespace llarp
|
|||
uint64_t m_SequenceNum = 0;
|
||||
};
|
||||
|
||||
using HopHandler_ptr = std::shared_ptr<IHopHandler>;
|
||||
using HopHandler_ptr = std::shared_ptr< IHopHandler >;
|
||||
|
||||
struct TransitHop : public IHopHandler, public routing::IMessageHandler
|
||||
{
|
||||
|
@ -303,7 +303,9 @@ namespace llarp
|
|||
};
|
||||
|
||||
/// A path we made
|
||||
struct Path : public IHopHandler, public routing::IMessageHandler, public std::enable_shared_from_this<Path>
|
||||
struct Path : public IHopHandler,
|
||||
public routing::IMessageHandler,
|
||||
public std::enable_shared_from_this< Path >
|
||||
{
|
||||
using BuildResultHookFunc = std::function< void(Path_ptr) >;
|
||||
using CheckForDeadFunc = std::function< bool(Path_ptr, llarp_time_t) >;
|
||||
|
@ -321,7 +323,7 @@ namespace llarp
|
|||
|
||||
HopList hops;
|
||||
|
||||
PathSet *const m_PathSet;
|
||||
PathSet* const m_PathSet;
|
||||
|
||||
service::Introduction intro;
|
||||
|
||||
|
@ -579,19 +581,6 @@ namespace llarp
|
|||
void
|
||||
ExpirePaths(llarp_time_t now);
|
||||
|
||||
/// called from router tick function
|
||||
/// builds all paths we need to build at current tick
|
||||
void
|
||||
BuildPaths(llarp_time_t now);
|
||||
|
||||
/// called from router tick function
|
||||
void
|
||||
TickPaths(llarp_time_t now);
|
||||
|
||||
/// track a path builder with this context
|
||||
void
|
||||
AddPathBuilder(Builder_ptr set);
|
||||
|
||||
void
|
||||
AllowTransit();
|
||||
|
||||
|
@ -644,9 +633,6 @@ namespace llarp
|
|||
void
|
||||
AddOwnPath(PathSet_ptr set, Path_ptr p);
|
||||
|
||||
void
|
||||
RemovePathBuilder(Builder_ptr ctx);
|
||||
|
||||
void
|
||||
RemovePathSet(PathSet_ptr set);
|
||||
|
||||
|
@ -689,9 +675,7 @@ namespace llarp
|
|||
private:
|
||||
AbstractRouter* m_Router;
|
||||
SyncTransitMap_t m_TransitPaths;
|
||||
SyncTransitMap_t m_Paths;
|
||||
SyncOwnedPathsMap_t m_OurPaths;
|
||||
std::list< Builder_ptr > m_PathBuilders;
|
||||
bool m_AllowTransit;
|
||||
};
|
||||
} // namespace path
|
||||
|
|
|
@ -16,7 +16,7 @@ namespace llarp
|
|||
struct AsyncPathKeyExchangeContext
|
||||
{
|
||||
typedef path::Path_ptr Path_t;
|
||||
typedef path::Builder_ptr PathSet_t;
|
||||
typedef path::PathSet_ptr PathSet_t;
|
||||
PathSet_t pathset = nullptr;
|
||||
Path_t path = nullptr;
|
||||
typedef std::function< void(AsyncPathKeyExchangeContext< User >*) > Handler;
|
||||
|
@ -79,9 +79,8 @@ namespace llarp
|
|||
else
|
||||
{
|
||||
hop.upstream = ctx->path->hops[ctx->idx].rc.pubkey;
|
||||
if(ctx->pathset->ShouldBundleRC())
|
||||
record.nextRC =
|
||||
std::make_unique< RouterContact >(ctx->path->hops[ctx->idx].rc);
|
||||
record.nextRC =
|
||||
std::make_unique< RouterContact >(ctx->path->hops[ctx->idx].rc);
|
||||
}
|
||||
// build record
|
||||
|
||||
|
@ -166,8 +165,6 @@ namespace llarp
|
|||
else
|
||||
LogError(ctx->pathset->Name(), " failed to send LRCM to ", remote);
|
||||
}
|
||||
// decrement keygen counter
|
||||
ctx->pathset->keygens--;
|
||||
}
|
||||
|
||||
namespace path
|
||||
|
@ -176,21 +173,27 @@ namespace llarp
|
|||
size_t pathNum, size_t hops)
|
||||
: path::PathSet(pathNum), router(p_router), dht(p_dht), numHops(hops)
|
||||
{
|
||||
p_router->pathContext().AddPathBuilder(shared_from_this());
|
||||
p_router->crypto()->encryption_keygen(enckey);
|
||||
_run.store(true);
|
||||
keygens.store(0);
|
||||
}
|
||||
|
||||
Builder::~Builder()
|
||||
{
|
||||
}
|
||||
|
||||
void
|
||||
Builder::Tick(llarp_time_t now)
|
||||
{
|
||||
ExpirePaths(now);
|
||||
if(ShouldBuildMore(now))
|
||||
BuildOne();
|
||||
TickPaths(now, router);
|
||||
}
|
||||
|
||||
util::StatusObject
|
||||
Builder::ExtractStatus() const
|
||||
{
|
||||
util::StatusObject obj{{"keygens", uint64_t(keygens.load())},
|
||||
{"numHops", uint64_t(numHops)},
|
||||
util::StatusObject obj{{"numHops", uint64_t(numHops)},
|
||||
{"numPaths", uint64_t(m_NumPaths)}};
|
||||
std::vector< util::StatusObject > pathObjs;
|
||||
std::transform(m_Paths.begin(), m_Paths.end(),
|
||||
|
@ -243,7 +246,6 @@ namespace llarp
|
|||
Builder::Stop()
|
||||
{
|
||||
_run.store(false);
|
||||
router->pathContext().RemovePathBuilder(shared_from_this());
|
||||
return true;
|
||||
}
|
||||
|
||||
|
@ -256,9 +258,7 @@ namespace llarp
|
|||
bool
|
||||
Builder::ShouldRemove() const
|
||||
{
|
||||
if(!IsStopped())
|
||||
return false;
|
||||
return keygens.load() > 0;
|
||||
return IsStopped();
|
||||
}
|
||||
|
||||
const SecretKey&
|
||||
|
@ -337,10 +337,10 @@ namespace llarp
|
|||
AsyncPathKeyExchangeContext< Builder >* ctx =
|
||||
new AsyncPathKeyExchangeContext< Builder >(router->crypto());
|
||||
ctx->router = router;
|
||||
ctx->pathset = shared_from_this();
|
||||
auto path = std::make_shared<path::Path>(hops, this, roles);
|
||||
path->SetBuildResultHook([this](Path_ptr p) { this->HandlePathBuilt(p); });
|
||||
++keygens;
|
||||
ctx->pathset = GetSelf();
|
||||
auto path = std::make_shared< path::Path >(hops, this, roles);
|
||||
path->SetBuildResultHook(
|
||||
[this](Path_ptr p) { this->HandlePathBuilt(p); });
|
||||
ctx->AsyncGenerateKeys(path, router->logic(), router->threadpool(), this,
|
||||
&PathBuilderKeysGenerated);
|
||||
}
|
||||
|
|
|
@ -15,7 +15,7 @@ namespace llarp
|
|||
// milliseconds waiting between builds on a path
|
||||
constexpr llarp_time_t MIN_PATH_BUILD_INTERVAL = 1000;
|
||||
|
||||
struct Builder : public PathSet, std::enable_shared_from_this<Builder> // yes private scope
|
||||
struct Builder : public PathSet
|
||||
{
|
||||
protected:
|
||||
/// flag for PathSet::Stop()
|
||||
|
@ -29,9 +29,6 @@ namespace llarp
|
|||
llarp_time_t lastBuild = 0;
|
||||
llarp_time_t buildIntervalLimit = MIN_PATH_BUILD_INTERVAL;
|
||||
|
||||
// how many keygens are currently happening
|
||||
std::atomic< uint8_t > keygens;
|
||||
|
||||
/// construct
|
||||
Builder(AbstractRouter* p_router, llarp_dht_context* p_dht,
|
||||
size_t numPaths, size_t numHops);
|
||||
|
@ -75,8 +72,11 @@ namespace llarp
|
|||
llarp_time_t
|
||||
Now() const override;
|
||||
|
||||
virtual void
|
||||
Tick(llarp_time_t now) override;
|
||||
|
||||
void
|
||||
BuildOne(PathRole roles = ePathRoleAny);
|
||||
BuildOne(PathRole roles = ePathRoleAny) override;
|
||||
|
||||
void
|
||||
Build(const std::vector< RouterContact >& hops,
|
||||
|
@ -99,7 +99,7 @@ namespace llarp
|
|||
HandlePathBuildTimeout(Path_ptr p) override;
|
||||
};
|
||||
|
||||
using Builder_ptr = std::shared_ptr<Builder>;
|
||||
using Builder_ptr = std::shared_ptr< Builder >;
|
||||
|
||||
} // namespace path
|
||||
|
||||
|
|
|
@ -15,7 +15,7 @@ namespace llarp
|
|||
bool
|
||||
PathSet::ShouldBuildMore(llarp_time_t now) const
|
||||
{
|
||||
(void) now;
|
||||
(void)now;
|
||||
const auto building = NumInStatus(ePathBuilding);
|
||||
if(building > m_NumPaths)
|
||||
return false;
|
||||
|
@ -61,7 +61,7 @@ namespace llarp
|
|||
}
|
||||
|
||||
void
|
||||
PathSet::Tick(llarp_time_t now, AbstractRouter* r)
|
||||
PathSet::TickPaths(llarp_time_t now, AbstractRouter* r)
|
||||
{
|
||||
Lock_t l(&m_PathsMutex);
|
||||
for(auto& item : m_Paths)
|
||||
|
@ -115,7 +115,7 @@ namespace llarp
|
|||
{
|
||||
Lock_t l(&m_PathsMutex);
|
||||
Path_ptr chosen = nullptr;
|
||||
auto itr = m_Paths.begin();
|
||||
auto itr = m_Paths.begin();
|
||||
while(itr != m_Paths.end())
|
||||
{
|
||||
if(itr->second->IsReady() && itr->second->SupportsAnyRoles(roles))
|
||||
|
@ -138,7 +138,7 @@ namespace llarp
|
|||
{
|
||||
Lock_t l(&m_PathsMutex);
|
||||
Path_ptr chosen = nullptr;
|
||||
auto itr = m_Paths.begin();
|
||||
auto itr = m_Paths.begin();
|
||||
while(itr != m_Paths.end())
|
||||
{
|
||||
if(itr->second->IsReady() && itr->second->SupportsAnyRoles(roles))
|
||||
|
|
|
@ -56,7 +56,11 @@ namespace llarp
|
|||
// forward declare
|
||||
struct Path;
|
||||
|
||||
using Path_ptr = std::shared_ptr<Path>;
|
||||
using Path_ptr = std::shared_ptr< Path >;
|
||||
|
||||
struct PathSet;
|
||||
|
||||
using PathSet_ptr = std::shared_ptr< PathSet >;
|
||||
|
||||
/// a set of paths owned by an entity
|
||||
struct PathSet
|
||||
|
@ -65,9 +69,16 @@ namespace llarp
|
|||
/// @params numPaths the number of paths to maintain
|
||||
PathSet(size_t numPaths);
|
||||
|
||||
/// get a shared_ptr of ourself
|
||||
virtual PathSet_ptr
|
||||
GetSelf() = 0;
|
||||
|
||||
virtual void
|
||||
BuildOne(PathRole roles = ePathRoleAny) = 0;
|
||||
|
||||
/// tick owned paths
|
||||
void
|
||||
Tick(llarp_time_t now, AbstractRouter* r);
|
||||
virtual void
|
||||
Tick(llarp_time_t now) = 0;
|
||||
|
||||
/// count the number of paths that will exist at this timestamp in future
|
||||
size_t
|
||||
|
@ -210,7 +221,10 @@ namespace llarp
|
|||
size_t m_NumPaths;
|
||||
|
||||
void
|
||||
ForEachPath(std::function< void(const Path_ptr &) > visit) const
|
||||
TickPaths(llarp_time_t now, AbstractRouter* r);
|
||||
|
||||
void
|
||||
ForEachPath(std::function< void(const Path_ptr&) > visit) const
|
||||
{
|
||||
Lock_t lock(&m_PathsMutex);
|
||||
auto itr = m_Paths.begin();
|
||||
|
@ -231,15 +245,14 @@ namespace llarp
|
|||
return RouterID::Hash()(i.first) ^ PathID_t::Hash()(i.second);
|
||||
}
|
||||
};
|
||||
using Mtx_t = util::NullMutex;
|
||||
using Lock_t = util::NullLock;
|
||||
using PathMap_t = std::unordered_map< PathInfo_t, Path_ptr, PathInfoHash >;
|
||||
using Mtx_t = util::NullMutex;
|
||||
using Lock_t = util::NullLock;
|
||||
using PathMap_t =
|
||||
std::unordered_map< PathInfo_t, Path_ptr, PathInfoHash >;
|
||||
mutable Mtx_t m_PathsMutex;
|
||||
PathMap_t m_Paths;
|
||||
};
|
||||
|
||||
using PathSet_ptr = std::shared_ptr<PathSet>;
|
||||
|
||||
} // namespace path
|
||||
} // namespace llarp
|
||||
|
||||
|
|
|
@ -1073,9 +1073,11 @@ namespace llarp
|
|||
ServiceNodeLookupRouterWhenExpired(remote);
|
||||
return;
|
||||
}
|
||||
_hiddenServiceContext.ForEachService([=](const std::string &, const std::shared_ptr<service::Endpoint> & ep) -> bool {
|
||||
return !ep->LookupRouterAnon(remote);
|
||||
});
|
||||
_hiddenServiceContext.ForEachService(
|
||||
[=](const std::string &,
|
||||
const std::shared_ptr< service::Endpoint > &ep) -> bool {
|
||||
return !ep->LookupRouterAnon(remote);
|
||||
});
|
||||
}
|
||||
|
||||
bool
|
||||
|
@ -1125,7 +1127,7 @@ namespace llarp
|
|||
return !IsBootstrapNode(rc.pubkey);
|
||||
});
|
||||
}
|
||||
paths.TickPaths(now);
|
||||
// expire transit paths
|
||||
paths.ExpirePaths(now);
|
||||
|
||||
{
|
||||
|
@ -1183,9 +1185,10 @@ namespace llarp
|
|||
}
|
||||
|
||||
if(!IsServiceNode())
|
||||
{
|
||||
_hiddenServiceContext.Tick(now);
|
||||
}
|
||||
|
||||
paths.BuildPaths(now);
|
||||
_exitContext.Tick(now);
|
||||
if(rpcCaller)
|
||||
rpcCaller->Tick(now);
|
||||
|
|
|
@ -36,55 +36,55 @@ namespace llarp
|
|||
{
|
||||
virtual bool
|
||||
HandleObtainExitMessage(const ObtainExitMessage& msg,
|
||||
AbstractRouter *r) = 0;
|
||||
AbstractRouter* r) = 0;
|
||||
|
||||
virtual bool
|
||||
HandleGrantExitMessage(const GrantExitMessage& msg,
|
||||
AbstractRouter *r) = 0;
|
||||
AbstractRouter* r) = 0;
|
||||
|
||||
virtual bool
|
||||
HandleRejectExitMessage(const RejectExitMessage& msg,
|
||||
AbstractRouter *r) = 0;
|
||||
AbstractRouter* r) = 0;
|
||||
|
||||
virtual bool
|
||||
HandleTransferTrafficMessage(const TransferTrafficMessage& msg,
|
||||
AbstractRouter *r) = 0;
|
||||
AbstractRouter* r) = 0;
|
||||
|
||||
virtual bool
|
||||
HandleUpdateExitMessage(const UpdateExitMessage& msg,
|
||||
AbstractRouter *r) = 0;
|
||||
AbstractRouter* r) = 0;
|
||||
|
||||
virtual bool
|
||||
HandleUpdateExitVerifyMessage(const UpdateExitVerifyMessage& msg,
|
||||
AbstractRouter *r) = 0;
|
||||
AbstractRouter* r) = 0;
|
||||
|
||||
virtual bool
|
||||
HandleCloseExitMessage(const CloseExitMessage& msg,
|
||||
AbstractRouter *r) = 0;
|
||||
AbstractRouter* r) = 0;
|
||||
|
||||
virtual bool
|
||||
HandleDataDiscardMessage(const DataDiscardMessage& msg,
|
||||
AbstractRouter *r) = 0;
|
||||
AbstractRouter* r) = 0;
|
||||
|
||||
virtual bool
|
||||
HandlePathTransferMessage(const PathTransferMessage& msg,
|
||||
AbstractRouter *r) = 0;
|
||||
AbstractRouter* r) = 0;
|
||||
|
||||
virtual bool
|
||||
HandleHiddenServiceFrame(const service::ProtocolFrame& msg) = 0;
|
||||
|
||||
virtual bool
|
||||
HandlePathConfirmMessage(const PathConfirmMessage& msg,
|
||||
AbstractRouter *r) = 0;
|
||||
AbstractRouter* r) = 0;
|
||||
|
||||
virtual bool
|
||||
HandlePathLatencyMessage(const PathLatencyMessage& msg,
|
||||
AbstractRouter *r) = 0;
|
||||
AbstractRouter* r) = 0;
|
||||
virtual bool
|
||||
HandleDHTMessage(const dht::IMessage& msg, AbstractRouter *r) = 0;
|
||||
HandleDHTMessage(const dht::IMessage& msg, AbstractRouter* r) = 0;
|
||||
};
|
||||
|
||||
using MessageHandler_ptr = std::shared_ptr<IMessageHandler>;
|
||||
using MessageHandler_ptr = std::shared_ptr< IMessageHandler >;
|
||||
|
||||
} // namespace routing
|
||||
} // namespace llarp
|
||||
|
|
|
@ -102,7 +102,8 @@ namespace llarp
|
|||
expired.emplace_back(rc.pubkey);
|
||||
return true;
|
||||
});
|
||||
ForEachService([&](const std::string &, const std::shared_ptr<Endpoint> &ep) -> bool {
|
||||
ForEachService([&](const std::string &,
|
||||
const std::shared_ptr< Endpoint > &ep) -> bool {
|
||||
// TODO: we need to stop looking up service nodes that are gone forever
|
||||
// how do?
|
||||
for(const auto &k : expired)
|
||||
|
@ -198,22 +199,30 @@ namespace llarp
|
|||
keyfile = option.second;
|
||||
}
|
||||
|
||||
std::unique_ptr< service::Endpoint > service;
|
||||
service::Endpoint_ptr service;
|
||||
|
||||
static std::map<
|
||||
std::string,
|
||||
std::function< std::unique_ptr< service::Endpoint >(
|
||||
std::function< service::Endpoint_ptr(
|
||||
const std::string &, AbstractRouter *, service::Context *) > >
|
||||
endpointConstructors = {
|
||||
{"tun",
|
||||
[](const std::string &nick, AbstractRouter *r,
|
||||
service::Context *c) -> std::unique_ptr< service::Endpoint > {
|
||||
return std::make_unique< handlers::TunEndpoint >(nick, r, c);
|
||||
service::Context *c) -> service::Endpoint_ptr {
|
||||
return std::make_shared< handlers::TunEndpoint >(nick, r, c);
|
||||
}},
|
||||
{"ios-tun",
|
||||
[](const std::string &nick, AbstractRouter *r,
|
||||
service::Context *c) -> service::Endpoint_ptr {
|
||||
return nullptr;
|
||||
/// SOOOOOOON (tm)
|
||||
// return std::make_shared<handlers::IOSTunEndpoint>(nick, r,
|
||||
// c);
|
||||
}},
|
||||
{"null",
|
||||
[](const std::string &nick, AbstractRouter *r,
|
||||
service::Context *c) -> std::unique_ptr< service::Endpoint > {
|
||||
return std::make_unique< handlers::NullEndpoint >(nick, r, c);
|
||||
service::Context *c) -> service::Endpoint_ptr {
|
||||
return std::make_shared< handlers::NullEndpoint >(nick, r, c);
|
||||
}}};
|
||||
|
||||
{
|
||||
|
@ -227,18 +236,22 @@ namespace llarp
|
|||
|
||||
// construct
|
||||
service = itr->second(conf.first, m_Router, this);
|
||||
|
||||
// if ephemeral, then we need to regen key
|
||||
// if privkey file, then set it and load it
|
||||
if(keyfile != "")
|
||||
if(service)
|
||||
{
|
||||
service->SetOption("keyfile", keyfile);
|
||||
// load keyfile, so we have the correct name for logging
|
||||
// if ephemeral, then we need to regen key
|
||||
// if privkey file, then set it and load it
|
||||
if(keyfile != "")
|
||||
{
|
||||
service->SetOption("keyfile", keyfile);
|
||||
// load keyfile, so we have the correct name for logging
|
||||
}
|
||||
LogInfo("Establishing endpoint identity");
|
||||
service->LoadKeyFile(); // only start endpoint not tun
|
||||
// now Name() will be correct
|
||||
}
|
||||
LogInfo("Establishing endpoint identity");
|
||||
service->LoadKeyFile(); // only start endpoint not tun
|
||||
// now Name() will be correct
|
||||
}
|
||||
if(service == nullptr)
|
||||
return false;
|
||||
// configure
|
||||
for(const auto &option : conf.second)
|
||||
{
|
||||
|
@ -259,7 +272,7 @@ namespace llarp
|
|||
if(service->Start())
|
||||
{
|
||||
LogInfo("autostarting hidden service endpoint ", service->Name());
|
||||
m_Endpoints.emplace(conf.first, std::move(service));
|
||||
m_Endpoints.emplace(conf.first, service);
|
||||
return true;
|
||||
}
|
||||
LogError("failed to start hidden service endpoint ", conf.first);
|
||||
|
@ -268,7 +281,7 @@ namespace llarp
|
|||
else
|
||||
{
|
||||
LogInfo("added hidden service endpoint ", service->Name());
|
||||
m_Endpoints.emplace(conf.first, std::move(service));
|
||||
m_Endpoints.emplace(conf.first, service);
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
|
|
@ -31,16 +31,15 @@ namespace llarp
|
|||
bool
|
||||
hasEndpoints();
|
||||
|
||||
|
||||
bool
|
||||
FindBestAddressFor(const AlignedBuffer< 32 > &addr, bool isSNode,
|
||||
huint32_t &);
|
||||
|
||||
/// function visitor returns false to prematurely break iteration
|
||||
void
|
||||
ForEachService(std::function< bool(const std::string &,
|
||||
const Endpoint_ptr &) >
|
||||
visit) const;
|
||||
ForEachService(
|
||||
std::function< bool(const std::string &, const Endpoint_ptr &) >
|
||||
visit) const;
|
||||
|
||||
/// add default endpoint with options
|
||||
bool
|
||||
|
|
|
@ -240,6 +240,7 @@ namespace llarp
|
|||
void
|
||||
Endpoint::Tick(llarp_time_t now)
|
||||
{
|
||||
path::Builder::Tick(now);
|
||||
// publish descriptors
|
||||
if(ShouldPublishDescriptors(now))
|
||||
{
|
||||
|
@ -256,7 +257,8 @@ namespace llarp
|
|||
auto itr = m_SNodeSessions.begin();
|
||||
while(itr != m_SNodeSessions.end())
|
||||
{
|
||||
if(itr->second->ShouldRemove() && itr->second->IsStopped())
|
||||
itr->second->Tick(now);
|
||||
if(itr->second->ShouldRemove())
|
||||
{
|
||||
itr = m_SNodeSessions.erase(itr);
|
||||
continue;
|
||||
|
@ -362,6 +364,7 @@ namespace llarp
|
|||
auto itr = m_DeadSessions.begin();
|
||||
while(itr != m_DeadSessions.end())
|
||||
{
|
||||
itr->second->Tick(now);
|
||||
if(itr->second->IsDone(now))
|
||||
itr = m_DeadSessions.erase(itr);
|
||||
else
|
||||
|
@ -373,14 +376,17 @@ namespace llarp
|
|||
auto itr = m_RemoteSessions.begin();
|
||||
while(itr != m_RemoteSessions.end())
|
||||
{
|
||||
if(itr->second->Tick(now))
|
||||
if(itr->second->Pump(now))
|
||||
{
|
||||
itr->second->Stop();
|
||||
m_DeadSessions.emplace(itr->first, std::move(itr->second));
|
||||
itr = m_RemoteSessions.erase(itr);
|
||||
}
|
||||
else
|
||||
{
|
||||
itr->second->Tick(now);
|
||||
++itr;
|
||||
}
|
||||
}
|
||||
}
|
||||
// expire convotags
|
||||
|
@ -726,7 +732,7 @@ namespace llarp
|
|||
// make sure we have all paths that are established
|
||||
// in our introset
|
||||
bool should = false;
|
||||
ForEachPath([&](const path::Path_ptr & p) {
|
||||
ForEachPath([&](const path::Path_ptr& p) {
|
||||
if(!p->IsReady())
|
||||
return;
|
||||
for(const auto& i : m_IntroSet.I)
|
||||
|
@ -797,7 +803,7 @@ namespace llarp
|
|||
}
|
||||
|
||||
auto it = m_RemoteSessions.emplace(
|
||||
addr, std::make_unique< OutboundContext >(introset, this));
|
||||
addr, std::make_shared< OutboundContext >(introset, this));
|
||||
LogInfo("Created New outbound context for ", addr.ToString());
|
||||
|
||||
// inform pending
|
||||
|
@ -879,7 +885,8 @@ namespace llarp
|
|||
}
|
||||
|
||||
bool
|
||||
Endpoint::HandleDataDrop(path::Path_ptr p, const PathID_t& dst, uint64_t seq)
|
||||
Endpoint::HandleDataDrop(path::Path_ptr p, const PathID_t& dst,
|
||||
uint64_t seq)
|
||||
{
|
||||
LogWarn(Name(), " message ", seq, " dropped by endpoint ", p->Endpoint(),
|
||||
" via ", dst);
|
||||
|
@ -964,7 +971,8 @@ namespace llarp
|
|||
return true;
|
||||
}
|
||||
if(!frame.AsyncDecryptAndVerify(EndpointLogic(), GetCrypto(), p,
|
||||
CryptoWorker(), m_Identity, m_DataHandler))
|
||||
CryptoWorker(), m_Identity,
|
||||
m_DataHandler))
|
||||
|
||||
{
|
||||
// send discard
|
||||
|
@ -974,17 +982,15 @@ namespace llarp
|
|||
f.F = p->intro.pathID;
|
||||
if(!f.Sign(GetCrypto(), m_Identity))
|
||||
return false;
|
||||
auto d = std::make_shared<const routing::PathTransferMessage>(f, frame.F);
|
||||
RouterLogic()->queue_func([=]() {
|
||||
p->SendRoutingMessage(*d, router);
|
||||
});
|
||||
auto d =
|
||||
std::make_shared< const routing::PathTransferMessage >(f, frame.F);
|
||||
RouterLogic()->queue_func([=]() { p->SendRoutingMessage(*d, router); });
|
||||
return true;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
void
|
||||
Endpoint::HandlePathDied(path::Path_ptr)
|
||||
void Endpoint::HandlePathDied(path::Path_ptr)
|
||||
{
|
||||
RegenAndPublishIntroSet(Now(), true);
|
||||
}
|
||||
|
@ -1073,21 +1079,20 @@ namespace llarp
|
|||
using namespace std::placeholders;
|
||||
if(m_SNodeSessions.count(snode) == 0)
|
||||
{
|
||||
auto themIP = ObtainIPForAddr(snode, true);
|
||||
m_SNodeSessions.emplace(
|
||||
auto themIP = ObtainIPForAddr(snode, true);
|
||||
auto session = std::make_shared< exit::SNodeSession >(
|
||||
snode,
|
||||
std::make_unique< exit::SNodeSession >(
|
||||
snode,
|
||||
std::bind(&Endpoint::HandleWriteIPPacket, this, _1,
|
||||
[themIP]() -> huint32_t { return themIP; }),
|
||||
m_Router, 2, numHops));
|
||||
std::bind(&Endpoint::HandleWriteIPPacket, this, _1,
|
||||
[themIP]() -> huint32_t { return themIP; }),
|
||||
m_Router, 2, numHops);
|
||||
m_SNodeSessions.emplace(snode, session);
|
||||
}
|
||||
auto range = m_SNodeSessions.equal_range(snode);
|
||||
auto itr = range.first;
|
||||
while(itr != range.second)
|
||||
{
|
||||
if(itr->second->IsReady())
|
||||
h(snode, itr->second.get());
|
||||
h(snode, itr->second);
|
||||
else
|
||||
itr->second->AddReadyHook(std::bind(h, snode, _1));
|
||||
++itr;
|
||||
|
@ -1130,9 +1135,9 @@ namespace llarp
|
|||
auto itr = m_AddressToService.find(remote);
|
||||
if(itr != m_AddressToService.end())
|
||||
{
|
||||
auto transfer = std::make_shared<routing::PathTransferMessage>();
|
||||
auto transfer = std::make_shared< routing::PathTransferMessage >();
|
||||
ProtocolFrame& f = transfer->T;
|
||||
std::shared_ptr<path::Path> p;
|
||||
std::shared_ptr< path::Path > p;
|
||||
std::set< ConvoTag > tags;
|
||||
if(GetConvoTagsForService(itr->second, tags))
|
||||
{
|
||||
|
@ -1167,9 +1172,9 @@ namespace llarp
|
|||
m.proto = t;
|
||||
m.introReply = p->intro;
|
||||
PutReplyIntroFor(f.T, m.introReply);
|
||||
m.sender = m_Identity.pub;
|
||||
f.F = m.introReply.pathID;
|
||||
f.S = GetSeqNoForConvo(f.T);
|
||||
m.sender = m_Identity.pub;
|
||||
f.F = m.introReply.pathID;
|
||||
f.S = GetSeqNoForConvo(f.T);
|
||||
transfer->P = remoteIntro.pathID;
|
||||
if(!f.EncryptAndSign(Router()->crypto(), m, K, m_Identity))
|
||||
{
|
||||
|
@ -1178,9 +1183,8 @@ namespace llarp
|
|||
}
|
||||
LogDebug(Name(), " send ", data.sz, " via ", remoteIntro.router);
|
||||
auto router = Router();
|
||||
RouterLogic()->queue_func([=]() {
|
||||
p->SendRoutingMessage(*transfer, router);
|
||||
});
|
||||
RouterLogic()->queue_func(
|
||||
[=]() { p->SendRoutingMessage(*transfer, router); });
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
|
|
@ -66,7 +66,7 @@ namespace llarp
|
|||
SetOption(const std::string& k, const std::string& v);
|
||||
|
||||
virtual void
|
||||
Tick(llarp_time_t now);
|
||||
Tick(llarp_time_t now) override;
|
||||
|
||||
/// return true if we have a resolvable ip address
|
||||
virtual bool
|
||||
|
@ -92,14 +92,14 @@ namespace llarp
|
|||
Logic*
|
||||
EndpointLogic();
|
||||
|
||||
/// borrow endpoint's net loop for sending data to user on local network interface
|
||||
/// borrow endpoint's net loop for sending data to user on local network
|
||||
/// interface
|
||||
llarp_ev_loop_ptr
|
||||
EndpointNetLoop();
|
||||
|
||||
Crypto*
|
||||
GetCrypto();
|
||||
|
||||
|
||||
/// crypto worker threadpool
|
||||
llarp_threadpool*
|
||||
CryptoWorker();
|
||||
|
@ -239,7 +239,7 @@ namespace llarp
|
|||
uint64_t timeoutMS, bool lookupOnRandomPath = false);
|
||||
|
||||
using SNodeEnsureHook =
|
||||
std::function< void(RouterID, exit::BaseSession*) >;
|
||||
std::function< void(RouterID, exit::BaseSession_ptr) >;
|
||||
|
||||
/// ensure a path to a service node by public key
|
||||
void
|
||||
|
@ -346,7 +346,7 @@ namespace llarp
|
|||
protected:
|
||||
IDataHandler* m_DataHandler = nullptr;
|
||||
Identity m_Identity;
|
||||
std::unique_ptr< exit::BaseSession > m_Exit;
|
||||
std::shared_ptr< exit::BaseSession > m_Exit;
|
||||
hooks::Backend_ptr m_OnUp;
|
||||
hooks::Backend_ptr m_OnDown;
|
||||
hooks::Backend_ptr m_OnReady;
|
||||
|
@ -367,14 +367,14 @@ namespace llarp
|
|||
PendingTraffic m_PendingTraffic;
|
||||
|
||||
using Sessions =
|
||||
std::unordered_multimap< Address, std::unique_ptr< OutboundContext >,
|
||||
std::unordered_multimap< Address, std::shared_ptr< OutboundContext >,
|
||||
Address::Hash >;
|
||||
Sessions m_RemoteSessions;
|
||||
|
||||
Sessions m_DeadSessions;
|
||||
|
||||
using SNodeSessions = std::unordered_multimap<
|
||||
RouterID, std::unique_ptr< exit::BaseSession >, RouterID::Hash >;
|
||||
RouterID, std::shared_ptr< exit::BaseSession >, RouterID::Hash >;
|
||||
|
||||
SNodeSessions m_SNodeSessions;
|
||||
|
||||
|
@ -437,7 +437,7 @@ namespace llarp
|
|||
std::unordered_map< Tag, CachedTagResult, Tag::Hash > m_PrefetchedTags;
|
||||
};
|
||||
|
||||
using Endpoint_ptr = std::shared_ptr<Endpoint>;
|
||||
using Endpoint_ptr = std::shared_ptr< Endpoint >;
|
||||
|
||||
} // namespace service
|
||||
} // namespace llarp
|
||||
|
|
|
@ -25,10 +25,8 @@ namespace llarp
|
|||
auto msg = BuildRequestMessage();
|
||||
if(!msg)
|
||||
return false;
|
||||
endpoint = path->Endpoint();
|
||||
r->logic()->queue_func([=]() {
|
||||
path->SendRoutingMessage(*msg, r);
|
||||
});
|
||||
endpoint = path->Endpoint();
|
||||
r->logic()->queue_func([=]() { path->SendRoutingMessage(*msg, r); });
|
||||
return true;
|
||||
}
|
||||
} // namespace service
|
||||
|
|
|
@ -274,7 +274,7 @@ namespace llarp
|
|||
}
|
||||
|
||||
bool
|
||||
OutboundContext::Tick(llarp_time_t now)
|
||||
OutboundContext::Pump(llarp_time_t now)
|
||||
{
|
||||
// we are probably dead af
|
||||
if(m_LookupFails > 16 || m_BuildFails > 10)
|
||||
|
@ -480,7 +480,7 @@ namespace llarp
|
|||
{
|
||||
// figure out how many paths to this router we have
|
||||
size_t num = 0;
|
||||
ForEachPath([&](const path::Path_ptr & p) {
|
||||
ForEachPath([&](const path::Path_ptr& p) {
|
||||
if(p->Endpoint() == endpoint && p->IsReady())
|
||||
++num;
|
||||
});
|
||||
|
@ -491,7 +491,7 @@ namespace llarp
|
|||
if(num == 1)
|
||||
{
|
||||
num = 0;
|
||||
ForEachPath([&](const path::Path_ptr & p) {
|
||||
ForEachPath([&](const path::Path_ptr& p) {
|
||||
if(p->Endpoint() == endpoint)
|
||||
++num;
|
||||
});
|
||||
|
@ -521,7 +521,7 @@ namespace llarp
|
|||
m_NextIntro = picked;
|
||||
// check if we have a path to this router
|
||||
num = 0;
|
||||
ForEachPath([&](const path::Path_ptr & p) {
|
||||
ForEachPath([&](const path::Path_ptr& p) {
|
||||
if(p->Endpoint() == m_NextIntro.router)
|
||||
++num;
|
||||
});
|
||||
|
|
|
@ -15,7 +15,10 @@ namespace llarp
|
|||
struct Endpoint;
|
||||
|
||||
/// context needed to initiate an outbound hidden service session
|
||||
struct OutboundContext : public path::Builder, public SendContext
|
||||
struct OutboundContext
|
||||
: public path::Builder,
|
||||
public SendContext,
|
||||
public std::enable_shared_from_this< OutboundContext >
|
||||
{
|
||||
OutboundContext(const IntroSet& introSet, Endpoint* parent);
|
||||
~OutboundContext();
|
||||
|
@ -26,6 +29,12 @@ namespace llarp
|
|||
bool
|
||||
ShouldBundleRC() const override;
|
||||
|
||||
path::PathSet_ptr
|
||||
GetSelf() override
|
||||
{
|
||||
return shared_from_this();
|
||||
}
|
||||
|
||||
bool
|
||||
Stop() override;
|
||||
|
||||
|
@ -54,10 +63,10 @@ namespace llarp
|
|||
bool
|
||||
ShouldBuildMore(llarp_time_t now) const override;
|
||||
|
||||
/// tick internal state
|
||||
/// pump internal state
|
||||
/// return true to mark as dead
|
||||
bool
|
||||
Tick(llarp_time_t now);
|
||||
Pump(llarp_time_t now);
|
||||
|
||||
/// return true if it's safe to remove ourselves
|
||||
bool
|
||||
|
|
Loading…
Reference in New Issue