Archives
/
lokinet
mirror of https://github.com/oxen-io/lokinet
2
0
Fork 0
Code Issues Projects Releases Wiki Activity

use shared_ptr for event loop

Browse Source
pull/494/head
Jeff Becker 5 years ago
parent 3783fb0e14
commit e178a70929
No known key found for this signature in database
GPG Key ID: F357B3B42F6F9B05
30 changed files with 124 additions and 161 deletions
Show Stats Download Patch File Download Diff File

2
CMakeLists.txt
Unescape Escape View File

@ -365,7 +365,7 @@ target_link_libraries(${ABYSS_LIB} PUBLIC ${PLATFORM_LIB})
if (NOT WIN32)
add_executable(${ABYSS_EXE} ${ABYSS}/main.cpp)
target_link_libraries(${ABYSS_EXE} PUBLIC ${ABYSS_LIB} ${STATIC_LIB} Threads::Threads)
target_link_libraries(${ABYSS_EXE} PUBLIC ${ABYSS_LIB} Threads::Threads)
else()
add_executable(${ABYSS_EXE} ${ABYSS}/main.cpp llarp/win32/abyss.rc)
target_link_libraries(${ABYSS_EXE} PUBLIC ${ABYSS_LIB} ${STATIC_LIB} ws2_32)

3
include/llarp.hpp
Unescape Escape View File

@ -2,6 +2,7 @@
#define LLARP_HPP
#include <util/types.hpp>
#include <ev/ev.hpp>
#include <iostream>
#include <memory>
@ -51,7 +52,7 @@ namespace llarp
std::unique_ptr< Logic > logic;
std::unique_ptr< Config > config;
std::unique_ptr< llarp_nodedb > nodedb;
std::unique_ptr< llarp_ev_loop > mainloop;
llarp_ev_loop_ptr mainloop;
std::string nodedb_dir;
bool

4
libabyss/include/abyss/client.hpp
Unescape Escape View File

@ -68,7 +68,7 @@ namespace abyss
/// start runing on event loop async
/// return true on success otherwise return false
bool
RunAsync(llarp_ev_loop* loop, const std::string& endpoint);
RunAsync(llarp_ev_loop_ptr loop, const std::string& endpoint);
/// must be called after RunAsync returns true
/// queue a call for rpc
@ -120,7 +120,7 @@ namespace abyss
std::atomic< bool > m_Run;
llarp_tcp_connecter m_connect;
llarp_ev_loop* m_Loop;
llarp_ev_loop_ptr m_Loop;
std::deque< Call > m_PendingCalls;
std::list< std::unique_ptr< IRPCClientHandler > > m_Conns;
};

4
libabyss/include/abyss/server.hpp
Unescape Escape View File

