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

Convert llarp_router to be a true C++ class

Browse Source
pull/123/head
Michael 6 years ago
parent 2d833211ba
commit f0fce5b68a
No known key found for this signature in database
GPG Key ID: 2D51757B47E2434C
85 changed files with 1375 additions and 1392 deletions
Show Stats Download Patch File Download Diff File

1
daemon/dns.cpp
Unescape Escape View File

@ -1,5 +1,6 @@
#include <unistd.h>
#include <llarp.h>
#include <llarp/config.h>
#include <llarp/dns_iptracker.hpp>
#include <llarp/dnsd.hpp>
#include <llarp/dns_dotlokilookup.hpp>

3
daemon/rcutil.cpp
Unescape Escape View File

@ -3,15 +3,16 @@
#include <signal.h>
#include "logger.hpp"
#include <llarp/nodedb.hpp>
#include <llarp/router_contact.hpp>
#include <llarp/time.hpp>
#include <router.hpp>
#include <fstream>
#include "buffer.hpp"
#include "crypto.hpp"
#include "fs.hpp"
#include "llarp/net.hpp"
#include "router.hpp"
#include <llarp/messages/dht.hpp>

5
include/llarp.hpp
Unescape Escape View File

@ -8,6 +8,9 @@
#include <vector>
#include <llarp/crypto.h>
struct llarp_config;
struct llarp_config_iterator;
namespace llarp
{
struct Context
@ -17,7 +20,7 @@ namespace llarp
int num_nethreads = 1;
bool singleThreaded = false;
llarp_crypto crypto;
llarp_router *router = nullptr;
llarp::Router *router = nullptr;
llarp_threadpool *worker = nullptr;
llarp::Logic *logic = nullptr;
llarp_config *config = nullptr;

6
include/llarp/dht.h
Unescape Escape View File

@ -2,7 +2,6 @@
#define LLARP_DHT_H_
#include <llarp/buffer.h>
#include <llarp/router.h>
#include <llarp/crypto.hpp>
#include <llarp/router_contact.hpp>
@ -14,9 +13,11 @@
struct llarp_dht_context;
namespace llarp { struct Router; }
/// allocator
struct llarp_dht_context*
llarp_dht_context_new(struct llarp_router* parent);
llarp_dht_context_new(llarp::Router* parent);
/// deallocator
void
@ -37,7 +38,6 @@ struct llarp_router_lookup_job
void* user;
llarp_router_lookup_handler hook;
struct llarp_dht_context* dht;
// byte_t target[PUBKEYSIZE];
llarp::PubKey target;
bool found;
// make sure you initialize addr and exits

11
include/llarp/dht/context.hpp
Unescape Escape View File

@ -7,7 +7,6 @@
#include <llarp/dht/message.hpp>
#include <llarp/dht/messages/findintro.hpp>
#include <llarp/dht/node.hpp>
#include <llarp/router.h>
#include <llarp/service/IntroSet.hpp>
#include <llarp/time.hpp>
@ -15,6 +14,8 @@
namespace llarp
{
struct Router;
namespace dht
{
struct TXOwner
@ -234,7 +235,7 @@ namespace llarp
/// initialize dht context and explore every exploreInterval milliseconds
void
Init(const Key_t& us, llarp_router* router, llarp_time_t exploreInterval);
Init(const Key_t& us, llarp::Router* router, llarp_time_t exploreInterval);
/// get localally stored introset by service address
const llarp::service::IntroSet*
@ -250,7 +251,7 @@ namespace llarp
void
Explore(size_t N = 3);
llarp_router* router = nullptr;
llarp::Router* router = nullptr;
// for router contacts
Bucket< RCNode >* nodes = nullptr;
@ -427,8 +428,8 @@ namespace llarp
struct llarp_dht_context
{
llarp::dht::Context impl;
llarp_router* parent;
llarp_dht_context(llarp_router* router);
llarp::Router* parent;
llarp_dht_context(llarp::Router* router);
};
#endif

2
include/llarp/dht/message.hpp
Unescape Escape View File

@ -24,7 +24,7 @@ namespace llarp
virtual bool
HandleMessage(
llarp_dht_context* dht,
struct llarp_dht_context* dht,
std::vector< std::unique_ptr< IMessage > >& replies) const = 0;
Key_t From;

1
include/llarp/dht/messages/findintro.hpp
Unescape Escape View File

@ -1,6 +1,7 @@
#ifndef LLARP_DHT_MESSAGES_FIND_INTRO_HPP
#define LLARP_DHT_MESSAGES_FIND_INTRO_HPP
#include <llarp/dht/message.hpp>
#include <llarp/routing/message.hpp>
#include <llarp/service/address.hpp>
#include <llarp/service/tag.hpp>

5
include/llarp/exit/context.hpp
Unescape Escape View File

@ -4,7 +4,6 @@
#include <string>
#include <unordered_map>
#include <llarp/handlers/exit.hpp>
#include <llarp/router.h>
namespace llarp
{
@ -15,7 +14,7 @@ namespace llarp
{
using Config_t = std::unordered_multimap< std::string, std::string >;
Context(llarp_router *r);
Context(llarp::Router *r);
~Context();
void
@ -43,7 +42,7 @@ namespace llarp
CalculateExitTraffic(TrafficStats &stats);
private:
llarp_router *m_Router;
llarp::Router *m_Router;
std::unordered_map< std::string,
std::unique_ptr< llarp::handlers::ExitEndpoint > >
m_Exits;

1
include/llarp/exit/endpoint.hpp
Unescape Escape View File

@ -2,7 +2,6 @@
#define LLARP_EXIT_ENDPOINT_HPP
#include <llarp/time.hpp>
#include <llarp/crypto.hpp>
#include <llarp/router.h>
#include <llarp/path.hpp>
#include <llarp/ip.hpp>

6
include/llarp/exit/session.hpp
Unescape Escape View File

@ -17,7 +17,7 @@ namespace llarp
BaseSession(const llarp::RouterID& exitRouter,
std::function< bool(llarp_buffer_t) > writepkt,
llarp_router* r, size_t numpaths, size_t hoplen);
llarp::Router* r, size_t numpaths, size_t hoplen);
virtual ~BaseSession();
@ -76,7 +76,7 @@ namespace llarp
{
ExitSession(const llarp::RouterID& snodeRouter,
std::function< bool(llarp_buffer_t) > writepkt,
llarp_router* r, size_t numpaths, size_t hoplen)
llarp::Router* r, size_t numpaths, size_t hoplen)
: BaseSession(snodeRouter, writepkt, r, numpaths, hoplen){};
~ExitSession(){};
@ -95,7 +95,7 @@ namespace llarp
{
SNodeSession(const llarp::RouterID& snodeRouter,
std::function< bool(llarp_buffer_t) > writepkt,
llarp_router* r, size_t numpaths, size_t hoplen)
llarp::Router* r, size_t numpaths, size_t hoplen)
: BaseSession(snodeRouter, writepkt, r, numpaths, hoplen){};
~SNodeSession(){};

6
include/llarp/handlers/exit.hpp
Unescape Escape View File

@ -11,7 +11,7 @@ namespace llarp
{
struct ExitEndpoint
{
ExitEndpoint(const std::string& name, llarp_router* r);
ExitEndpoint(const std::string& name, llarp::Router* r);
~ExitEndpoint();
void
@ -41,7 +41,7 @@ namespace llarp
void
OnInetPacket(llarp_buffer_t buf);
llarp_router*
llarp::Router*
Router();
llarp_time_t
@ -100,7 +100,7 @@ namespace llarp
void
KickIdentOffExit(const llarp::PubKey& pk);
llarp_router* m_Router;
llarp::Router* m_Router;
bool m_ShouldInitTun;
std::string m_Name;
bool m_PermitExit;

2
include/llarp/handlers/null.hpp
Unescape Escape View File

@ -8,7 +8,7 @@ namespace llarp
{
struct NullEndpoint final : public llarp::service::Endpoint
{
NullEndpoint(const std::string &name, llarp_router *r)
NullEndpoint(const std::string &name, llarp::Router *r)
: llarp::service::Endpoint(name, r){};
bool HandleWriteIPPacket(llarp_buffer_t,

2
include/llarp/handlers/tun.hpp
Unescape Escape View File

@ -19,7 +19,7 @@ namespace llarp
struct TunEndpoint : public service::Endpoint, public dns::IQueryHandler
{
TunEndpoint(const std::string& nickname, llarp_router* r);
TunEndpoint(const std::string& nickname, llarp::Router* r);
~TunEndpoint();
virtual bool

7
include/llarp/iwp.hpp
Unescape Escape View File

@ -3,12 +3,17 @@
#include <llarp/crypto.h>
#include <string>
namespace llarp {
class Logic;
struct Router;
}
struct llarp_iwp_args
{
struct llarp_crypto* crypto;
llarp::Logic* logic;
struct llarp_threadpool* cryptoworker;
struct llarp_router* router;
struct llarp::Router* router;
bool permitInbound;
};

2
include/llarp/link/curvecp.hpp
Unescape Escape View File

@ -8,7 +8,7 @@ namespace llarp
namespace curvecp
{
std::unique_ptr< ILinkLayer >
NewServer(llarp_router* r);
NewServer(llarp::Router* r);
}
} // namespace llarp

4
include/llarp/link/server.hpp
Unescape Escape View File

@ -10,10 +10,10 @@
#include <llarp/logic.hpp>
#include <list>
struct llarp_router;
namespace llarp
{
struct Router;
struct ILinkLayer
{
virtual ~ILinkLayer();

2
include/llarp/link/utp.hpp
Unescape Escape View File

@ -8,7 +8,7 @@ namespace llarp
namespace utp
{
std::unique_ptr< ILinkLayer >
NewServer(llarp_router* r);
NewServer(llarp::Router* r);
}
} // namespace llarp

9
include/llarp/link_message.hpp
Unescape Escape View File

@ -8,11 +8,10 @@
#include <queue>
#include <vector>
struct llarp_router;
namespace llarp
{
struct ILinkSession;
struct Router;
using SendQueue = std::queue< ILinkMessage* >;
@ -35,12 +34,12 @@ namespace llarp
}
virtual bool
HandleMessage(llarp_router* router) const = 0;
HandleMessage(Router* router) const = 0;
};
struct InboundMessageParser
{
InboundMessageParser(llarp_router* router);
InboundMessageParser(Router* router);
dict_reader reader;
static bool
@ -65,7 +64,7 @@ namespace llarp
private:
bool firstkey;
llarp_router* router;
Router* router;
ILinkSession* from = nullptr;
std::unique_ptr< ILinkMessage > msg;
};

2
include/llarp/messages/dht.hpp
Unescape Escape View File

@ -23,7 +23,7 @@ namespace llarp
BEncode(llarp_buffer_t* buf) const override;
bool
HandleMessage(IMessageHandler* h, llarp_router* r) const override;
HandleMessage(IMessageHandler* h, llarp::Router* r) const override;
};
} // namespace routing
} // namespace llarp

2
include/llarp/messages/dht_immediate.hpp
Unescape Escape View File

@ -27,7 +27,7 @@ namespace llarp
BEncode(llarp_buffer_t* buf) const;
bool
HandleMessage(llarp_router* router) const;
HandleMessage(llarp::Router* router) const;
};
} // namespace llarp

4
include/llarp/messages/discard.hpp
Unescape Escape View File

@ -43,7 +43,7 @@ namespace llarp
}
bool
HandleMessage(__attribute__((unused)) llarp_router* router) const override
HandleMessage(__attribute__((unused)) llarp::Router* router) const override
{
return true;
}
@ -66,7 +66,7 @@ namespace llarp
}
bool
HandleMessage(IMessageHandler* h, llarp_router* r) const override
HandleMessage(IMessageHandler* h, llarp::Router* r) const override
{
return h->HandleDataDiscardMessage(this, r);
}

12
include/llarp/messages/exit.hpp
Unescape Escape View File

@ -44,7 +44,7 @@ namespace llarp
DecodeKey(llarp_buffer_t key, llarp_buffer_t* buf) override;
bool
HandleMessage(IMessageHandler* h, llarp_router* r) const override;
HandleMessage(IMessageHandler* h, llarp::Router* r) const override;
};
struct GrantExitMessage final : public IMessage
@ -77,7 +77,7 @@ namespace llarp
DecodeKey(llarp_buffer_t key, llarp_buffer_t* buf) override;
bool
HandleMessage(IMessageHandler* h, llarp_router* r) const override;
HandleMessage(IMessageHandler* h, llarp::Router* r) const override;
};
struct RejectExitMessage final : public IMessage
@ -113,7 +113,7 @@ namespace llarp
DecodeKey(llarp_buffer_t key, llarp_buffer_t* buf) override;
bool
HandleMessage(IMessageHandler* h, llarp_router* r) const override;
HandleMessage(IMessageHandler* h, llarp::Router* r) const override;
};
struct UpdateExitVerifyMessage final : public IMessage
@ -147,7 +147,7 @@ namespace llarp
DecodeKey(llarp_buffer_t key, llarp_buffer_t* buf) override;
bool
HandleMessage(IMessageHandler* h, llarp_router* r) const override;
HandleMessage(IMessageHandler* h, llarp::Router* r) const override;
};
struct UpdateExitMessage final : public IMessage
@ -182,7 +182,7 @@ namespace llarp
DecodeKey(llarp_buffer_t key, llarp_buffer_t* buf) override;
bool
HandleMessage(IMessageHandler* h, llarp_router* r) const override;
HandleMessage(IMessageHandler* h, llarp::Router* r) const override;
};
struct CloseExitMessage final : public IMessage
@ -210,7 +210,7 @@ namespace llarp
DecodeKey(llarp_buffer_t key, llarp_buffer_t* buf) override;
bool
HandleMessage(IMessageHandler* h, llarp_router* r) const override;
HandleMessage(IMessageHandler* h, llarp::Router* r) const override;
bool
Sign(llarp_crypto* c, const llarp::SecretKey& sk);

2
include/llarp/messages/link_intro.hpp
Unescape Escape View File

@ -35,7 +35,7 @@ namespace llarp
BEncode(llarp_buffer_t* buf) const;
bool
HandleMessage(llarp_router* router) const;
HandleMessage(llarp::Router* router) const;
bool
Sign(llarp_crypto* c, const SecretKey& signKeySecret);

2
include/llarp/messages/path_confirm.hpp
Unescape Escape View File

@ -22,7 +22,7 @@ namespace llarp
DecodeKey(llarp_buffer_t key, llarp_buffer_t* val) override;
bool
HandleMessage(IMessageHandler* h, llarp_router* r) const override;
HandleMessage(IMessageHandler* h, llarp::Router* r) const override;
};
} // namespace routing
} // namespace llarp

2
include/llarp/messages/path_latency.hpp
Unescape Escape View File

@ -20,7 +20,7 @@ namespace llarp
DecodeKey(llarp_buffer_t key, llarp_buffer_t* val) override;
bool
HandleMessage(IMessageHandler* h, llarp_router* r) const override;
HandleMessage(IMessageHandler* h, llarp::Router* r) const override;
};
} // namespace routing
} // namespace llarp

2
include/llarp/messages/path_transfer.hpp
Unescape Escape View File

@ -31,7 +31,7 @@ namespace llarp
BEncode(llarp_buffer_t* buf) const override;
bool
HandleMessage(IMessageHandler*, llarp_router* r) const override;
HandleMessage(IMessageHandler*, llarp::Router* r) const override;
};
} // namespace routing

4
include/llarp/messages/relay.hpp
Unescape Escape View File

@ -26,7 +26,7 @@ namespace llarp
BEncode(llarp_buffer_t* buf) const;
bool
HandleMessage(llarp_router* router) const;
HandleMessage(llarp::Router* router) const;
};
struct RelayDownstreamMessage : public ILinkMessage
@ -45,7 +45,7 @@ namespace llarp
BEncode(llarp_buffer_t* buf) const;
bool
HandleMessage(llarp_router* router) const;
HandleMessage(llarp::Router* router) const;
};
} // namespace llarp

2
include/llarp/messages/relay_commit.hpp
Unescape Escape View File

@ -67,7 +67,7 @@ namespace llarp
BEncode(llarp_buffer_t *buf) const;
bool
HandleMessage(llarp_router *router) const;
HandleMessage(llarp::Router *router) const;
bool
AsyncDecrypt(llarp::path::PathContext *context) const;

2
include/llarp/messages/transfer_traffic.hpp
Unescape Escape View File

@ -36,7 +36,7 @@ namespace llarp
DecodeKey(llarp_buffer_t k, llarp_buffer_t* val) override;
bool
HandleMessage(IMessageHandler* h, llarp_router* r) const override;
HandleMessage(IMessageHandler* h, llarp::Router* r) const override;
};
} // namespace routing
} // namespace llarp

81
include/llarp/path.hpp
Unescape Escape View File

@ -1,6 +1,5 @@
#ifndef LLARP_PATH_HPP
#define LLARP_PATH_HPP
#include <llarp/router.h>
#include <llarp/time.hpp>
#include <llarp/aligned.hpp>
#include <llarp/crypto.hpp>
@ -110,17 +109,17 @@ namespace llarp
/// send routing message and increment sequence number
virtual bool
SendRoutingMessage(const llarp::routing::IMessage* msg,
llarp_router* r) = 0;
llarp::Router* r) = 0;
// handle data in upstream direction
virtual bool
HandleUpstream(llarp_buffer_t X, const TunnelNonce& Y,
llarp_router* r) = 0;
llarp::Router* r) = 0;
// handle data in downstream direction
virtual bool
HandleDownstream(llarp_buffer_t X, const TunnelNonce& Y,
llarp_router* r) = 0;
llarp::Router* r) = 0;
uint64_t
NextSeqNo()
@ -176,55 +175,55 @@ namespace llarp
// send routing message when end of path
bool
SendRoutingMessage(const llarp::routing::IMessage* msg,
llarp_router* r) override;
llarp::Router* r) override;
// handle routing message when end of path
bool
HandleRoutingMessage(const llarp::routing::IMessage* msg,
llarp_router* r);
llarp::Router* r);
bool
HandleDataDiscardMessage(const llarp::routing::DataDiscardMessage* msg,
llarp_router* r) override;
llarp::Router* r) override;
bool
HandlePathConfirmMessage(const llarp::routing::PathConfirmMessage* msg,
llarp_router* r) override;
llarp::Router* r) override;
bool
HandlePathTransferMessage(const llarp::routing::PathTransferMessage* msg,
llarp_router* r) override;
llarp::Router* r) override;
bool
HandlePathLatencyMessage(const llarp::routing::PathLatencyMessage* msg,
llarp_router* r) override;
llarp::Router* r) override;
bool
HandleObtainExitMessage(const llarp::routing::ObtainExitMessage* msg,
llarp_router* r) override;
llarp::Router* r) override;
bool
HandleUpdateExitVerifyMessage(
const llarp::routing::UpdateExitVerifyMessage* msg,
llarp_router* r) override;
llarp::Router* r) override;
bool
HandleTransferTrafficMessage(
const llarp::routing::TransferTrafficMessage* msg,
llarp_router* r) override;
llarp::Router* r) override;
bool
HandleUpdateExitMessage(const llarp::routing::UpdateExitMessage* msg,
llarp_router* r) override;
llarp::Router* r) override;
bool
HandleGrantExitMessage(const llarp::routing::GrantExitMessage* msg,
llarp_router* r) override;
llarp::Router* r) override;
bool
HandleRejectExitMessage(const llarp::routing::RejectExitMessage* msg,
llarp_router* r) override;
llarp::Router* r) override;
bool
HandleCloseExitMessage(const llarp::routing::CloseExitMessage* msg,
llarp_router* r) override;
llarp::Router* r) override;
bool
HandleHiddenServiceFrame(__attribute__((
@ -240,17 +239,17 @@ namespace llarp
bool
HandleDHTMessage(const llarp::dht::IMessage* msg,
llarp_router* r) override;
llarp::Router* r) override;
// handle data in upstream direction
bool
HandleUpstream(llarp_buffer_t X, const TunnelNonce& Y,
llarp_router* r) override;
llarp::Router* r) override;
// handle data in downstream direction
bool
HandleDownstream(llarp_buffer_t X, const TunnelNonce& Y,
llarp_router* r) override;
llarp::Router* r) override;
};
/// configuration for a single hop when building a path
@ -395,55 +394,55 @@ namespace llarp
Expired(llarp_time_t now) const override;
void
Tick(llarp_time_t now, llarp_router* r);
Tick(llarp_time_t now, llarp::Router* r);
bool
SendRoutingMessage(const llarp::routing::IMessage* msg,
llarp_router* r) override;
llarp::Router* r) override;
bool
HandleObtainExitMessage(const llarp::routing::ObtainExitMessage* msg,
llarp_router* r) override;
llarp::Router* r) override;
bool
HandleUpdateExitVerifyMessage(
const llarp::routing::UpdateExitVerifyMessage* msg,
llarp_router* r) override;
llarp::Router* r) override;
bool
HandleTransferTrafficMessage(
const llarp::routing::TransferTrafficMessage* msg,
llarp_router* r) override;
llarp::Router* r) override;
bool
HandleUpdateExitMessage(const llarp::routing::UpdateExitMessage* msg,
llarp_router* r) override;
llarp::Router* r) override;
bool
HandleCloseExitMessage(const llarp::routing::CloseExitMessage* msg,
llarp_router* r) override;
llarp::Router* r) override;
bool
HandleGrantExitMessage(const llarp::routing::GrantExitMessage* msg,
llarp_router* r) override;
llarp::Router* r) override;
bool
HandleRejectExitMessage(const llarp::routing::RejectExitMessage* msg,
llarp_router* r) override;
llarp::Router* r) override;
bool
HandleDataDiscardMessage(const llarp::routing::DataDiscardMessage* msg,
llarp_router* r) override;
llarp::Router* r) override;
bool
HandlePathConfirmMessage(const llarp::routing::PathConfirmMessage* msg,
llarp_router* r) override;
llarp::Router* r) override;
bool
HandlePathLatencyMessage(const llarp::routing::PathLatencyMessage* msg,
llarp_router* r) override;
llarp::Router* r) override;
bool
HandlePathTransferMessage(const llarp::routing::PathTransferMessage* msg,
llarp_router* r) override;
llarp::Router* r) override;
bool
HandleHiddenServiceFrame(
@ -454,20 +453,20 @@ namespace llarp
bool
HandleDHTMessage(const llarp::dht::IMessage* msg,
llarp_router* r) override;
llarp::Router* r) override;
bool
HandleRoutingMessage(llarp_buffer_t buf, llarp_router* r);
HandleRoutingMessage(llarp_buffer_t buf, llarp::Router* r);
// handle data in upstream direction
bool
HandleUpstream(llarp_buffer_t X, const TunnelNonce& Y,
llarp_router* r) override;
llarp::Router* r) override;
// handle data in downstream direction
bool
HandleDownstream(llarp_buffer_t X, const TunnelNonce& Y,
llarp_router* r) override;
llarp::Router* r) override;
bool
IsReady() const;
@ -503,7 +502,7 @@ namespace llarp
bool
SendExitRequest(const llarp::routing::ObtainExitMessage* msg,
llarp_router* r);
llarp::Router* r);
protected:
llarp::routing::InboundMessageParser m_InboundMessageParser;
@ -540,7 +539,7 @@ namespace llarp
struct PathContext
{
PathContext(llarp_router* router);
PathContext(llarp::Router* router);
~PathContext();
/// called from router tick function
@ -634,7 +633,7 @@ namespace llarp
llarp::Logic*
Logic();
llarp_router*
llarp::Router*
Router();
byte_t*
@ -644,7 +643,7 @@ namespace llarp
OurRouterID() const;
private:
llarp_router* m_Router;
llarp::Router* m_Router;
SyncTransitMap_t m_TransitPaths;
SyncTransitMap_t m_Paths;
SyncOwnedPathsMap_t m_OurPaths;

4
include/llarp/pathbuilder.hpp
Unescape Escape View File

@ -12,14 +12,14 @@ namespace llarp
struct Builder : public PathSet
{
struct llarp_router* router;
llarp::Router* router;
struct llarp_dht_context* dht;
llarp::SecretKey enckey;
size_t numHops;
llarp_time_t lastBuild = 0;
llarp_time_t buildIntervalLimit = MIN_PATH_BUILD_INTERVAL;
/// construct
Builder(llarp_router* p_router, struct llarp_dht_context* p_dht,
Builder(llarp::Router* p_router, struct llarp_dht_context* p_dht,
size_t numPaths, size_t numHops);
virtual ~Builder();

7
include/llarp/pathset.hpp
Unescape Escape View File

@ -1,5 +1,6 @@
#ifndef LLARP_PATHSET_HPP
#define LLARP_PATHSET_HPP
#include <llarp/time.hpp>
#include <functional>
#include <list>
@ -12,6 +13,8 @@
#include <map>
#include <tuple>
struct llarp_nodedb;
namespace llarp
{
namespace dht
@ -58,7 +61,7 @@ namespace llarp
/// tick owned paths
void
Tick(llarp_time_t now, llarp_router* r);
Tick(llarp_time_t now, llarp::Router* r);
/// count the number of paths that will exist at this timestamp in future
size_t
@ -167,7 +170,7 @@ namespace llarp
std::set< llarp::service::Introduction >& intros) const;
virtual bool
PublishIntroSet(__attribute__((unused)) llarp_router* r)
PublishIntroSet(__attribute__((unused)) llarp::Router* r)
{
return false;
}

30
include/llarp/router.h
Unescape Escape View File

@ -1,30 +0,0 @@
#ifndef LLARP_ROUTER_H_
#define LLARP_ROUTER_H_
#include <llarp/config.h>
#include <llarp/ev.h>
#include <llarp/logic.hpp>
#include <llarp/threadpool.h>
#include <llarp/buffer.h>
struct llarp_nodedb;
struct llarp_router;
bool
llarp_findOrCreateIdentity(struct llarp_crypto *crypto, const char *path,
byte_t *secretkey);
struct llarp_router *
llarp_init_router(struct llarp_threadpool *worker,
struct llarp_ev_loop *netloop, llarp::Logic *logic);
void
llarp_free_router(struct llarp_router **router);
bool
llarp_configure_router(struct llarp_router *router, struct llarp_config *conf);
bool
llarp_run_router(struct llarp_router *router, struct llarp_nodedb *nodedb);
void
llarp_stop_router(struct llarp_router *router);
#endif

25
include/llarp/routing/handler.hpp
Unescape Escape View File

@ -2,7 +2,6 @@
#define LLARP_ROUTING_HANDLER_HPP
#include <llarp/buffer.h>
#include <llarp/router.h>
#include <llarp/dht.hpp>
#include <llarp/messages/path_confirm.hpp>
@ -22,50 +21,50 @@ namespace llarp
{
virtual bool
HandleObtainExitMessage(const ObtainExitMessage *msg,
llarp_router *r) = 0;
llarp::Router *r) = 0;
virtual bool
HandleGrantExitMessage(const GrantExitMessage *msg, llarp_router *r) = 0;
HandleGrantExitMessage(const GrantExitMessage *msg, llarp::Router *r) = 0;
virtual bool
HandleRejectExitMessage(const RejectExitMessage *msg,
llarp_router *r) = 0;
llarp::Router *r) = 0;
virtual bool
HandleTransferTrafficMessage(const TransferTrafficMessage *msg,
llarp_router *r) = 0;
llarp::Router *r) = 0;
virtual bool
HandleUpdateExitMessage(const UpdateExitMessage *msg,
llarp_router *r) = 0;
llarp::Router *r) = 0;
virtual bool
HandleUpdateExitVerifyMessage(const UpdateExitVerifyMessage *msg,
llarp_router *r) = 0;
llarp::Router *r) = 0;
virtual bool
HandleCloseExitMessage(const CloseExitMessage *msg, llarp_router *r) = 0;
HandleCloseExitMessage(const CloseExitMessage *msg, llarp::Router *r) = 0;
virtual bool
HandleDataDiscardMessage(const DataDiscardMessage *msg,
llarp_router *r) = 0;
llarp::Router *r) = 0;
virtual bool
HandlePathTransferMessage(const PathTransferMessage *msg,
llarp_router *r) = 0;
llarp::Router *r) = 0;
virtual bool
HandleHiddenServiceFrame(const service::ProtocolFrame *msg) = 0;
virtual bool
HandlePathConfirmMessage(const PathConfirmMessage *msg,
llarp_router *r) = 0;
llarp::Router *r) = 0;
virtual bool
HandlePathLatencyMessage(const PathLatencyMessage *msg,
llarp_router *r) = 0;
llarp::Router *r) = 0;
virtual bool
HandleDHTMessage(const llarp::dht::IMessage *msg, llarp_router *r) = 0;
HandleDHTMessage(const llarp::dht::IMessage *msg, llarp::Router *r) = 0;
};
} // namespace routing
} // namespace llarp