@ -45,7 +45,7 @@ namespace abyss
~BaseReqHandler();
bool
ServeAsync(llarp_ev_loop* loop, llarp::Logic* logic,
ServeAsync(llarp_ev_loop_ptr loop, llarp::Logic* logic,
const sockaddr* bindaddr);
void
@ -75,7 +75,7 @@ namespace abyss
static void
OnAccept(struct llarp_tcp_acceptor*, struct llarp_tcp_conn*);
llarp_ev_loop* m_loop;
llarp_ev_loop_ptr m_loop;
llarp::Logic* m_Logic;
llarp_tcp_acceptor m_acceptor;
std::list< std::unique_ptr< IRPCHandler > > m_Conns;

14
libabyss/main.cpp
Unescape Escape View File

@ -64,18 +64,19 @@ struct DemoCall : public abyss::http::IRPCClientHandler
struct DemoClient : public abyss::http::JSONRPC
{
llarp_ev_loop* m_Loop;
llarp_ev_loop_ptr m_Loop;
llarp::Logic* m_Logic;
DemoClient(llarp_ev_loop* l, llarp::Logic* logic)
: abyss::http::JSONRPC(), m_Loop(l), m_Logic(logic)
DemoClient(llarp_ev_loop_ptr l, llarp::Logic* logic)
: abyss::http::JSONRPC(), m_Loop(std::move(l)), m_Logic(logic)
{
}
abyss::http::IRPCClientHandler*
NewConn(abyss::http::ConnImpl* impl)
{
return new DemoCall(impl, m_Logic, std::bind(&llarp_ev_loop_stop, m_Loop));
return new DemoCall(impl, m_Logic,
std::bind(&llarp_ev_loop_stop, m_Loop.get()));
}
void
@ -124,9 +125,8 @@ main(__attribute__((unused)) int argc, __attribute__((unused)) char* argv[])
#endif
llarp::SetLogLevel(llarp::eLogDebug);
llarp_threadpool* threadpool = llarp_init_same_process_threadpool();
llarp_ev_loop* loop = nullptr;
llarp_ev_loop_alloc(&loop);
llarp::Logic* logic = new llarp::Logic(threadpool);
llarp_ev_loop_ptr loop = llarp_make_ev_loop();
llarp::Logic* logic = new llarp::Logic(threadpool);
sockaddr_in addr;
addr.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
addr.sin_port = htons(1222);

6
libabyss/src/client.cpp
Unescape Escape View File

@ -367,7 +367,7 @@ namespace abyss
llarp::LogDebug("tick connect to rpc ", numCalls, " times");
while(numCalls--)
{
llarp_tcp_async_try_connect(m_Loop, &m_connect);
llarp_tcp_async_try_connect(m_Loop.get(), &m_connect);
}
}
@ -413,7 +413,7 @@ namespace abyss
}
bool
JSONRPC::RunAsync(llarp_ev_loop* loop, const std::string& remote)
JSONRPC::RunAsync(llarp_ev_loop_ptr loop, const std::string& remote)
{
strncpy(m_connect.remote, remote.c_str(), sizeof(m_connect.remote));
// TODO: ipv6
@ -421,7 +421,7 @@ namespace abyss
m_connect.error = &JSONRPC::OnConnectFail;
m_connect.user = this;
m_connect.af = AF_INET;
m_Loop = loop;
m_Loop = std::move(loop);
return true;
}

6
libabyss/src/server.cpp
Unescape Escape View File