6
include/llarp/routing/message.hpp
Unescape Escape View File

@ -2,12 +2,12 @@
#define LLARP_ROUTING_MESSAGE_HPP
#include <llarp/buffer.h>
#include <llarp/router.h>
#include <llarp/bencode.hpp>
#include <llarp/path_types.hpp>
namespace llarp
{
struct Router;
namespace routing
{
struct IMessageHandler;
@ -24,7 +24,7 @@ namespace llarp
virtual ~IMessage(){};
virtual bool
HandleMessage(IMessageHandler* h, llarp_router* r) const = 0;
HandleMessage(IMessageHandler* h, llarp::Router* r) const = 0;
};
struct InboundMessageParser
@ -32,7 +32,7 @@ namespace llarp
InboundMessageParser();
bool
ParseMessageBuffer(llarp_buffer_t buf, IMessageHandler* handler,
const PathID_t& from, llarp_router* r);
const PathID_t& from, llarp::Router* r);
private:
static bool

9
include/llarp/rpc.hpp
Unescape Escape View File

@ -6,11 +6,10 @@
#include <functional>
#include <llarp/crypto.hpp>
// forward declare
struct llarp_router;
namespace llarp
{
struct Router;
namespace rpc
{
struct ServerImpl;
@ -18,7 +17,7 @@ namespace llarp
/// jsonrpc server
struct Server
{
Server(llarp_router* r);
Server(llarp::Router* r);
~Server();
bool
@ -33,7 +32,7 @@ namespace llarp
/// jsonrpc caller
struct Caller
{
Caller(llarp_router* r);
Caller(llarp::Router* r);
~Caller();
/// start with jsonrpc endpoint address

5
include/llarp/service/context.hpp
Unescape Escape View File

@ -1,6 +1,5 @@
#ifndef LLARP_SERVICE_CONTEXT_HPP
#define LLARP_SERVICE_CONTEXT_HPP
#include <llarp/router.h>
#include <llarp/net.hpp>
#include <llarp/service/config.hpp>
#include <llarp/service/endpoint.hpp>
@ -14,7 +13,7 @@ namespace llarp
/// holds all the hidden service endpoints we own
struct Context
{
Context(llarp_router *r);
Context(llarp::Router *r);
~Context();
void
@ -74,7 +73,7 @@ namespace llarp
StartAll();
private:
llarp_router *m_Router;
llarp::Router *m_Router;
std::unordered_map< std::string, std::unique_ptr< Endpoint > >
m_Endpoints;
};

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

@ -34,7 +34,7 @@ namespace llarp
static const size_t MAX_OUTBOUND_CONTEXT_COUNT = 4;
Endpoint(const std::string& nickname, llarp_router* r);
Endpoint(const std::string& nickname, llarp::Router* r);
~Endpoint();
void
@ -64,7 +64,7 @@ namespace llarp
llarp_threadpool*
Worker();
llarp_router*
llarp::Router*
Router()
{
return m_Router;
@ -90,10 +90,10 @@ namespace llarp
EnsureReplyPath(const ServiceInfo& addr);
bool
PublishIntroSet(llarp_router* r);
PublishIntroSet(llarp::Router* r);
bool
PublishIntroSetVia(llarp_router* r, path::Path* p);
PublishIntroSetVia(llarp::Router* r, path::Path* p);
bool
HandleGotIntroMessage(const llarp::dht::GotIntroMessage* msg);
@ -428,7 +428,7 @@ namespace llarp
std::unique_ptr< llarp::exit::BaseSession > m_Exit;
private:
llarp_router* m_Router;
llarp::Router* m_Router;
llarp_threadpool* m_IsolatedWorker = nullptr;
llarp::Logic* m_IsolatedLogic = nullptr;
llarp_ev_loop* m_IsolatedNetLoop = nullptr;

3
include/llarp/service/lookup.hpp
Unescape Escape View File

@ -1,7 +1,6 @@
#ifndef LLARP_SERVICE_LOOKUP_HPP
#define LLARP_SERVICE_LOOKUP_HPP
#include <llarp/router.h>
#include <llarp/routing/message.hpp>
#include <llarp/service/IntroSet.hpp>
#include <set>
@ -46,7 +45,7 @@ namespace llarp
/// build a new requset message and send it via a path
bool
SendRequestViaPath(llarp::path::Path* p, llarp_router* r);
SendRequestViaPath(llarp::path::Path* p, llarp::Router* r);
ILookupHolder* parent;
uint64_t txid;

5
include/llarp/service/protocol.hpp
Unescape Escape View File

@ -4,6 +4,7 @@
#include <llarp/bencode.hpp>
#include <llarp/crypto.hpp>
#include <llarp/encrypted.hpp>
#include <llarp/dht/message.hpp>
#include <llarp/routing/message.hpp>
#include <llarp/service/Identity.hpp>
#include <llarp/service/Info.hpp>
@ -13,6 +14,8 @@
namespace llarp
{
class Logic;
namespace service
{
constexpr std::size_t MAX_PROTOCOL_MESSAGE_SIZE = 2048 * 2;
@ -115,7 +118,7 @@ namespace llarp
bool
HandleMessage(llarp::routing::IMessageHandler* h,
llarp_router* r) const override;
llarp::Router* r) const override;
};
} // namespace service
} // namespace llarp

12
llarp/context.cpp
Unescape Escape View File

@ -4,7 +4,7 @@
#include <signal.h>
#include <sys/param.h> // for MIN
#include <llarp.hpp>
#include "router.hpp"
#include <router.hpp>
#include <llarp/dnsd.hpp>
#include <llarp/dns_dotlokilookup.hpp>
@ -149,9 +149,9 @@ namespace llarp
else
logic = new Logic;
router = llarp_init_router(worker, mainloop, logic);
router = new Router(worker, mainloop, logic);
if(!llarp_configure_router(router, config))
if(!router->Configure(config))
{
llarp::LogError("Failed to configure router");
return 1;
@ -169,7 +169,7 @@ namespace llarp
return 1;
}
// run
if(!llarp_run_router(router, nodedb))
if(!router->Run(nodedb))
return 1;
// run net io thread
llarp::LogInfo("running mainloop");
@ -213,7 +213,7 @@ namespace llarp
llarp::LogDebug("stop router");
if(router)
llarp_stop_router(router);
router->Stop();
llarp::LogDebug("stop workers");
if(worker)
@ -236,7 +236,7 @@ namespace llarp
llarp_ev_loop_stop(mainloop);
llarp::LogDebug("free router");
llarp_free_router(&router);
delete router;
llarp::LogDebug("free logic");
delete logic;

6
llarp/dht.cpp
Unescape Escape View File

@ -1,14 +1,14 @@
#include <llarp/dht.h>
#include "router.hpp"
#include <llarp/dht/context.hpp>
#include "router_contact.hpp"
llarp_dht_context::llarp_dht_context(llarp_router *router)
llarp_dht_context::llarp_dht_context(llarp::Router *router)
{
parent = router;
}
struct llarp_dht_context *
llarp_dht_context_new(struct llarp_router *router)
llarp_dht_context_new(llarp::Router *router)
{
return new llarp_dht_context(router);
}

6
llarp/dht/context.cpp
Unescape Escape View File

@ -2,8 +2,8 @@
#include <llarp/dht/messages/gotrouter.hpp>
#include <llarp/messages/dht.hpp>
#include <llarp/messages/dht_immediate.hpp>
#include <vector>
#include "router.hpp"
#include <vector>
namespace llarp
{
@ -79,7 +79,7 @@ namespace llarp
// lookup router
parent->LookupRouter(
pk,
std::bind(&llarp_router::HandleDHTLookupForExplore,
std::bind(&llarp::Router::HandleDHTLookupForExplore,
parent->router, pk, std::placeholders::_1));
}
}
@ -258,7 +258,7 @@ namespace llarp
}
void
Context::Init(const Key_t &us, llarp_router *r,
Context::Init(const Key_t &us, llarp::Router *r,
llarp_time_t exploreInterval)
{
router = r;

5
llarp/dht/dht_immediate.cpp
Unescape Escape View File

@ -1,5 +1,6 @@
#include <llarp/messages/dht_immediate.hpp>
#include "router.hpp"
#include <router.hpp>
namespace llarp
{
@ -57,7 +58,7 @@ namespace llarp
}
bool
DHTImmeidateMessage::HandleMessage(llarp_router *router) const
DHTImmeidateMessage::HandleMessage(llarp::Router *router) const
{
DHTImmeidateMessage reply(session);
bool result = true;

2
llarp/dht/find_intro.cpp
Unescape Escape View File

@ -10,7 +10,7 @@ namespace llarp
/*
struct IntroSetLookupInformer
{
llarp_router* router;
llarp::Router* router;
service::Address target;
void

4
llarp/dht/find_router.cpp
Unescape Escape View File

@ -1,9 +1,9 @@
#include <llarp/dht/context.hpp>
#include <llarp/dht/messages/findrouter.hpp>
#include <llarp/dht/messages/gotrouter.hpp>
#include <llarp/messages/dht.hpp>
#include "router.hpp"
#include <router.hpp>
namespace llarp
{

4
llarp/dht/got_intro.cpp
Unescape Escape View File

@ -1,8 +1,8 @@
#include <llarp/dht/context.hpp>
#include <llarp/dht/messages/gotintro.hpp>
#include <llarp/messages/dht.hpp>
#include "router.hpp"
#include <router.hpp>
namespace llarp
{

3
llarp/dht/got_router.cpp
Unescape Escape View File

@ -1,7 +1,8 @@
#include <llarp/dht/context.hpp>
#include <llarp/dht/messages/gotrouter.hpp>
#include "router.hpp"
#include <router.hpp>
namespace llarp
{

4
llarp/dht/publish_intro.cpp
Unescape Escape View File

@ -1,9 +1,9 @@
#include <llarp/dht/context.hpp>
#include <llarp/dht/messages/pubintro.hpp>
#include <llarp/messages/dht.hpp>
#include <llarp/messages/dht_immediate.hpp>
#include "router.hpp"
#include <router.hpp>
namespace llarp
{

1
llarp/dns_dotlokilookup.cpp
Unescape Escape View File

@ -1,6 +1,7 @@
#include <llarp/dns_dotlokilookup.hpp>
#include <llarp/handlers/tun.hpp>
#include <llarp/service/context.hpp>
#include <llarp/logic.hpp>
std::string const default_chars =
"abcdefghijklmnaoqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890";

2
llarp/exit/close_exit.cpp
Unescape Escape View File

@ -76,7 +76,7 @@ namespace llarp
}
bool
CloseExitMessage::HandleMessage(IMessageHandler* h, llarp_router* r) const
CloseExitMessage::HandleMessage(IMessageHandler* h, llarp::Router* r) const
{
return h->HandleCloseExitMessage(this, r);
}

2
llarp/exit/context.cpp
Unescape Escape View File

@ -4,7 +4,7 @@ namespace llarp
{
namespace exit
{
Context::Context(llarp_router* r) : m_Router(r)
Context::Context(llarp::Router* r) : m_Router(r)
{
}
Context::~Context()

4
llarp/exit/endpoint.cpp
Unescape Escape View File

@ -1,5 +1,7 @@
#include <llarp/exit/endpoint.hpp>
#include "router.hpp"
#include <llarp/handlers/exit.hpp>
#include <router.hpp>
namespace llarp
{

2
llarp/exit/grant_exit.cpp
Unescape Escape View File

@ -81,7 +81,7 @@ namespace llarp
}
bool
GrantExitMessage::HandleMessage(IMessageHandler* h, llarp_router* r) const
GrantExitMessage::HandleMessage(IMessageHandler* h, llarp::Router* r) const
{
return h->HandleGrantExitMessage(this, r);
}

2
llarp/exit/obtain_exit.cpp
Unescape Escape View File

@ -103,7 +103,7 @@ namespace llarp
}
bool
ObtainExitMessage::HandleMessage(IMessageHandler* h, llarp_router* r) const
ObtainExitMessage::HandleMessage(IMessageHandler* h, llarp::Router* r) const
{
return h->HandleObtainExitMessage(this, r);
}

2
llarp/exit/reject_exit.cpp
Unescape Escape View File

@ -91,7 +91,7 @@ namespace llarp
}
bool
RejectExitMessage::HandleMessage(IMessageHandler* h, llarp_router* r) const
RejectExitMessage::HandleMessage(IMessageHandler* h, llarp::Router* r) const
{
return h->HandleRejectExitMessage(this, r);
}

5
llarp/exit/session.cpp
Unescape Escape View File

@ -1,5 +1,6 @@
#include <llarp/exit/session.hpp>
#include "router.hpp"
#include <llarp/path.hpp>
#include <router.hpp>
namespace llarp
{
@ -7,7 +8,7 @@ namespace llarp
{
BaseSession::BaseSession(const llarp::RouterID& router,
std::function< bool(llarp_buffer_t) > writepkt,
llarp_router* r, size_t numpaths, size_t hoplen)
llarp::Router* r, size_t numpaths, size_t hoplen)
: llarp::path::Builder(r, r->dht, numpaths, hoplen)
, m_ExitRouter(router)
, m_WritePacket(writepkt)

2
llarp/exit/transfer_traffic.cpp
Unescape Escape View File

@ -61,7 +61,7 @@ namespace llarp
bool
TransferTrafficMessage::HandleMessage(IMessageHandler* h,
llarp_router* r) const
llarp::Router* r) const
{
return h->HandleTransferTrafficMessage(this, r);
}

4
llarp/exit/update_exit.cpp
Unescape Escape View File

@ -82,7 +82,7 @@ namespace llarp
}
bool
UpdateExitMessage::HandleMessage(IMessageHandler* h, llarp_router* r) const
UpdateExitMessage::HandleMessage(IMessageHandler* h, llarp::Router* r) const
{
return h->HandleUpdateExitMessage(this, r);
}
@ -118,7 +118,7 @@ namespace llarp
bool
UpdateExitVerifyMessage::HandleMessage(IMessageHandler* h,
llarp_router* r) const
llarp::Router* r) const
{
return h->HandleUpdateExitVerifyMessage(this, r);
}

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

@ -19,7 +19,7 @@ namespace llarp
static_cast< ExitEndpoint * >(tun->user)->Flush();
}
ExitEndpoint::ExitEndpoint(const std::string &name, llarp_router *r)
ExitEndpoint::ExitEndpoint(const std::string &name, llarp::Router *r)
: m_Router(r)
, m_Name(name)
, m_Tun{{0}, 0, {0}, 0, 0, 0, 0, 0, 0, 0}
@ -108,7 +108,7 @@ namespace llarp
return true;
}
llarp_router *
llarp::Router *
ExitEndpoint::Router()
{
return m_Router;

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

@ -2,7 +2,6 @@
// harmless on other platforms
#define __USE_MINGW_ANSI_STDIO 1
#include <llarp/handlers/tun.hpp>
#include "router.hpp"
#include <sys/types.h>
#ifndef _WIN32
#include <sys/socket.h>
@ -10,6 +9,8 @@
#endif
#include "ev.hpp"
#include <router.hpp>
namespace llarp
{
namespace handlers
@ -20,7 +21,7 @@ namespace llarp
return static_cast< TunEndpoint * >(tun->user)->Promise.get();
}
TunEndpoint::TunEndpoint(const std::string &nickname, llarp_router *r)
TunEndpoint::TunEndpoint(const std::string &nickname, llarp::Router *r)
: service::Endpoint(nickname, r)
, m_UserToNetworkPktQueue(nickname + "_sendq", r->netloop, r->netloop)
, m_NetworkToUserPktQueue(nickname + "_recvq", r->netloop, r->netloop)

3
llarp/link/curvecp.cpp
Unescape Escape View File

@ -1,5 +1,4 @@
#include <llarp/link/curvecp.hpp>
#include "router.hpp"
#include <llarp/messages/link_intro.hpp>
namespace llarp
@ -7,7 +6,7 @@ namespace llarp
namespace curvecp
{
std::unique_ptr< ILinkLayer >
NewServer(__attribute__((unused)) llarp_router* r)
NewServer(__attribute__((unused)) llarp::Router* r)
{
return nullptr;
}

15
llarp/link/utp.cpp
Unescape Escape View File

@ -1,5 +1,4 @@
#include <llarp/link/utp.hpp>
#include "router.hpp"
#include <llarp/messages/link_intro.hpp>
#include <llarp/messages/discard.hpp>
#include <llarp/buffer.hpp>
@ -9,6 +8,8 @@
#include <tuple>
#include <deque>
#include <router.hpp>
#ifdef __linux__
#include <linux/errqueue.h>
#include <netinet/ip_icmp.h>
@ -92,7 +93,7 @@ namespace llarp
eClose // utp connection is closed
};
llarp_router*
llarp::Router*
Router();
State state;
@ -323,7 +324,7 @@ namespace llarp
struct LinkLayer : public ILinkLayer
{
utp_context* _utp_ctx = nullptr;
llarp_router* router = nullptr;
llarp::Router* router = nullptr;
static uint64
OnRead(utp_callback_arguments* arg);
@ -437,7 +438,7 @@ namespace llarp
return 0;
}
LinkLayer(llarp_router* r) : ILinkLayer()
LinkLayer(llarp::Router* r) : ILinkLayer()
{
router = r;
_utp_ctx = utp_init(2);
@ -584,7 +585,7 @@ namespace llarp
{
}
llarp_router*
llarp::Router*
GetRouter();
bool
@ -618,7 +619,7 @@ namespace llarp
};
std::unique_ptr< ILinkLayer >
NewServer(llarp_router* r)
NewServer(llarp::Router* r)
{
return std::unique_ptr< LinkLayer >(new LinkLayer(r));
}
@ -803,7 +804,7 @@ namespace llarp
EnterState(eSessionReady);
}
llarp_router*
llarp::Router*
BaseSession::Router()
{
return parent->router;

2
llarp/link_intro.cpp
Unescape Escape View File

@ -114,7 +114,7 @@ namespace llarp
}
bool
LinkIntroMessage::HandleMessage(llarp_router* router) const
LinkIntroMessage::HandleMessage(llarp::Router* router) const
{
if(!Verify(&router->crypto))
return false;

3
llarp/link_message.cpp
Unescape Escape View File

@ -2,11 +2,10 @@
#include <llarp/messages.hpp>
#include "buffer.hpp"
#include "logger.hpp"
#include "router.hpp"
namespace llarp
{
InboundMessageParser::InboundMessageParser(llarp_router* _router)
InboundMessageParser::InboundMessageParser(Router* _router)
: router(_router)
{
}

42
llarp/path.cpp
Unescape Escape View File

@ -4,15 +4,15 @@
#include <llarp/pathbuilder.hpp>
#include <llarp/messages/dht.hpp>
#include <llarp/messages/discard.hpp>
#include <llarp/endian.hpp>
#include "buffer.hpp"
#include "router.hpp"
#include <llarp/endian.hpp>
namespace llarp
{
namespace path
{
PathContext::PathContext(llarp_router* router)
PathContext::PathContext(llarp::Router* router)
: m_Router(router), m_AllowTransit(false)
{
}
@ -204,7 +204,7 @@ namespace llarp
return m_Router->pubkey();
}
llarp_router*
llarp::Router*
PathContext::Router()
{
return m_Router;
@ -418,7 +418,7 @@ namespace llarp
}
void
Path::Tick(llarp_time_t now, llarp_router* r)
Path::Tick(llarp_time_t now, llarp::Router* r)
{
if(Expired(now))
return;
@ -488,7 +488,7 @@ namespace llarp
bool
Path::HandleUpstream(llarp_buffer_t buf, const TunnelNonce& Y,
llarp_router* r)
llarp::Router* r)
{
TunnelNonce n = Y;
for(const auto& hop : hops)
@ -527,7 +527,7 @@ namespace llarp
bool
Path::HandleDownstream(llarp_buffer_t buf, const TunnelNonce& Y,
llarp_router* r)
llarp::Router* r)
{
TunnelNonce n = Y;
for(const auto& hop : hops)
@ -539,7 +539,7 @@ namespace llarp
}
bool
Path::HandleRoutingMessage(llarp_buffer_t buf, llarp_router* r)
Path::HandleRoutingMessage(llarp_buffer_t buf, llarp::Router* r)
{
if(!m_InboundMessageParser.ParseMessageBuffer(buf, this, RXID(), r))
{
@ -551,7 +551,7 @@ namespace llarp
bool
Path::HandleUpdateExitVerifyMessage(
const llarp::routing::UpdateExitVerifyMessage* msg, llarp_router* r)
const llarp::routing::UpdateExitVerifyMessage* msg, llarp::Router* r)
{
(void)r;
if(m_UpdateExitTX && msg->T == m_UpdateExitTX)
@ -569,7 +569,7 @@ namespace llarp
bool
Path::SendRoutingMessage(const llarp::routing::IMessage* msg,
llarp_router* r)
llarp::Router* r)
{
byte_t tmp[MAX_LINK_MSG_SIZE / 2];
auto buf = llarp::StackBuffer< decltype(tmp) >(tmp);
@ -597,7 +597,7 @@ namespace llarp
bool
Path::HandlePathTransferMessage(
__attribute__((unused)) const llarp::routing::PathTransferMessage* msg,
__attribute__((unused)) llarp_router* r)
__attribute__((unused)) llarp::Router* r)
{
llarp::LogWarn("unwarranted path transfer message on tx=", TXID(),
" rx=", RXID());
@ -606,7 +606,7 @@ namespace llarp
bool
Path::HandleDataDiscardMessage(
const llarp::routing::DataDiscardMessage* msg, llarp_router* r)
const llarp::routing::DataDiscardMessage* msg, llarp::Router* r)
{
MarkActive(r->Now());
if(m_DropHandler)
@ -617,7 +617,7 @@ namespace llarp
bool
Path::HandlePathConfirmMessage(
__attribute__((unused)) const llarp::routing::PathConfirmMessage* msg,
llarp_router* r)
llarp::Router* r)
{
auto now = r->Now();
if(_status == ePathBuilding)
@ -658,7 +658,7 @@ namespace llarp
bool
Path::HandlePathLatencyMessage(
const llarp::routing::PathLatencyMessage* msg, llarp_router* r)
const llarp::routing::PathLatencyMessage* msg, llarp::Router* r)
{
auto now = r->Now();
MarkActive(now);
@ -680,7 +680,7 @@ namespace llarp
}
bool
Path::HandleDHTMessage(const llarp::dht::IMessage* msg, llarp_router* r)
Path::HandleDHTMessage(const llarp::dht::IMessage* msg, llarp::Router* r)
{
llarp::routing::DHTMessage reply;
if(!msg->HandleMessage(r->dht, reply.M))
@ -693,7 +693,7 @@ namespace llarp
bool
Path::HandleCloseExitMessage(const llarp::routing::CloseExitMessage* msg,
llarp_router* r)
llarp::Router* r)
{
/// allows exits to close from their end
if(SupportsAnyRoles(ePathRoleExit | ePathRoleSVC))
@ -714,7 +714,7 @@ namespace llarp
bool
Path::SendExitRequest(const llarp::routing::ObtainExitMessage* msg,
llarp_router* r)
llarp::Router* r)
{
llarp::LogInfo(Name(), " sending exit request to ", Endpoint());
m_ExitObtainTX = msg->T;
@ -723,7 +723,7 @@ namespace llarp
bool
Path::HandleObtainExitMessage(const llarp::routing::ObtainExitMessage* msg,
llarp_router* r)
llarp::Router* r)
{
(void)msg;
(void)r;
@ -733,7 +733,7 @@ namespace llarp
bool
Path::HandleUpdateExitMessage(const llarp::routing::UpdateExitMessage* msg,
llarp_router* r)
llarp::Router* r)
{
(void)msg;
(void)r;
@ -743,7 +743,7 @@ namespace llarp
bool
Path::HandleRejectExitMessage(const llarp::routing::RejectExitMessage* msg,
llarp_router* r)
llarp::Router* r)
{
if(m_ExitObtainTX && msg->T == m_ExitObtainTX)
{
@ -762,7 +762,7 @@ namespace llarp
bool
Path::HandleGrantExitMessage(const llarp::routing::GrantExitMessage* msg,
llarp_router* r)
llarp::Router* r)
{
if(m_ExitObtainTX && msg->T == m_ExitObtainTX)
{
@ -793,7 +793,7 @@ namespace llarp
bool
Path::HandleTransferTrafficMessage(
const llarp::routing::TransferTrafficMessage* msg, llarp_router* r)
const llarp::routing::TransferTrafficMessage* msg, llarp::Router* r)
{
// check if we can handle exit data
if(!SupportsAnyRoles(ePathRoleExit | ePathRoleSVC))

4
llarp/pathbuilder.cpp
Unescape Escape View File

@ -20,7 +20,7 @@ namespace llarp
Handler result;
size_t idx = 0;
llarp_router* router = nullptr;
llarp::Router* router = nullptr;
llarp_threadpool* worker = nullptr;
llarp::Logic* logic = nullptr;
llarp_crypto* crypto = nullptr;
@ -153,7 +153,7 @@ namespace llarp
namespace path
{
Builder::Builder(llarp_router* p_router, struct llarp_dht_context* p_dht,
Builder::Builder(llarp::Router* p_router, struct llarp_dht_context* p_dht,
size_t pathNum, size_t hops)
: llarp::path::PathSet(pathNum)
, router(p_router)

2
llarp/pathset.cpp
Unescape Escape View File

@ -57,7 +57,7 @@ namespace llarp
}
void
PathSet::Tick(llarp_time_t now, llarp_router* r)
PathSet::Tick(llarp_time_t now, llarp::Router* r)
{
Lock_t l(m_PathsMutex);
for(auto& item : m_Paths)

3
llarp/relay_commit.cpp
Unescape Escape View File

@ -1,4 +1,5 @@
#include <llarp/bencode.hpp>
#include <llarp/path.hpp>
#include <llarp/messages/path_confirm.hpp>
#include <llarp/messages/relay_commit.hpp>
#include "buffer.hpp"
@ -45,7 +46,7 @@ namespace llarp
}
bool
LR_CommitMessage::HandleMessage(llarp_router* router) const
LR_CommitMessage::HandleMessage(llarp::Router* router) const
{
if(frames.size() != MAXHOPS)
{

4
llarp/relay_up_down.cpp
Unescape Escape View File

@ -54,7 +54,7 @@ namespace llarp
}
bool
RelayUpstreamMessage::HandleMessage(llarp_router *r) const
RelayUpstreamMessage::HandleMessage(llarp::Router *r) const
{
auto path = r->paths.GetByDownstream(session->GetPubKey(), pathid);
if(path)
@ -112,7 +112,7 @@ namespace llarp
}
bool
RelayDownstreamMessage::HandleMessage(llarp_router *r) const
RelayDownstreamMessage::HandleMessage(llarp::Router *r) const
{
auto path = r->paths.GetByUpstream(session->GetPubKey(), pathid);
if(path)

355
llarp/router.cpp
Unescape Escape View File

@ -1,4 +1,3 @@
#include "router.hpp"
#include <llarp/proto.hpp>
#include <llarp/iwp.hpp>
#include <llarp/link_message.hpp>
@ -9,6 +8,7 @@
#include "encode.hpp"
#include "llarp/net.hpp"
#include "logger.hpp"
#include "router.hpp"
#include "str.hpp"
#include <fstream>
@ -25,7 +25,7 @@ namespace llarp
struct async_verify_context
{
llarp_router *router;
Router *router;
TryConnectJob *establish_job;
};
@ -35,10 +35,10 @@ struct TryConnectJob
{
llarp::RouterContact rc;
llarp::ILinkLayer *link;
llarp_router *router;
llarp::Router *router;
uint16_t triesLeft;
TryConnectJob(const llarp::RouterContact &remote, llarp::ILinkLayer *l,
uint16_t tries, llarp_router *r)
uint16_t tries, llarp::Router *r)
: rc(remote), link(l), router(r), triesLeft(tries)
{
}
@ -98,7 +98,7 @@ on_try_connecting(void *u)
}
bool
llarp_router_try_connect(struct llarp_router *router,
llarp_router_try_connect(llarp::Router *router,
const llarp::RouterContact &remote,
uint16_t numretries)
{
@ -119,15 +119,77 @@ llarp_router_try_connect(struct llarp_router *router,
return true;
}
bool
llarp_findOrCreateIdentity(llarp_crypto *crypto, const char *fpath,
byte_t *secretkey)
{
llarp::LogDebug("find or create ", fpath);
fs::path path(fpath);
std::error_code ec;
if(!fs::exists(path, ec))
{
llarp::LogInfo("generating new identity key");
crypto->identity_keygen(secretkey);
std::ofstream f(path.string(), std::ios::binary);
if(f.is_open())
{
f.write((char *)secretkey, SECKEYSIZE);
}
}
std::ifstream f(path.string(), std::ios::binary);
if(f.is_open())
{
f.read((char *)secretkey, SECKEYSIZE);
return true;
}
llarp::LogInfo("failed to get identity key");
return false;
}
// C++ ...
bool
llarp_findOrCreateEncryption(llarp_crypto *crypto, const char *fpath,
llarp::SecretKey &encryption)
{
llarp::LogDebug("find or create ", fpath);
fs::path path(fpath);
std::error_code ec;
if(!fs::exists(path, ec))
{
llarp::LogInfo("generating new encryption key");
crypto->encryption_keygen(encryption);
std::ofstream f(path.string(), std::ios::binary);
if(f.is_open())
{
f.write((char *)encryption.data(), SECKEYSIZE);
}
}
std::ifstream f(path.string(), std::ios::binary);
if(f.is_open())
{
f.read((char *)encryption.data(), SECKEYSIZE);
return true;
}
llarp::LogInfo("failed to get encryption key");
return false;
}
namespace llarp
{
void
llarp_router::HandleLinkSessionEstablished(llarp::RouterContact rc,
Router::HandleLinkSessionEstablished(llarp::RouterContact rc,
llarp::ILinkLayer *link)
{
async_verify_RC(rc, link);
}
llarp_router::llarp_router()
Router::Router(struct llarp_threadpool *_tp, struct llarp_ev_loop *_netloop,
llarp::Logic *_logic)
: ready(false)
, netloop(_netloop)
, tp(_tp)
, logic(_logic)
, paths(this)
, exitContext(this)
, dht(llarp_dht_context_new(this))
@ -138,15 +200,22 @@ llarp_router::llarp_router()
// set rational defaults
this->ip4addr.sin_family = AF_INET;
this->ip4addr.sin_port = htons(1090);
#ifdef TESTNET
disk = tp;
#else
disk = llarp_init_threadpool(1, "llarp-diskio");
#endif
llarp_crypto_init(&crypto);
}
llarp_router::~llarp_router()
Router::~Router()
{
llarp_dht_context_free(dht);
}
bool
llarp_router::HandleRecvLinkMessageBuffer(llarp::ILinkSession *session,
Router::HandleRecvLinkMessageBuffer(llarp::ILinkSession *session,
llarp_buffer_t buf)
{
if(!session)
@ -158,17 +227,17 @@ llarp_router::HandleRecvLinkMessageBuffer(llarp::ILinkSession *session,
}
void
llarp_router::PersistSessionUntil(const llarp::RouterID &remote,
llarp_time_t until)
Router::PersistSessionUntil(const llarp::RouterID &remote, llarp_time_t until)
{
llarp::LogDebug("persist session to ", remote, " until ", until);
m_PersistingSessions[remote] = std::max(until, m_PersistingSessions[remote]);
m_PersistingSessions[remote] =
std::max(until, m_PersistingSessions[remote]);
}
constexpr size_t MaxPendingSendQueueSize = 8;
bool
llarp_router::SendToOrQueue(const llarp::RouterID &remote,
Router::SendToOrQueue(const llarp::RouterID &remote,
const llarp::ILinkMessage *msg)
{
for(const auto &link : inboundLinks)
@ -223,18 +292,20 @@ llarp_router::SendToOrQueue(const llarp::RouterID &remote,
// we don't have the RC locally so do a dht lookup
dht->impl.LookupRouter(remote,
std::bind(&llarp_router::HandleDHTLookupForSendTo,
this, remote, std::placeholders::_1));
std::bind(&Router::HandleDHTLookupForSendTo, this,
remote, std::placeholders::_1));
return true;
}
void
llarp_router::HandleDHTLookupForSendTo(
llarp::RouterID remote, const std::vector< llarp::RouterContact > &results)
Router::HandleDHTLookupForSendTo(
llarp::RouterID remote,
const std::vector< llarp::RouterContact > &results)
{
if(results.size())
{
if(whitelistRouters && lokinetRouters.find(remote) == lokinetRouters.end())
if(whitelistRouters
&& lokinetRouters.find(remote) == lokinetRouters.end())
{
return;
}
@ -251,7 +322,7 @@ llarp_router::HandleDHTLookupForSendTo(
}
void
llarp_router::ForEachPeer(
Router::ForEachPeer(
std::function< void(const llarp::ILinkSession *, bool) > visit) const
{
outboundLink->ForEachSession(
@ -264,7 +335,7 @@ llarp_router::ForEachPeer(
}
void
llarp_router::try_connect(fs::path rcfile)
Router::try_connect(fs::path rcfile)
{
llarp::RouterContact remote;
if(!remote.Read(rcfile.string().c_str()))
@ -291,7 +362,7 @@ llarp_router::try_connect(fs::path rcfile)
}
bool
llarp_router::EnsureIdentity()
Router::EnsureIdentity()
{
if(!EnsureEncryptionKey())
return false;
@ -300,26 +371,42 @@ llarp_router::EnsureIdentity()
}
bool
llarp_router::EnsureEncryptionKey()
Router::EnsureEncryptionKey()
{
return llarp_findOrCreateEncryption(
&crypto, encryption_keyfile.string().c_str(), encryption);
}
void
llarp_router::AddInboundLink(std::unique_ptr< llarp::ILinkLayer > &link)
Router::AddInboundLink(std::unique_ptr< llarp::ILinkLayer > &link)
{
inboundLinks.push_back(std::move(link));
}
bool
llarp_router::Ready()
Router::Configure(struct llarp_config *conf)
{
llarp_config_iterator iter;
iter.user = this;
iter.visit = llarp::router_iter_config;
llarp_config_iter(conf, &iter);
if(!InitOutboundLink())
return false;
if(!Ready())
{
return false;
}
return EnsureIdentity();
}
bool
Router::Ready()
{
return outboundLink != nullptr;
}
bool
llarp_router::SaveRC()
Router::SaveRC()
{
llarp::LogDebug("verify RC signature");
if(!rc().Verify(&crypto))
@ -332,13 +419,13 @@ llarp_router::SaveRC()
}
bool
llarp_router::IsServiceNode() const
Router::IsServiceNode() const
{
return inboundLinks.size() > 0;
}
void
llarp_router::Close()
Router::Close()
{
for(const auto &link : inboundLinks)
{
@ -353,7 +440,7 @@ llarp_router::Close()
}
void
llarp_router::on_verify_client_rc(llarp_async_verify_rc *job)
Router::on_verify_client_rc(llarp_async_verify_rc *job)
{
llarp::async_verify_context *ctx =
static_cast< llarp::async_verify_context * >(job->user);
@ -366,7 +453,7 @@ llarp_router::on_verify_client_rc(llarp_async_verify_rc *job)
}
void
llarp_router::on_verify_server_rc(llarp_async_verify_rc *job)
Router::on_verify_server_rc(llarp_async_verify_rc *job)
{
llarp::async_verify_context *ctx =
static_cast< llarp::async_verify_context * >(job->user);
@ -416,18 +503,18 @@ llarp_router::on_verify_server_rc(llarp_async_verify_rc *job)
}
void
llarp_router::handle_router_ticker(void *user, uint64_t orig, uint64_t left)
Router::handle_router_ticker(void *user, uint64_t orig, uint64_t left)
{
if(left)
return;
llarp_router *self = static_cast< llarp_router * >(user);
Router *self = static_cast< Router * >(user);
self->ticker_job_id = 0;
self->Tick();
self->ScheduleTicker(orig);
}
bool
llarp_router::ConnectionToRouterAllowed(const llarp::RouterID &router) const
Router::ConnectionToRouterAllowed(const llarp::RouterID &router) const
{
if(strictConnectPubkeys.size() && strictConnectPubkeys.count(router) == 0)
return false;
@ -438,8 +525,9 @@ llarp_router::ConnectionToRouterAllowed(const llarp::RouterID &router) const
}
void
llarp_router::HandleDHTLookupForExplore(
llarp::RouterID remote, const std::vector< llarp::RouterContact > &results)
Router::HandleDHTLookupForExplore(
llarp::RouterID remote,
const std::vector< llarp::RouterContact > &results)
{
if(results.size() == 0)
return;
@ -457,7 +545,7 @@ llarp_router::HandleDHTLookupForExplore(
}
void
llarp_router::TryEstablishTo(const llarp::RouterID &remote)
Router::TryEstablishTo(const llarp::RouterID &remote)
{
if(!ConnectionToRouterAllowed(remote))
{
@ -480,7 +568,7 @@ llarp_router::TryEstablishTo(const llarp::RouterID &remote)
// dht lookup as we don't know it
dht->impl.LookupRouter(
remote,
std::bind(&llarp_router::HandleDHTLookupForTryEstablishTo, this, remote,
std::bind(&Router::HandleDHTLookupForTryEstablishTo, this, remote,
std::placeholders::_1));
}
else
@ -490,7 +578,7 @@ llarp_router::TryEstablishTo(const llarp::RouterID &remote)
}
void
llarp_router::OnConnectTimeout(const llarp::RouterID &remote)
Router::OnConnectTimeout(const llarp::RouterID &remote)
{
auto itr = pendingEstablishJobs.find(remote);
if(itr != pendingEstablishJobs.end())
@ -500,8 +588,9 @@ llarp_router::OnConnectTimeout(const llarp::RouterID &remote)
}
void
llarp_router::HandleDHTLookupForTryEstablishTo(
llarp::RouterID remote, const std::vector< llarp::RouterContact > &results)
Router::HandleDHTLookupForTryEstablishTo(
llarp::RouterID remote,
const std::vector< llarp::RouterContact > &results)
{
if(results.size() == 0)
{
@ -519,13 +608,13 @@ llarp_router::HandleDHTLookupForTryEstablishTo(
}
size_t
llarp_router::NumberOfConnectedRouters() const
Router::NumberOfConnectedRouters() const
{
return validRouters.size();
}
void
llarp_router::Tick()
Router::Tick()
{
// llarp::LogDebug("tick router");
auto now = llarp_ev_loop_time_now_ms(netloop);
@ -590,7 +679,7 @@ llarp_router::Tick()
}
void
llarp_router::SendTo(llarp::RouterID remote, const llarp::ILinkMessage *msg,
Router::SendTo(llarp::RouterID remote, const llarp::ILinkMessage *msg,
llarp::ILinkLayer *selected)
{
llarp_buffer_t buf =
@ -627,13 +716,13 @@ llarp_router::SendTo(llarp::RouterID remote, const llarp::ILinkMessage *msg,
}
void
llarp_router::ScheduleTicker(uint64_t ms)
Router::ScheduleTicker(uint64_t ms)
{
ticker_job_id = logic->call_later({ms, this, &handle_router_ticker});
}
void
llarp_router::SessionClosed(const llarp::RouterID &remote)
Router::SessionClosed(const llarp::RouterID &remote)
{
__llarp_dht_remove_peer(dht, remote);
// remove from valid routers if it's a valid router
@ -642,7 +731,7 @@ llarp_router::SessionClosed(const llarp::RouterID &remote)
}
llarp::ILinkLayer *
llarp_router::GetLinkWithSessionByPubkey(const llarp::RouterID &pubkey)
Router::GetLinkWithSessionByPubkey(const llarp::RouterID &pubkey)
{
if(outboundLink->HasSessionTo(pubkey))
return outboundLink.get();
@ -655,8 +744,7 @@ llarp_router::GetLinkWithSessionByPubkey(const llarp::RouterID &pubkey)
}
void
llarp_router::FlushOutboundFor(llarp::RouterID remote,
llarp::ILinkLayer *chosen)
Router::FlushOutboundFor(llarp::RouterID remote, llarp::ILinkLayer *chosen)
{
llarp::LogDebug("Flush outbound for ", remote);
@ -685,13 +773,13 @@ llarp_router::FlushOutboundFor(llarp::RouterID remote,
}
void
llarp_router::DiscardOutboundFor(const llarp::RouterID &remote)
Router::DiscardOutboundFor(const llarp::RouterID &remote)
{
outboundMessageQueue.erase(remote);
}
bool
llarp_router::GetRandomConnectedRouter(llarp::RouterContact &result) const
Router::GetRandomConnectedRouter(llarp::RouterContact &result) const
{
auto sz = validRouters.size();
if(sz)
@ -706,7 +794,7 @@ llarp_router::GetRandomConnectedRouter(llarp::RouterContact &result) const
}
void
llarp_router::async_verify_RC(const llarp::RouterContact &rc,
Router::async_verify_RC(const llarp::RouterContact &rc,
llarp::ILinkLayer *link)
{
if(pendingVerifyRC.count(rc.pubkey))
@ -740,16 +828,18 @@ llarp_router::async_verify_RC(const llarp::RouterContact &rc,
job->cryptoworker = tp;
job->diskworker = disk;
if(rc.IsPublicRouter())
job->hook = &llarp_router::on_verify_server_rc;
job->hook = &Router::on_verify_server_rc;
else
job->hook = &llarp_router::on_verify_client_rc;
job->hook = &Router::on_verify_client_rc;
llarp_nodedb_async_verify(job);
}
bool
llarp_router::Run()
Router::Run(struct llarp_nodedb *nodedb)
{
this->nodedb = nodedb;
if(enableRPCServer)
{
if(rpcBindAddr.empty())
@ -925,26 +1015,24 @@ llarp_router::Run()
return true;
}
bool
llarp_router::InitServiceNode()
void
Router::Stop()
{
llarp::LogInfo("accepting transit traffic");
paths.AllowTransit();
llarp_dht_allow_transit(dht);
return exitContext.AddExitEndpoint("default-connectivity", netConfig);
this->Close();
this->routerProfiling.Save(this->routerProfilesFile.c_str());
}
bool
llarp_router::HasSessionTo(const llarp::RouterID &remote) const
Router::HasSessionTo(const llarp::RouterID &remote) const
{
return validRouters.find(remote) != validRouters.end();
}
void
llarp_router::ConnectToRandomRouters(int want)
Router::ConnectToRandomRouters(int want)
{
int wanted = want;
llarp_router *self = this;
Router *self = this;
llarp_nodedb_visit_loaded(
self->nodedb, [self, &want](const llarp::RouterContact &other) -> bool {
// check if we really want to
@ -965,14 +1053,23 @@ llarp_router::ConnectToRandomRouters(int want)
}
bool
llarp_router::ReloadConfig(__attribute__((unused)) const llarp_config *conf)
Router::InitServiceNode()
{
llarp::LogInfo("accepting transit traffic");
paths.AllowTransit();
llarp_dht_allow_transit(dht);
return exitContext.AddExitEndpoint("default-connectivity", netConfig);
}
bool
Router::ReloadConfig(__attribute__((unused)) const llarp_config *conf)
{
// TODO: implement me
return true;
}
bool
llarp_router::InitOutboundLink()
Router::InitOutboundLink()
{
if(outboundLink)
return true;
@ -1000,7 +1097,7 @@ llarp_router::InitOutboundLink()
}
bool
llarp_router::CreateDefaultHiddenService()
Router::CreateDefaultHiddenService()
{
// fallback defaults
static const std::unordered_map< std::string,
@ -1025,133 +1122,13 @@ llarp_router::CreateDefaultHiddenService()
}
bool
llarp_router::HasPendingConnectJob(const llarp::RouterID &remote)
Router::HasPendingConnectJob(const llarp::RouterID &remote)
{
return pendingEstablishJobs.find(remote) != pendingEstablishJobs.end();
}
struct llarp_router *
llarp_init_router(struct llarp_threadpool *tp, struct llarp_ev_loop *netloop,
llarp::Logic *logic)
{
llarp_router *router = new llarp_router();
if(router)
{
router->netloop = netloop;
router->tp = tp;
router->logic = logic;
// TODO: make disk io threadpool count configurable (?)
#ifdef TESTNET
router->disk = tp;
#else
router->disk = llarp_init_threadpool(1, "llarp-diskio");
#endif
llarp_crypto_init(&router->crypto);
}
return router;
}
bool
llarp_configure_router(struct llarp_router *router, struct llarp_config *conf)
{
llarp_config_iterator iter;
iter.user = router;
iter.visit = llarp::router_iter_config;
llarp_config_iter(conf, &iter);
if(!router->InitOutboundLink())
return false;
if(!router->Ready())
{
return false;
}
return router->EnsureIdentity();
}
bool
llarp_run_router(struct llarp_router *router, struct llarp_nodedb *nodedb)
{
router->nodedb = nodedb;
return router->Run();
}
void
llarp_stop_router(struct llarp_router *router)
{
if(router)
{
router->Close();
router->routerProfiling.Save(router->routerProfilesFile.c_str());
}
}
void
llarp_free_router(struct llarp_router **router)
{
if(*router)
{
delete *router;
}
*router = nullptr;
}
bool
llarp_findOrCreateIdentity(llarp_crypto *crypto, const char *fpath,
byte_t *secretkey)
{
llarp::LogDebug("find or create ", fpath);
fs::path path(fpath);
std::error_code ec;
if(!fs::exists(path, ec))
{
llarp::LogInfo("generating new identity key");
crypto->identity_keygen(secretkey);
std::ofstream f(path.string(), std::ios::binary);
if(f.is_open())
{
f.write((char *)secretkey, SECKEYSIZE);
}
}
std::ifstream f(path.string(), std::ios::binary);
if(f.is_open())
{
f.read((char *)secretkey, SECKEYSIZE);
return true;
}
llarp::LogInfo("failed to get identity key");
return false;
}
// C++ ...
bool
llarp_findOrCreateEncryption(llarp_crypto *crypto, const char *fpath,
llarp::SecretKey &encryption)
{
llarp::LogDebug("find or create ", fpath);
fs::path path(fpath);
std::error_code ec;
if(!fs::exists(path, ec))
{
llarp::LogInfo("generating new encryption key");
crypto->encryption_keygen(encryption);
std::ofstream f(path.string(), std::ios::binary);
if(f.is_open())
{
f.write((char *)encryption.data(), SECKEYSIZE);
}
}
std::ifstream f(path.string(), std::ios::binary);
if(f.is_open())
{
f.read((char *)encryption.data(), SECKEYSIZE);
return true;
}
llarp::LogInfo("failed to get encryption key");
return false;
}
bool
llarp_router::LoadHiddenServiceConfig(const char *fname)
Router::LoadHiddenServiceConfig(const char *fname)
{
llarp::LogDebug("opening hidden service config ", fname);
llarp::service::Config conf;
@ -1168,14 +1145,12 @@ llarp_router::LoadHiddenServiceConfig(const char *fname)
return true;
}
namespace llarp
{
void
router_iter_config(llarp_config_iterator *iter, const char *section,
const char *key, const char *val)
{
llarp::LogDebug(section, " ", key, "=", val);
llarp_router *self = static_cast< llarp_router * >(iter->user);
Router *self = static_cast< Router * >(iter->user);
int af;
uint16_t proto;

73
llarp/router.hpp
Unescape Escape View File

@ -1,11 +1,25 @@
#ifndef LLARP_ROUTER_HPP
#define LLARP_ROUTER_HPP
#include <llarp/buffer.h>
#include <llarp/config.h>
#include <llarp/dht.h>
#include <llarp/dht.hpp>
#include <llarp/establish_job.hpp>
#include <llarp/ev.h>
#include <llarp/exit.hpp>
#include <llarp/handlers/tun.hpp>
#include <llarp/link_layer.hpp>
#include <llarp/link_message.hpp>
#include <llarp/logic.hpp>
#include <llarp/nodedb.hpp>
#include <llarp/router_contact.hpp>
#include <llarp/path.hpp>
#include <llarp/link_layer.hpp>
#include <llarp/profiling.hpp>
#include <llarp/router_contact.hpp>
#include <llarp/routing/handler.hpp>
#include <llarp/rpc.hpp>
#include <llarp/service.hpp>
#include <threadpool.hpp>
#include <functional>
#include <list>
@ -13,27 +27,24 @@
#include <vector>
#include <unordered_map>
#include <llarp/dht.hpp>
#include <llarp/handlers/tun.hpp>
#include <llarp/link_message.hpp>
#include <llarp/routing/handler.hpp>
#include <llarp/service.hpp>
#include <llarp/establish_job.hpp>
#include <llarp/profiling.hpp>
#include <llarp/exit.hpp>
#include "crypto.hpp"
#include "fs.hpp"
#include "mem.hpp"
#include "str.hpp"
#include <crypto.hpp>
#include <fs.hpp>
#include <mem.hpp>
#include <str.hpp>
bool
llarp_findOrCreateEncryption(llarp_crypto *crypto, const char *fpath,
llarp::SecretKey &encryption);
bool
llarp_findOrCreateIdentity(struct llarp_crypto *crypto, const char *path,
byte_t *secretkey);
struct TryConnectJob;
struct llarp_router
namespace llarp
{
struct Router
{
bool ready;
// transient iwp encryption key
@ -169,11 +180,13 @@ struct llarp_router
// lokinet routers from lokid, maps pubkey to when we think it will expire,
// set to max value right now
std::unordered_map< llarp::RouterID, llarp_time_t, llarp::RouterID::Hash >
std::unordered_map< llarp::RouterID, llarp_time_t, llarp::PubKey::Hash >
lokinetRouters;
llarp_router();
~llarp_router();
Router(struct llarp_threadpool *tp, struct llarp_ev_loop *netloop,
llarp::Logic *logic);
~Router();
void
HandleLinkSessionEstablished(llarp::RouterContact, llarp::ILinkLayer *);
@ -205,11 +218,17 @@ struct llarp_router
bool
AddHiddenService(const llarp::service::Config::section_t &config);
bool
Configure(struct llarp_config *conf);
bool
Ready();
bool
Run();
Run(struct llarp_nodedb *nodedb);
void
Stop();
void
PersistSessionUntil(const llarp::RouterID &remote, llarp_time_t until);
@ -250,7 +269,8 @@ struct llarp_router
/// NOT threadsafe
/// MUST be called in the logic thread
bool
SendToOrQueue(const llarp::RouterID &remote, const llarp::ILinkMessage *msg);
SendToOrQueue(const llarp::RouterID &remote,
const llarp::ILinkMessage *msg);
/// sendto or drop
void
@ -259,7 +279,8 @@ struct llarp_router
/// manually flush outbound message queue for just 1 router
void
FlushOutboundFor(llarp::RouterID remote, llarp::ILinkLayer *chosen = nullptr);
FlushOutboundFor(llarp::RouterID remote,
llarp::ILinkLayer *chosen = nullptr);
/// manually discard all pending messages to remote router
void
@ -270,7 +291,8 @@ struct llarp_router
TryEstablishTo(const llarp::RouterID &remote);
void
HandleDHTLookupForExplore(llarp::RouterID remote,
HandleDHTLookupForExplore(
llarp::RouterID remote,
const std::vector< llarp::RouterContact > &results);
void
@ -316,7 +338,8 @@ struct llarp_router
async_verify_RC(const llarp::RouterContact &rc, llarp::ILinkLayer *link);
void
HandleDHTLookupForSendTo(llarp::RouterID remote,
HandleDHTLookupForSendTo(
llarp::RouterID remote,
const std::vector< llarp::RouterContact > &results);
bool
@ -351,4 +374,6 @@ struct llarp_router
}
};
} // namespace llarp
#endif

2
llarp/routing/dht_message.cpp
Unescape Escape View File

@ -48,7 +48,7 @@ namespace llarp
}
bool
DHTMessage::HandleMessage(IMessageHandler* h, llarp_router* r) const
DHTMessage::HandleMessage(IMessageHandler* h, llarp::Router* r) const
{
// set source as us
llarp::dht::Key_t us = r->pubkey();

2
llarp/routing/message_parser.cpp
Unescape Escape View File

@ -94,7 +94,7 @@ namespace llarp
InboundMessageParser::ParseMessageBuffer(llarp_buffer_t buf,
IMessageHandler* h,
const PathID_t& from,
llarp_router* r)
llarp::Router* r)
{
bool result = false;
msg = nullptr;

2
llarp/routing/path_confirm.cpp
Unescape Escape View File

@ -51,7 +51,7 @@ namespace llarp
}
bool
PathConfirmMessage::HandleMessage(IMessageHandler* h, llarp_router* r) const
PathConfirmMessage::HandleMessage(IMessageHandler* h, llarp::Router* r) const
{
return h && h->HandlePathConfirmMessage(this, r);
}

2
llarp/routing/path_latency.cpp
Unescape Escape View File

@ -45,7 +45,7 @@ namespace llarp
}
bool
PathLatencyMessage::HandleMessage(IMessageHandler* h, llarp_router* r) const
PathLatencyMessage::HandleMessage(IMessageHandler* h, llarp::Router* r) const
{
return h && h->HandlePathLatencyMessage(this, r);
}

2
llarp/routing/path_transfer.cpp
Unescape Escape View File

@ -57,7 +57,7 @@ namespace llarp
bool
PathTransferMessage::HandleMessage(IMessageHandler* h,
llarp_router* r) const
llarp::Router* r) const
{
return h->HandlePathTransferMessage(this, r);
}

25
llarp/rpc.cpp
Unescape Escape View File

@ -1,6 +1,5 @@
#include <llarp/rpc.hpp>
#include "router.hpp"
#ifdef USE_ABYSS
#include <libabyss.hpp>
#endif
@ -110,12 +109,12 @@ namespace llarp
struct CallerImpl : public ::abyss::http::JSONRPC
{
llarp_router* router;
llarp::Router* router;
llarp_time_t m_NextKeyUpdate;
const llarp_time_t KeyUpdateInterval = 1000 * 60 * 2;
using PubkeyList_t = GetServiceNodeListHandler::PubkeyList_t;
CallerImpl(llarp_router* r) : ::abyss::http::JSONRPC(), router(r)
CallerImpl(llarp::Router* r) : ::abyss::http::JSONRPC(), router(r)
{
}
@ -179,8 +178,8 @@ namespace llarp
struct Handler : public ::abyss::httpd::IRPCHandler
{
llarp_router* router;
Handler(::abyss::httpd::ConnImpl* conn, llarp_router* r)
llarp::Router* router;
Handler(::abyss::httpd::ConnImpl* conn, llarp::Router* r)
: ::abyss::httpd::IRPCHandler(conn), router(r)
{
}
@ -259,11 +258,11 @@ namespace llarp
struct ReqHandlerImpl : public ::abyss::httpd::BaseReqHandler
{
ReqHandlerImpl(llarp_router* r, llarp_time_t reqtimeout)
ReqHandlerImpl(llarp::Router* r, llarp_time_t reqtimeout)
: ::abyss::httpd::BaseReqHandler(reqtimeout), router(r)
{
}
llarp_router* router;
llarp::Router* router;
::abyss::httpd::IRPCHandler*
CreateHandler(::abyss::httpd::ConnImpl* conn)
{
@ -273,10 +272,10 @@ namespace llarp
struct ServerImpl
{
llarp_router* router;
llarp::Router* router;
ReqHandlerImpl _handler;
ServerImpl(llarp_router* r) : router(r), _handler(r, 2000)
ServerImpl(llarp::Router* r) : router(r), _handler(r, 2000)
{
}
@ -306,7 +305,7 @@ namespace llarp
#else
struct ServerImpl
{
ServerImpl(__attribute__((unused)) llarp_router* r){};
ServerImpl(__attribute__((unused)) llarp::Router* r){};
bool
Start(__attribute__((unused)) const std::string& addr)
@ -317,7 +316,7 @@ namespace llarp
struct CallerImpl
{
CallerImpl(__attribute__((unused)) llarp_router* r)
CallerImpl(__attribute__((unused)) llarp::Router* r)
{
}
@ -340,7 +339,7 @@ namespace llarp
#endif
Caller::Caller(llarp_router* r) : m_Impl(new CallerImpl(r))
Caller::Caller(llarp::Router* r) : m_Impl(new CallerImpl(r))
{
}
@ -361,7 +360,7 @@ namespace llarp
m_Impl->Tick(now);
}
Server::Server(llarp_router* r) : m_Impl(new ServerImpl(r))
Server::Server(llarp::Router* r) : m_Impl(new ServerImpl(r))
{
}

1
llarp/service.cpp
Unescape Escape View File

@ -2,7 +2,6 @@
#include "buffer.hpp"
#include "fs.hpp"
#include "ini.hpp"
#include "router.hpp"
namespace llarp
{

9
llarp/service/context.cpp
Unescape Escape View File

@ -2,13 +2,12 @@
#include <llarp/handlers/null.hpp>
#include <llarp/service/context.hpp>
#include <llarp/service/endpoint.hpp>
#include "router.hpp"
namespace llarp
{
namespace service
{
Context::Context(llarp_router *r) : m_Router(r)
Context::Context(llarp::Router *r) : m_Router(r)
{
}
@ -229,16 +228,16 @@ namespace llarp
static std::map< std::string,
std::function< llarp::service::Endpoint *(
const std::string &, llarp_router *) > >
const std::string &, llarp::Router *) > >
endpointConstructors = {
{"tun",
[](const std::string &nick,
llarp_router *r) -> llarp::service::Endpoint * {
llarp::Router *r) -> llarp::service::Endpoint * {
return new llarp::handlers::TunEndpoint(nick, r);
}},
{"null",
[](const std::string &nick,
llarp_router *r) -> llarp::service::Endpoint * {
llarp::Router *r) -> llarp::service::Endpoint * {
return new llarp::handlers::NullEndpoint(nick, r);
}}};

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

@ -1,5 +1,6 @@
#include <llarp/dht/messages/findintro.hpp>
#include <llarp/logic.hpp>
#include <llarp/messages/dht.hpp>
#include <llarp/service/endpoint.hpp>
#include <llarp/service/protocol.hpp>
@ -10,7 +11,7 @@ namespace llarp
{
namespace service
{
Endpoint::Endpoint(const std::string& name, llarp_router* r)
Endpoint::Endpoint(const std::string& name, llarp::Router* r)
: path::Builder(r, r->dht, 6, 4), m_Router(r), m_Name(name)
{
m_Tag.Zero();
@ -513,7 +514,7 @@ namespace llarp
}
bool
Endpoint::PublishIntroSet(llarp_router* r)
Endpoint::PublishIntroSet(llarp::Router* r)
{
// publish via near router
RouterID location = m_Identity.pub.Addr().data();
@ -561,7 +562,7 @@ namespace llarp
}
bool
Endpoint::PublishIntroSetVia(llarp_router* r, path::Path* path)
Endpoint::PublishIntroSetVia(llarp::Router* r, path::Path* path)
{
auto job = new PublishIntroSetJob(this, GenTXID(), m_IntroSet);
if(job->SendRequestViaPath(path, r))

2
llarp/service/lookup.cpp
Unescape Escape View File

@ -16,7 +16,7 @@ namespace llarp
}
bool
IServiceLookup::SendRequestViaPath(llarp::path::Path *path, llarp_router *r)
IServiceLookup::SendRequestViaPath(llarp::path::Path *path, llarp::Router *r)
{
auto msg = BuildRequestMessage();
if(!msg)

3
llarp/service/protocol.cpp
Unescape Escape View File

@ -1,3 +1,4 @@
#include <llarp/logic.hpp>
#include <llarp/routing/handler.hpp>
#include <llarp/service/protocol.hpp>
#include "buffer.hpp"
@ -384,7 +385,7 @@ namespace llarp
bool
ProtocolFrame::HandleMessage(llarp::routing::IMessageHandler* h,
__attribute__((unused)) llarp_router* r) const
__attribute__((unused)) llarp::Router* r) const
{
return h->HandleHiddenServiceFrame(this);
}

30
llarp/transit_hop.cpp
Unescape Escape View File

@ -53,7 +53,7 @@ namespace llarp
bool
TransitHop::SendRoutingMessage(const llarp::routing::IMessage* msg,
llarp_router* r)
llarp::Router* r)
{
if(!IsEndpoint(r->pubkey()))
return false;
@ -82,7 +82,7 @@ namespace llarp
bool
TransitHop::HandleDownstream(llarp_buffer_t buf, const TunnelNonce& Y,
llarp_router* r)
llarp::Router* r)
{
RelayDownstreamMessage msg;
msg.pathid = info.rxID;
@ -96,7 +96,7 @@ namespace llarp
bool
TransitHop::HandleUpstream(llarp_buffer_t buf, const TunnelNonce& Y,
llarp_router* r)
llarp::Router* r)
{
r->crypto.xchacha20(buf, pathKey, Y);
if(IsEndpoint(r->pubkey()))
@ -118,14 +118,14 @@ namespace llarp
bool
TransitHop::HandleDHTMessage(const llarp::dht::IMessage* msg,
llarp_router* r)
llarp::Router* r)
{
return r->dht->impl.RelayRequestForPath(info.rxID, msg);
}
bool
TransitHop::HandlePathLatencyMessage(
const llarp::routing::PathLatencyMessage* msg, llarp_router* r)
const llarp::routing::PathLatencyMessage* msg, llarp::Router* r)
{
llarp::routing::PathLatencyMessage reply;
reply.L = msg->T;
@ -135,7 +135,7 @@ namespace llarp
bool
TransitHop::HandlePathConfirmMessage(
__attribute__((unused)) const llarp::routing::PathConfirmMessage* msg,
__attribute__((unused)) llarp_router* r)
__attribute__((unused)) llarp::Router* r)
{
llarp::LogWarn("unwarranted path confirm message on ", info);
return false;
@ -144,7 +144,7 @@ namespace llarp
bool
TransitHop::HandleDataDiscardMessage(
__attribute__((unused)) const llarp::routing::DataDiscardMessage* msg,
__attribute__((unused)) llarp_router* r)
__attribute__((unused)) llarp::Router* r)
{
llarp::LogWarn("unwarranted path data discard message on ", info);
return false;
@ -152,7 +152,7 @@ namespace llarp
bool
TransitHop::HandleObtainExitMessage(
const llarp::routing::ObtainExitMessage* msg, llarp_router* r)
const llarp::routing::ObtainExitMessage* msg, llarp::Router* r)
{
if(msg->Verify(&r->crypto)
&& r->exitContext.ObtainNewExit(msg->I, info.rxID, msg->E != 0))
@ -182,7 +182,7 @@ namespace llarp
bool
TransitHop::HandleCloseExitMessage(
const llarp::routing::CloseExitMessage* msg, llarp_router* r)
const llarp::routing::CloseExitMessage* msg, llarp::Router* r)
{
llarp::routing::DataDiscardMessage discard(info.rxID, msg->S);
auto ep = r->exitContext.FindEndpointForPath(info.rxID);
@ -200,7 +200,7 @@ namespace llarp
bool
TransitHop::HandleUpdateExitVerifyMessage(
const llarp::routing::UpdateExitVerifyMessage* msg, llarp_router* r)
const llarp::routing::UpdateExitVerifyMessage* msg, llarp::Router* r)
{
(void)msg;
(void)r;
@ -210,7 +210,7 @@ namespace llarp
bool
TransitHop::HandleUpdateExitMessage(
const llarp::routing::UpdateExitMessage* msg, llarp_router* r)
const llarp::routing::UpdateExitMessage* msg, llarp::Router* r)
{
auto ep = r->exitContext.FindEndpointForPath(msg->P);
if(ep)
@ -233,7 +233,7 @@ namespace llarp
bool
TransitHop::HandleRejectExitMessage(
const llarp::routing::RejectExitMessage* msg, llarp_router* r)
const llarp::routing::RejectExitMessage* msg, llarp::Router* r)
{
(void)msg;
(void)r;
@ -243,7 +243,7 @@ namespace llarp
bool
TransitHop::HandleGrantExitMessage(
const llarp::routing::GrantExitMessage* msg, llarp_router* r)
const llarp::routing::GrantExitMessage* msg, llarp::Router* r)
{
(void)msg;
(void)r;
@ -253,7 +253,7 @@ namespace llarp
bool
TransitHop::HandleTransferTrafficMessage(
const llarp::routing::TransferTrafficMessage* msg, llarp_router* r)
const llarp::routing::TransferTrafficMessage* msg, llarp::Router* r)
{
auto endpoint = r->exitContext.FindEndpointForPath(info.rxID);
if(endpoint)
@ -279,7 +279,7 @@ namespace llarp
bool
TransitHop::HandlePathTransferMessage(
const llarp::routing::PathTransferMessage* msg, llarp_router* r)
const llarp::routing::PathTransferMessage* msg, llarp::Router* r)
{
auto path = r->paths.GetPathForTransfer(msg->P);
llarp::routing::DataDiscardMessage discarded(msg->P, msg->S);

9
test/exit_unittest.cpp
Unescape Escape View File

@ -1,16 +1,13 @@
#include <gtest/gtest.h>
#include <llarp/exit.hpp>
#include "router.hpp"
#include <router.hpp>
struct ExitTest : public ::testing::Test
{
ExitTest()
ExitTest() : r(nullptr, nullptr, nullptr)
{
llarp_crypto_init(&r.crypto);
r.netloop = nullptr; // only windows uses defined sentinel values in
// uninitialised blocks
}
llarp_router r;
llarp::Router r;
};
TEST_F(ExitTest, AddMultipleIP)

Write Preview
Loading…
Cancel
Save