@ -337,12 +337,12 @@ namespace abyss
}
bool
BaseReqHandler::ServeAsync(llarp_ev_loop* loop, llarp::Logic* logic,
BaseReqHandler::ServeAsync(llarp_ev_loop_ptr loop, llarp::Logic* logic,
const sockaddr* bindaddr)
{
m_loop = loop;
m_loop = std::move(loop);
m_Logic = logic;
return llarp_tcp_serve(m_loop, &m_acceptor, bindaddr);
return llarp_tcp_serve(m_loop.get(), &m_acceptor, bindaddr);
}
void

1
llarp/CMakeLists.txt
Unescape Escape View File

@ -57,6 +57,7 @@ endif()
set(LIB_PLATFORM_SRC
# for networking
ev/ev.cpp
ev/pipe.cpp
net/net.cpp
net/net_addr.cpp
net/net_inaddr.cpp

8
llarp/context.cpp
Unescape Escape View File

@ -41,9 +41,6 @@ namespace llarp
Context::~Context()
{
llarp_ev_loop *ptr = mainloop.release();
llarp_ev_loop_free(&ptr);
m_scheduler->stop();
}
@ -182,8 +179,7 @@ namespace llarp
else
logic = std::make_unique< Logic >();
router =
std::make_unique< Router >(worker.get(), mainloop.get(), logic.get());
router = std::make_unique< Router >(worker.get(), mainloop, logic.get());
if(!router->Configure(config.get()))
{
llarp::LogError("Failed to configure router");
@ -214,7 +210,7 @@ namespace llarp
// run net io thread
llarp::LogInfo("running mainloop");
llarp_ev_loop_run_single_process(mainloop.get(), worker.get(), logic.get());
llarp_ev_loop_run_single_process(mainloop, worker.get(), logic.get());
// waits for router graceful stop
return 0;
}

8
llarp/dns/server.cpp
Unescape Escape View File

@ -8,8 +8,8 @@ namespace llarp
{
namespace dns
{
Proxy::Proxy(llarp_ev_loop* loop, IQueryHandler* h)
: m_Loop(loop), m_QueryHandler(h)
Proxy::Proxy(llarp_ev_loop_ptr loop, IQueryHandler* h)
: m_Loop(std::move(loop)), m_QueryHandler(h)
{
m_Client.user = this;
m_Server.user = this;
@ -31,8 +31,8 @@ namespace llarp
m_Resolvers.clear();
m_Resolvers = resolvers;
llarp::Addr any("0.0.0.0", 0);
return llarp_ev_add_udp(m_Loop, &m_Server, addr) == 0
&& llarp_ev_add_udp(m_Loop, &m_Client, any) == 0;
return llarp_ev_add_udp(m_Loop.get(), &m_Server, addr) == 0
&& llarp_ev_add_udp(m_Loop.get(), &m_Client, any) == 0;
}
void

4
llarp/dns/server.hpp
Unescape Escape View File

@ -29,7 +29,7 @@ namespace llarp
struct Proxy
{
Proxy(llarp_ev_loop* loop, IQueryHandler* handler);
Proxy(llarp_ev_loop_ptr loop, IQueryHandler* handler);
bool
Start(const llarp::Addr& addr,
@ -69,7 +69,7 @@ namespace llarp
private:
llarp_udp_io m_Server;
llarp_udp_io m_Client;
llarp_ev_loop* m_Loop;
llarp_ev_loop_ptr m_Loop;
IQueryHandler* m_QueryHandler;
std::vector< llarp::Addr > m_Resolvers;

58
llarp/ev/ev.cpp
Unescape Escape View File

@ -20,39 +20,18 @@
#error No async event loop for your platform, subclass llarp_ev_loop
#endif
// This is dead now isn't it -rick
void
llarp_ev_loop_alloc(struct llarp_ev_loop **ev)
{
#if __linux__ || SOLARIS_HAVE_EPOLL
*ev = new llarp_epoll_loop;
#elif defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__NetBSD__) \
|| (__APPLE__ && __MACH__)
*ev = new llarp_kqueue_loop;
#elif defined(_WIN32) || defined(_WIN64) || defined(__NT__)
*ev = new llarp_win32_loop;
#elif defined(__sun) && !defined(SOLARIS_HAVE_EPOLL)
*ev = new llarp_poll_loop;
#else
// TODO: fall back to a generic select-based event loop
#error no event loop subclass
#endif
(*ev)->init();
(*ev)->_now = llarp::time_now_ms();
}
std::unique_ptr< llarp_ev_loop >
llarp_ev_loop_ptr
llarp_make_ev_loop()
{
#if __linux__ || SOLARIS_HAVE_EPOLL
std::unique_ptr< llarp_ev_loop > r = std::make_unique< llarp_epoll_loop >();
llarp_ev_loop_ptr r = std::make_shared< llarp_epoll_loop >();
#elif defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__NetBSD__) \
|| (__APPLE__ && __MACH__)
std::unique_ptr< llarp_ev_loop > r = std::make_unique< llarp_kqueue_loop >();
llarp_ev_loop_ptr r = std::make_shared< llarp_kqueue_loop >();
#elif defined(_WIN32) || defined(_WIN64) || defined(__NT__)
std::unique_ptr< llarp_ev_loop > r = std::make_unique< llarp_win32_loop >();
llarp_ev_loop_ptr r = std::make_shared< llarp_win32_loop >();
#elif defined(__sun) && !defined(SOLARIS_HAVE_EPOLL)
std::unique_ptr< llarp_ev_loop > r = std::make_unique< llarp_poll_loop >();
llarp_ev_loop_ptr r = std::make_shared< llarp_poll_loop >();
#else
#error no event loop subclass
#endif
@ -61,29 +40,6 @@ llarp_make_ev_loop()
return r;
}
void
llarp_ev_loop_free(struct llarp_ev_loop **ev)
{
delete *ev;
*ev = nullptr;
#ifdef _WIN32
exit_tun_loop();
#endif
}
int
llarp_ev_loop_run(struct llarp_ev_loop *ev, llarp::Logic *logic)
{
while(ev->running())
{
ev->update_time();
ev->tick(EV_TICK_INTERVAL);
if(ev->running())
logic->tick(ev->_now);
}
return 0;
}
int
llarp_fd_promise_wait_for_value(struct llarp_fd_promise *p)
{
@ -91,7 +47,7 @@ llarp_fd_promise_wait_for_value(struct llarp_fd_promise *p)
}
void
llarp_ev_loop_run_single_process(struct llarp_ev_loop *ev,
llarp_ev_loop_run_single_process(llarp_ev_loop_ptr ev,
struct llarp_threadpool *tp,
llarp::Logic *logic)
{
@ -127,7 +83,7 @@ llarp_ev_close_udp(struct llarp_udp_io *udp)
}
llarp_time_t
llarp_ev_loop_time_now_ms(struct llarp_ev_loop *loop)
llarp_ev_loop_time_now_ms(const llarp_ev_loop_ptr &loop)
{
if(loop)
return loop->time_now();

19
llarp/ev/ev.h
Unescape Escape View File

@ -40,29 +40,20 @@ namespace llarp
class Logic;
}
/// allocator
void
llarp_ev_loop_alloc(struct llarp_ev_loop **ev);
using llarp_ev_loop_ptr = std::shared_ptr< llarp_ev_loop >;
std::unique_ptr< llarp_ev_loop >
llarp_ev_loop_ptr
llarp_make_ev_loop();
// deallocator
void
llarp_ev_loop_free(struct llarp_ev_loop **ev);
/// run main loop
int
llarp_ev_loop_run(struct llarp_ev_loop *ev, llarp::Logic *logic);
// run mainloop
void
llarp_ev_loop_run_single_process(struct llarp_ev_loop *ev,
llarp_ev_loop_run_single_process(llarp_ev_loop_ptr ev,
struct llarp_threadpool *tp,
llarp::Logic *logic);
/// get the current time on the event loop
llarp_time_t
llarp_ev_loop_time_now_ms(struct llarp_ev_loop *ev);
llarp_ev_loop_time_now_ms(const llarp_ev_loop_ptr &ev);
/// stop event loop and wait for it to complete all jobs
void

16
llarp/ev/ev.hpp
Unescape Escape View File

@ -98,8 +98,8 @@ namespace llarp
struct GetNow
{
llarp_ev_loop* loop;
GetNow(llarp_ev_loop* l) : loop(l)
llarp_ev_loop_ptr loop;
GetNow(llarp_ev_loop_ptr l) : loop(l)
{
}
@ -112,8 +112,8 @@ namespace llarp
struct PutTime
{
llarp_ev_loop* loop;
PutTime(llarp_ev_loop* l) : loop(l)
llarp_ev_loop_ptr loop;
PutTime(llarp_ev_loop_ptr l) : loop(l)
{
}
void
@ -304,8 +304,8 @@ namespace llarp
struct GetNow
{
llarp_ev_loop* loop;
GetNow(llarp_ev_loop* l) : loop(l)
llarp_ev_loop_ptr loop;
GetNow(llarp_ev_loop_ptr l) : loop(l)
{
}
@ -318,8 +318,8 @@ namespace llarp
struct PutTime
{
llarp_ev_loop* loop;
PutTime(llarp_ev_loop* l) : loop(l)
llarp_ev_loop_ptr loop;
PutTime(llarp_ev_loop_ptr l) : loop(l)
{
}
void

4
llarp/ev/ev_epoll.cpp
Unescape Escape View File

@ -207,7 +207,7 @@ namespace llarp
bool
tun::setup()
{
// for android
// for android / ios
if(t->get_fd_promise)
{
tunif->obtain_fd = &wait_for_fd_promise;
@ -476,7 +476,7 @@ llarp_epoll_loop::close_ev(llarp::ev_io* ev)
llarp::ev_io*
llarp_epoll_loop::create_tun(llarp_tun_io* tun)
{
llarp::tun* t = new llarp::tun(tun, this);
llarp::tun* t = new llarp::tun(tun, shared_from_this());
if(tun->get_fd_promise)
{
}

5
llarp/ev/ev_epoll.hpp
Unescape Escape View File

@ -49,7 +49,7 @@ namespace llarp
{
llarp_tun_io* t;
device* tunif;
tun(llarp_tun_io* tio, llarp_ev_loop* l)
tun(llarp_tun_io* tio, llarp_ev_loop_ptr l)
: ev_io(-1, new LossyWriteQueue_t("tun_write_queue", l, l))
, t(tio)
, tunif(tuntap_init())
@ -84,7 +84,8 @@ namespace llarp
};
}; // namespace llarp
struct llarp_epoll_loop : public llarp_ev_loop
struct llarp_epoll_loop : public llarp_ev_loop,
public std::enable_shared_from_this< llarp_ev_loop >
{
int epollfd;

1
llarp/ev/pipe.cpp
Unescape Escape View File

@ -0,0 +1 @@
#include <ev/pipe.hpp>

15
llarp/ev/pipe.hpp
Unescape Escape View File

@ -0,0 +1,15 @@
#ifndef LLARP_EV_PIPE_HPP
#define LLARP_EV_PIPE_HPP
#include <ev/ev.hpp>
struct llarp_ev_pipe
{
llarp_ev_pipe(llarp_ev_loop_ptr loop);
private:
std::pair< int, int > m_EventFDs;
std::pair< int, int > m_ExternFDs;
};
#endif

3
llarp/handlers/exit.cpp
Unescape Escape View File

@ -267,7 +267,8 @@ namespace llarp
{
if(m_ShouldInitTun)
{
if(!llarp_ev_add_tun(GetRouter()->netloop(), &m_Tun))
auto loop = GetRouter()->netloop();
if(!llarp_ev_add_tun(loop.get(), &m_Tun))
{
llarp::LogWarn("Could not create tunnel for exit endpoint");
return false;

3
llarp/handlers/tun.cpp
Unescape Escape View File

@ -472,7 +472,8 @@ namespace llarp
bool
TunEndpoint::SetupTun()
{
if(!llarp_ev_add_tun(EndpointNetLoop(), &tunif))
auto loop = EndpointNetLoop();
if(!llarp_ev_add_tun(loop.get(), &tunif))
{
llarp::LogError(Name(),
" failed to set up tun interface: ", tunif.ifaddr,

16
llarp/link/server.cpp
Unescape Escape View File

@ -33,15 +33,15 @@ namespace llarp
}
void
ILinkLayer::ForEachSession(
std::function< void(const ILinkSession*) > visit, bool randomize) const
ILinkLayer::ForEachSession(std::function< void(const ILinkSession*) > visit,
bool randomize) const
{
Lock l(&m_AuthedLinksMutex);
if(m_AuthedLinks.size() == 0)
return;
const size_t sz = randint() % m_AuthedLinks.size();
auto itr = m_AuthedLinks.begin();
auto begin = itr;
auto itr = m_AuthedLinks.begin();
auto begin = itr;
if(randomize)
{
std::advance(itr, sz);
@ -89,10 +89,10 @@ namespace llarp
}
bool
ILinkLayer::Configure(llarp_ev_loop* loop, const std::string& ifname, int af,
uint16_t port)
ILinkLayer::Configure(llarp_ev_loop_ptr loop, const std::string& ifname,
int af, uint16_t port)
{
m_Loop = loop;
m_Loop = std::move(loop);
m_udp.user = this;
m_udp.recvfrom = &ILinkLayer::udp_recv_from;
m_udp.tick = &ILinkLayer::udp_tick;
@ -104,7 +104,7 @@ namespace llarp
else if(!GetIFAddr(ifname, m_ourAddr, af))
return false;
m_ourAddr.port(port);
return llarp_ev_add_udp(loop, &m_udp, m_ourAddr) != -1;
return llarp_ev_add_udp(m_Loop.get(), &m_udp, m_ourAddr) != -1;
}
void

7
llarp/link/server.hpp
Unescape Escape View File

@ -71,7 +71,8 @@ namespace llarp
HasSessionVia(const Addr& addr);
void
ForEachSession(std::function< void(const ILinkSession*) > visit, bool randomize=false) const
ForEachSession(std::function< void(const ILinkSession*) > visit,
bool randomize = false) const
LOCKS_EXCLUDED(m_AuthedLinksMutex);
void
@ -106,7 +107,7 @@ namespace llarp
}
bool
Configure(llarp_ev_loop* loop, const std::string& ifname, int af,
Configure(llarp_ev_loop_ptr loop, const std::string& ifname, int af,
uint16_t port);
virtual std::shared_ptr< ILinkSession >
@ -232,7 +233,7 @@ namespace llarp
PutSession(const std::shared_ptr< ILinkSession >& s);
llarp::Logic* m_Logic = nullptr;
llarp_ev_loop* m_Loop = nullptr;
llarp_ev_loop_ptr m_Loop;
Addr m_ourAddr;
llarp_udp_io m_udp;
SecretKey m_SecretKey;

8
llarp/net/ip.hpp
Unescape Escape View File

@ -109,8 +109,8 @@ namespace llarp
struct PutTime
{
llarp_ev_loop* loop;
PutTime(llarp_ev_loop* evloop) : loop(evloop)
llarp_ev_loop_ptr loop;
PutTime(llarp_ev_loop_ptr evloop) : loop(evloop)
{
}
void
@ -122,8 +122,8 @@ namespace llarp
struct GetNow
{
llarp_ev_loop* loop;
GetNow(llarp_ev_loop* evloop) : loop(evloop)
llarp_ev_loop_ptr loop;
GetNow(llarp_ev_loop_ptr evloop) : loop(evloop)
{
}
llarp_time_t

10
llarp/router/abstractrouter.hpp
Unescape Escape View File

@ -4,10 +4,10 @@
#include <util/types.hpp>
#include <util/status.hpp>
#include <vector>
#include <ev/ev.h>
struct llarp_buffer_t;
struct llarp_dht_context;
struct llarp_ev_loop;
struct llarp_nodedb;
struct llarp_threadpool;
@ -87,7 +87,7 @@ namespace llarp
virtual Profiling &
routerProfiling() = 0;
virtual llarp_ev_loop *
virtual llarp_ev_loop_ptr
netloop() const = 0;
virtual llarp_threadpool *
@ -117,7 +117,7 @@ namespace llarp
virtual bool
IsBootstrapNode(RouterID r) const = 0;
virtual const byte_t *
pubkey() const = 0;
@ -187,8 +187,8 @@ namespace llarp
/// visit each connected link session
virtual void
ForEachPeer(
std::function< void(const ILinkSession *, bool) > visit, bool randomize) const = 0;
ForEachPeer(std::function< void(const ILinkSession *, bool) > visit,
bool randomize) const = 0;
};
} // namespace llarp

4
llarp/router/router.cpp
Unescape Escape View File

@ -200,7 +200,7 @@ namespace llarp
return async_verify_RC(s->GetRemoteRC());
}
Router::Router(struct llarp_threadpool *_tp, struct llarp_ev_loop *__netloop,
Router::Router(struct llarp_threadpool *_tp, llarp_ev_loop_ptr __netloop,
Logic *l)
: ready(false)
, _netloop(__netloop)
@ -502,7 +502,7 @@ namespace llarp
Router::Close()
{
LogInfo("closing router");
llarp_ev_loop_stop(netloop());
llarp_ev_loop_stop(_netloop.get());
inboundLinks.clear();
outboundLinks.clear();
}

15
llarp/router/router.hpp
Unescape Escape View File

@ -167,7 +167,7 @@ namespace llarp
return _routerProfiling;
}
llarp_ev_loop *
llarp_ev_loop_ptr
netloop() const override
{
return _netloop;
@ -190,7 +190,7 @@ namespace llarp
struct sockaddr_in ip4addr;
AddressInfo addrInfo;
llarp_ev_loop *_netloop;
llarp_ev_loop_ptr _netloop;
llarp_threadpool *tp;
Logic *_logic;
std::unique_ptr< Crypto > _crypto;
@ -319,7 +319,7 @@ namespace llarp
// set to max value right now
std::unordered_map< RouterID, llarp_time_t, PubKey::Hash > lokinetRouters;
Router(struct llarp_threadpool *tp, struct llarp_ev_loop *__netloop,
Router(struct llarp_threadpool *tp, llarp_ev_loop_ptr __netloop,
Logic *logic);
~Router();
@ -451,15 +451,14 @@ namespace llarp
RouterID remote, const std::vector< RouterContact > &results) override;
void
ForEachPeer(
std::function< void(const ILinkSession *, bool) > visit, bool randomize=false) const override;
ForEachPeer(std::function< void(const ILinkSession *, bool) > visit,
bool randomize = false) const override;
void
ForEachPeer(std::function< void(ILinkSession *) > visit);
bool
IsBootstrapNode(RouterID) const override;
bool IsBootstrapNode(RouterID) const override;
/// check if newRc matches oldRC and update local rc for this remote contact
/// if valid
/// returns true on valid and updated

12
llarp/service/endpoint.cpp
Unescape Escape View File

@ -66,7 +66,7 @@ namespace llarp
return false;
}
llarp_ev_loop*
llarp_ev_loop_ptr
Endpoint::EndpointNetLoop()
{
if(m_IsolatedNetLoop)
@ -800,7 +800,7 @@ namespace llarp
{
if(failed)
return IsolationFailed();
llarp_ev_loop_alloc(&m_IsolatedNetLoop);
m_IsolatedNetLoop = llarp_make_ev_loop();
return SetupNetworking();
}
@ -1413,10 +1413,10 @@ 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);
transfer.P = remoteIntro.pathID;
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))
{
llarp::LogError("failed to encrypt and sign");

10
llarp/service/endpoint.hpp
Unescape Escape View File

@ -74,8 +74,8 @@ namespace llarp
llarp::Logic*
EndpointLogic();
/// endpoint's net loop for sending data to user
llarp_ev_loop*
/// borrow endpoint's net loop for sending data to user
llarp_ev_loop_ptr
EndpointNetLoop();
llarp::Crypto*
@ -488,9 +488,9 @@ namespace llarp
private:
AbstractRouter* m_Router;
llarp_threadpool* m_IsolatedWorker = nullptr;
llarp::Logic* m_IsolatedLogic = nullptr;
llarp_ev_loop* m_IsolatedNetLoop = nullptr;
llarp_threadpool* m_IsolatedWorker = nullptr;
llarp::Logic* m_IsolatedLogic = nullptr;
llarp_ev_loop_ptr m_IsolatedNetLoop = nullptr;
std::string m_Keyfile;
std::string m_Name;
std::string m_NetNS;

10
test/link/test_llarp_link.cpp
Unescape Escape View File

@ -68,7 +68,7 @@ struct LinkLayerTest : public ::testing::Test
}
bool
Start(llarp::Logic* logic, llarp_ev_loop* loop, uint16_t port)
Start(llarp::Logic* logic, llarp_ev_loop_ptr loop, uint16_t port)
{
if(!link)
return false;
@ -106,7 +106,7 @@ struct LinkLayerTest : public ::testing::Test
bool success = false;
llarp_ev_loop* netLoop;
llarp_ev_loop_ptr netLoop;
std::unique_ptr< llarp::Logic > logic;
llarp_time_t oldRCLifetime;
@ -121,7 +121,7 @@ struct LinkLayerTest : public ::testing::Test
oldRCLifetime = llarp::RouterContact::Lifetime;
llarp::RouterContact::IgnoreBogons = true;
llarp::RouterContact::Lifetime = 500;
llarp_ev_loop_alloc(&netLoop);
netLoop = llarp_make_ev_loop();
logic.reset(new llarp::Logic());
}
@ -131,7 +131,7 @@ struct LinkLayerTest : public ::testing::Test
Alice.TearDown();
Bob.TearDown();
logic.reset();
llarp_ev_loop_free(&netLoop);
netLoop.reset();
llarp::RouterContact::IgnoreBogons = false;
llarp::RouterContact::Lifetime = oldRCLifetime;
}
@ -154,7 +154,7 @@ struct LinkLayerTest : public ::testing::Test
void
Stop()
{
llarp_ev_loop_stop(netLoop);
llarp_ev_loop_stop(netLoop.get());
}
bool

9
test/test_libabyss.cpp
Unescape Escape View File

@ -12,7 +12,7 @@ struct AbyssTestBase : public ::testing::Test
{
llarp::sodium::CryptoLibSodium crypto;
llarp_threadpool* threadpool = nullptr;
llarp_ev_loop* loop = nullptr;
llarp_ev_loop_ptr loop = nullptr;
std::unique_ptr< llarp::Logic > logic;
abyss::httpd::BaseReqHandler* server = nullptr;
abyss::http::JSONRPC* client = nullptr;
@ -48,8 +48,8 @@ struct AbyssTestBase : public ::testing::Test
Start()
{
threadpool = llarp_init_same_process_threadpool();
llarp_ev_loop_alloc(&loop);
logic = std::make_unique< llarp::Logic >(threadpool);
loop = llarp_make_ev_loop();
logic = std::make_unique< llarp::Logic >(threadpool);
sockaddr_in addr;
addr.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
@ -72,7 +72,7 @@ struct AbyssTestBase : public ::testing::Test
Stop()
{
llarp::LogDebug("test case Stop() called");
llarp_ev_loop_stop(loop);
llarp_ev_loop_stop(loop.get());
}
void
@ -84,7 +84,6 @@ struct AbyssTestBase : public ::testing::Test
~AbyssTestBase()
{
logic.reset();
llarp_ev_loop_free(&loop);
llarp_free_threadpool(&threadpool);
llarp::SetLogLevel(llarp::eLogInfo);
}

Write Preview
Loading…
Cancel
Save