mirror of https://github.com/oxen-io/lokinet
start fleshing out dht subsystem a bit
This commit is contained in:
parent
fe35b98abc
commit
5649d261ae
|
@ -44,6 +44,7 @@ set(LIB_SRC
|
|||
llarp/context.cpp
|
||||
llarp/crypto_async.cpp
|
||||
llarp/crypto_libsodium.cpp
|
||||
llarp/dht.cpp
|
||||
llarp/ev.cpp
|
||||
llarp/exit_info.cpp
|
||||
llarp/exit_route.c
|
||||
|
@ -56,6 +57,7 @@ set(LIB_SRC
|
|||
llarp/mem.cpp
|
||||
llarp/net.cpp
|
||||
llarp/nodedb.cpp
|
||||
llarp/relay_commit.cpp
|
||||
llarp/router_contact.cpp
|
||||
llarp/router.cpp
|
||||
llarp/router_identity.c
|
||||
|
|
|
@ -410,7 +410,7 @@ transfer one or more dht messages directly without a previously made path.
|
|||
|
||||
{
|
||||
a: "m",
|
||||
d: [many, dht, messages],
|
||||
m: [many, dht, messages],
|
||||
v: 0
|
||||
}
|
||||
|
||||
|
|
|
@ -1,5 +1,6 @@
|
|||
#ifndef LLARP_H_
|
||||
#define LLARP_H_
|
||||
#include <llarp/dht.h>
|
||||
#include <llarp/ev.h>
|
||||
#include <llarp/logic.h>
|
||||
#include <llarp/mem.h>
|
||||
|
@ -22,6 +23,10 @@ llarp_main_init(const char *fname);
|
|||
void
|
||||
llarp_main_signal(struct llarp_main *ptr, int sig);
|
||||
|
||||
/** set custom dht message handler function */
|
||||
void
|
||||
llarp_main_set_dht_handler(struct llarp_main *ptr, llarp_dht_msg_handler h);
|
||||
|
||||
/** run main context */
|
||||
int
|
||||
llarp_main_run(struct llarp_main *ptr);
|
||||
|
|
|
@ -17,13 +17,14 @@ namespace llarp
|
|||
int num_nethreads = 1;
|
||||
std::vector< std::thread > netio_threads;
|
||||
llarp_crypto crypto;
|
||||
llarp_router *router = nullptr;
|
||||
llarp_threadpool *worker = nullptr;
|
||||
llarp_logic *logic = nullptr;
|
||||
llarp_config *config = nullptr;
|
||||
llarp_nodedb *nodedb = nullptr;
|
||||
llarp_ev_loop *mainloop = nullptr;
|
||||
char nodedb_dir[256] = {0};
|
||||
llarp_router *router = nullptr;
|
||||
llarp_threadpool *worker = nullptr;
|
||||
llarp_logic *logic = nullptr;
|
||||
llarp_config *config = nullptr;
|
||||
llarp_nodedb *nodedb = nullptr;
|
||||
llarp_ev_loop *mainloop = nullptr;
|
||||
llarp_dht_msg_handler custom_dht_func = nullptr;
|
||||
char nodedb_dir[256] = {0};
|
||||
|
||||
bool
|
||||
LoadConfig(const std::string &fname);
|
||||
|
|
|
@ -0,0 +1,126 @@
|
|||
#ifndef LLARP_ALIGNED_HPP
|
||||
#define LLARP_ALIGNED_HPP
|
||||
|
||||
#include <llarp/crypto.h>
|
||||
#include <sodium.h>
|
||||
#include <iostream>
|
||||
|
||||
namespace llarp
|
||||
{
|
||||
/// aligned buffer, sz must be multiple of 8 bytes
|
||||
template < size_t sz >
|
||||
struct AlignedBuffer
|
||||
{
|
||||
AlignedBuffer()
|
||||
{
|
||||
}
|
||||
|
||||
AlignedBuffer(const byte_t* data)
|
||||
{
|
||||
memcpy(buf.b, data, sz);
|
||||
}
|
||||
|
||||
AlignedBuffer(const AlignedBuffer& other)
|
||||
{
|
||||
memcpy(buf.b, other.data(), sz);
|
||||
}
|
||||
|
||||
AlignedBuffer&
|
||||
operator=(const AlignedBuffer& other)
|
||||
{
|
||||
memcpy(buf.b, other.data(), sz);
|
||||
return *this;
|
||||
}
|
||||
|
||||
byte_t& operator[](size_t idx)
|
||||
{
|
||||
return buf.b[idx];
|
||||
}
|
||||
|
||||
std::ostream&
|
||||
operator<<(std::ostream& out) const
|
||||
{
|
||||
char buf[(1 + sz) * 2] = {0};
|
||||
size_t idx = 0;
|
||||
char* ptr = buf;
|
||||
char* end = ptr + (sz * 2);
|
||||
while(idx < sz)
|
||||
{
|
||||
auto wrote = snprintf(ptr, end - ptr, "%.2x", buf.b[idx]);
|
||||
if(wrote == -1)
|
||||
break;
|
||||
++idx;
|
||||
ptr += wrote;
|
||||
}
|
||||
return out << std::string(buf);
|
||||
}
|
||||
|
||||
bool
|
||||
operator==(const AlignedBuffer& other) const
|
||||
{
|
||||
return memcmp(data(), other.data(), sz) == 0;
|
||||
}
|
||||
|
||||
bool
|
||||
operator!=(const AlignedBuffer& other) const
|
||||
{
|
||||
return !(*this == other);
|
||||
}
|
||||
|
||||
size_t
|
||||
size() const
|
||||
{
|
||||
return sz;
|
||||
}
|
||||
|
||||
void
|
||||
Zero()
|
||||
{
|
||||
for(size_t idx = 0; sz < idx / 8; ++idx)
|
||||
buf.l[idx] = 0;
|
||||
}
|
||||
|
||||
void
|
||||
Randomize()
|
||||
{
|
||||
randombytes(buf.b, sz);
|
||||
}
|
||||
|
||||
byte_t*
|
||||
data()
|
||||
{
|
||||
return buf.b;
|
||||
}
|
||||
|
||||
const byte_t*
|
||||
data() const
|
||||
{
|
||||
return buf.b;
|
||||
}
|
||||
|
||||
const uint64_t*
|
||||
data_l() const
|
||||
{
|
||||
return buf.l;
|
||||
}
|
||||
|
||||
uint64_t*
|
||||
data_l()
|
||||
{
|
||||
return buf.l;
|
||||
}
|
||||
|
||||
operator const byte_t*() const
|
||||
{
|
||||
return buf.b;
|
||||
}
|
||||
|
||||
private:
|
||||
union {
|
||||
byte_t b[sz];
|
||||
uint64_t l[sz / 8];
|
||||
} buf = {0};
|
||||
};
|
||||
}
|
||||
|
||||
#endif
|
|
@ -1,6 +1,8 @@
|
|||
#ifndef LLARP_DHT_H_
|
||||
#define LLARP_DHT_H_
|
||||
|
||||
#include <llarp/buffer.h>
|
||||
|
||||
/**
|
||||
* dht.h
|
||||
*
|
||||
|
@ -21,6 +23,22 @@ llarp_dht_context_new();
|
|||
void
|
||||
llarp_dht_context_free(struct llarp_dht_context* dht);
|
||||
|
||||
struct llarp_dht_msg;
|
||||
|
||||
/// handler function
|
||||
/// f(outmsg, inmsg)
|
||||
/// returns true if outmsg has been filled otherwise returns false
|
||||
typedef bool (*llarp_dht_msg_handler)(struct llarp_dht_msg*,
|
||||
struct llarp_dht_msg*);
|
||||
|
||||
void
|
||||
llarp_dht_context_set_our_key(struct llarp_dht_context* ctx, const byte_t* key);
|
||||
|
||||
// override dht message handler with custom handler
|
||||
void
|
||||
llarp_dht_set_msg_handler(struct llarp_dht_context* ctx,
|
||||
llarp_dht_msg_handler func);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
|
|
@ -0,0 +1,179 @@
|
|||
#ifndef LLARP_DHT_HPP_
|
||||
#define LLARP_DHT_HPP_
|
||||
#include <llarp/buffer.h>
|
||||
#include <llarp/dht.h>
|
||||
#include <llarp/router.h>
|
||||
#include <llarp/router_contact.h>
|
||||
#include <llarp/aligned.hpp>
|
||||
|
||||
#include <array>
|
||||
#include <map>
|
||||
#include <vector>
|
||||
|
||||
namespace llarp
|
||||
{
|
||||
namespace dht
|
||||
{
|
||||
const size_t MAX_MSG_SIZE = 2048;
|
||||
|
||||
struct SearchJob;
|
||||
|
||||
struct Node
|
||||
{
|
||||
llarp_rc rc;
|
||||
|
||||
const byte_t*
|
||||
ID() const;
|
||||
|
||||
Node();
|
||||
~Node();
|
||||
};
|
||||
|
||||
struct Key_t : public llarp::AlignedBuffer< 32 >
|
||||
{
|
||||
Key_t(const byte_t* val) : llarp::AlignedBuffer< 32 >(val)
|
||||
{
|
||||
}
|
||||
|
||||
Key_t() : llarp::AlignedBuffer< 32 >()
|
||||
{
|
||||
}
|
||||
|
||||
Key_t
|
||||
operator^(const Key_t& other) const
|
||||
{
|
||||
Key_t dist;
|
||||
for(size_t idx = 0; idx < 8; ++idx)
|
||||
dist.data_l()[idx] = data_l()[idx] ^ other.data_l()[idx];
|
||||
return dist;
|
||||
}
|
||||
|
||||
bool
|
||||
operator<(const Key_t& other) const
|
||||
{
|
||||
return memcmp(data_l(), other.data_l(), 32) < 0;
|
||||
}
|
||||
};
|
||||
|
||||
struct XorMetric
|
||||
{
|
||||
const Key_t& us;
|
||||
|
||||
XorMetric(const Key_t& ourKey) : us(ourKey){};
|
||||
|
||||
bool
|
||||
operator()(const Key_t& left, const Key_t& right) const
|
||||
{
|
||||
return (us ^ left) < right;
|
||||
};
|
||||
};
|
||||
|
||||
struct IMessage
|
||||
{
|
||||
virtual ~IMessage(){};
|
||||
|
||||
IMessage(const Key_t& from) : From(from)
|
||||
{
|
||||
}
|
||||
|
||||
virtual bool
|
||||
BEncode(llarp_buffer_t* buf) const = 0;
|
||||
|
||||
virtual bool
|
||||
DecodeKey(llarp_buffer_t key, llarp_buffer_t* val) = 0;
|
||||
|
||||
virtual bool
|
||||
HandleMessage(llarp_router* router,
|
||||
std::vector< IMessage* >& replies) const = 0;
|
||||
|
||||
Key_t From;
|
||||
};
|
||||
|
||||
IMessage*
|
||||
DecodeMessage(const Key_t& from, llarp_buffer_t* buf);
|
||||
|
||||
bool
|
||||
DecodeMesssageList(const Key_t& from, llarp_buffer_t* buf,
|
||||
std::vector< IMessage* >& dst);
|
||||
|
||||
struct Bucket
|
||||
{
|
||||
typedef std::map< Key_t, Node, XorMetric > BucketStorage_t;
|
||||
|
||||
Bucket(const Key_t& us) : nodes(XorMetric(us)){};
|
||||
|
||||
bool
|
||||
FindClosest(const Key_t& target, Key_t& result) const;
|
||||
|
||||
BucketStorage_t nodes;
|
||||
};
|
||||
|
||||
struct Context
|
||||
{
|
||||
Context();
|
||||
~Context();
|
||||
|
||||
llarp_dht_msg_handler custom_handler = nullptr;
|
||||
|
||||
void
|
||||
Init(const Key_t& us);
|
||||
|
||||
private:
|
||||
Bucket* nodes = nullptr;
|
||||
Key_t ourKey;
|
||||
};
|
||||
|
||||
struct GotRouterMessage : public IMessage
|
||||
{
|
||||
GotRouterMessage(const Key_t& from) : IMessage(from)
|
||||
{
|
||||
}
|
||||
|
||||
~GotRouterMessage();
|
||||
|
||||
bool
|
||||
BEncode(llarp_buffer_t* buf) const;
|
||||
|
||||
bool
|
||||
DecodeKey(llarp_buffer_t key, llarp_buffer_t* val);
|
||||
|
||||
bool
|
||||
HandleMessage(llarp_router* router,
|
||||
std::vector< IMessage* >& replies) const;
|
||||
|
||||
std::vector< llarp_rc > R;
|
||||
uint64_t txid = 0;
|
||||
uint64_t version = 0;
|
||||
};
|
||||
|
||||
struct FindRouterMessage : public IMessage
|
||||
{
|
||||
FindRouterMessage(const Key_t& from) : IMessage(from)
|
||||
{
|
||||
}
|
||||
|
||||
~FindRouterMessage();
|
||||
|
||||
bool
|
||||
BEncode(llarp_buffer_t* buf) const;
|
||||
|
||||
bool
|
||||
DecodeKey(llarp_buffer_t key, llarp_buffer_t* val);
|
||||
|
||||
bool
|
||||
HandleMessage(llarp_router* router,
|
||||
std::vector< IMessage* >& replies) const;
|
||||
|
||||
Key_t K;
|
||||
uint64_t txid = 0;
|
||||
uint64_t version = 0;
|
||||
};
|
||||
}
|
||||
}
|
||||
|
||||
struct llarp_dht_context
|
||||
{
|
||||
llarp::dht::Context impl;
|
||||
};
|
||||
|
||||
#endif
|
|
@ -14,6 +14,9 @@
|
|||
extern "C" {
|
||||
#endif
|
||||
|
||||
/** 2^15 bytes */
|
||||
const size_t MAX_LINK_MSG_SIZE = 32768;
|
||||
|
||||
/**
|
||||
* wire layer transport interface
|
||||
*/
|
||||
|
@ -79,7 +82,12 @@ struct llarp_link
|
|||
bool (*stop_link)(struct llarp_link *);
|
||||
void (*iter_sessions)(struct llarp_link *, struct llarp_link_session_iter);
|
||||
bool (*try_establish)(struct llarp_link *, struct llarp_link_establish_job *);
|
||||
|
||||
/// send to already established session given its public identity key
|
||||
/// returns false if we don't have this session
|
||||
/// returns true if the messages were queued
|
||||
bool (*sendto)(struct llarp_link *, const byte_t *, llarp_buffer_t);
|
||||
/// return true if we have a session to router given public identity key
|
||||
bool (*has_session_to)(struct llarp_link *, const byte_t *);
|
||||
void (*mark_session_active)(struct llarp_link *, struct llarp_link_session *);
|
||||
void (*free_impl)(struct llarp_link *);
|
||||
};
|
||||
|
|
|
@ -3,18 +3,45 @@
|
|||
|
||||
#include <llarp/bencode.h>
|
||||
#include <llarp/link.h>
|
||||
#include <llarp/relay_commit.hpp>
|
||||
#include <llarp/aligned.hpp>
|
||||
|
||||
#include <queue>
|
||||
#include <vector>
|
||||
|
||||
namespace llarp
|
||||
{
|
||||
typedef std::vector< byte_t > Message;
|
||||
typedef AlignedBuffer< 32 > RouterID;
|
||||
|
||||
struct InboundMessageHandler
|
||||
struct ILinkMessage;
|
||||
|
||||
typedef std::queue< ILinkMessage* > SendQueue;
|
||||
|
||||
/// parsed link layer message
|
||||
struct ILinkMessage
|
||||
{
|
||||
InboundMessageHandler(llarp_router* router);
|
||||
/// who did this message come from (rc.k)
|
||||
RouterID remote;
|
||||
uint64_t version = 0;
|
||||
|
||||
ILinkMessage(const RouterID& from) : remote(from)
|
||||
{
|
||||
}
|
||||
|
||||
virtual ~ILinkMessage(){};
|
||||
|
||||
virtual bool
|
||||
DecodeKey(llarp_buffer_t key, llarp_buffer_t* buf) = 0;
|
||||
|
||||
virtual bool
|
||||
BEncode(llarp_buffer_t* buf) const = 0;
|
||||
|
||||
virtual bool
|
||||
HandleMessage(llarp_router* router) const = 0;
|
||||
};
|
||||
|
||||
struct InboundMessageParser
|
||||
{
|
||||
InboundMessageParser(llarp_router* router);
|
||||
dict_reader reader;
|
||||
|
||||
static bool
|
||||
|
@ -29,28 +56,16 @@ namespace llarp
|
|||
bool
|
||||
MessageDone();
|
||||
|
||||
/// called to send any replies
|
||||
bool
|
||||
FlushReplies();
|
||||
private:
|
||||
RouterID
|
||||
GetCurrentFrom();
|
||||
|
||||
private:
|
||||
bool
|
||||
DecodeLIM(llarp_buffer_t key, llarp_buffer_t* buff);
|
||||
|
||||
bool
|
||||
DecodeDHT(llarp_buffer_t key, llarp_buffer_t* buff);
|
||||
|
||||
bool
|
||||
DecodeLRCM(llarp_buffer_t key, llarp_buffer_t* buff);
|
||||
|
||||
private:
|
||||
char msgtype;
|
||||
bool firstkey;
|
||||
uint64_t proto;
|
||||
llarp_router* router;
|
||||
llarp_link_session* from;
|
||||
llarp::LR_CommitMessage lrcm;
|
||||
std::queue< Message > sendq;
|
||||
ILinkMessage* msg = nullptr;
|
||||
};
|
||||
}
|
||||
|
||||
|
|
|
@ -0,0 +1,30 @@
|
|||
#ifndef LLARP_MESSAGES_DHT_IMMEDIATE_HPP
|
||||
#define LLARP_MESSAGES_DHT_IMMEDIATE_HPP
|
||||
#include <llarp/dht.hpp>
|
||||
#include <llarp/link_message.hpp>
|
||||
#include <vector>
|
||||
|
||||
namespace llarp
|
||||
{
|
||||
struct DHTImmeidateMessage : public ILinkMessage
|
||||
{
|
||||
DHTImmeidateMessage(const RouterID& from) : ILinkMessage(from)
|
||||
{
|
||||
}
|
||||
|
||||
~DHTImmeidateMessage();
|
||||
|
||||
std::vector< llarp::dht::IMessage* > msgs;
|
||||
|
||||
bool
|
||||
DecodeKey(llarp_buffer_t key, llarp_buffer_t* buf);
|
||||
|
||||
bool
|
||||
BEncode(llarp_buffer_t* buf) const;
|
||||
|
||||
bool
|
||||
HandleMessage(llarp_router* router) const;
|
||||
};
|
||||
}
|
||||
|
||||
#endif
|
|
@ -0,0 +1,27 @@
|
|||
#ifndef LLARP_MESSAGES_LINK_INTRO_HPP
|
||||
#define LLARP_MESSAGES_LINK_INTRO_HPP
|
||||
#include <llarp/link_message.hpp>
|
||||
namespace llarp
|
||||
{
|
||||
struct LinkIntroMessage : public ILinkMessage
|
||||
{
|
||||
LinkIntroMessage(llarp_rc* rc) : ILinkMessage({}), RC(rc)
|
||||
{
|
||||
}
|
||||
|
||||
~LinkIntroMessage();
|
||||
|
||||
llarp_rc* RC;
|
||||
|
||||
bool
|
||||
DecodeKey(llarp_buffer_t key, llarp_buffer_t* buf);
|
||||
|
||||
bool
|
||||
BEncode(llarp_buffer_t* buf) const;
|
||||
|
||||
bool
|
||||
HandleMessage(llarp_router* router) const;
|
||||
};
|
||||
}
|
||||
|
||||
#endif
|
|
@ -2,6 +2,7 @@
|
|||
#define LLARP_RELAY_COMMIT_HPP
|
||||
#include <llarp/crypto.h>
|
||||
#include <llarp/encrypted_frame.hpp>
|
||||
#include <llarp/link_message.hpp>
|
||||
#include <vector>
|
||||
|
||||
namespace llarp
|
||||
|
@ -47,19 +48,27 @@ namespace llarp
|
|||
BEncode(llarp_buffer_t *buf);
|
||||
};
|
||||
|
||||
struct LR_CommitMessage
|
||||
struct LR_CommitMessage : public ILinkMessage
|
||||
{
|
||||
std::vector< EncryptedFrame > frames;
|
||||
uint64_t version;
|
||||
|
||||
LR_CommitMessage(const RouterID &from) : ILinkMessage(from)
|
||||
{
|
||||
}
|
||||
~LR_CommitMessage();
|
||||
|
||||
void
|
||||
Clear();
|
||||
|
||||
bool
|
||||
BDecode(llarp_buffer_t *buf);
|
||||
DecodeKey(llarp_buffer_t key, llarp_buffer_t *buf);
|
||||
|
||||
bool
|
||||
BEncode(llarp_buffer_t *buf);
|
||||
BEncode(llarp_buffer_t *buf) const;
|
||||
|
||||
bool
|
||||
HandleMessage(llarp_router *router) const;
|
||||
};
|
||||
|
||||
struct AsyncPathDecryption
|
|
@ -24,7 +24,7 @@ void
|
|||
llarp_free_router(struct llarp_router **router);
|
||||
|
||||
bool
|
||||
llarp_router_try_connect(struct llarp_router *router, struct llarp_rc *remtoe);
|
||||
llarp_router_try_connect(struct llarp_router *router, struct llarp_rc *remote);
|
||||
|
||||
bool
|
||||
llarp_configure_router(struct llarp_router *router, struct llarp_config *conf);
|
||||
|
|
|
@ -2,6 +2,7 @@
|
|||
#include <signal.h>
|
||||
#include <llarp.hpp>
|
||||
#include "logger.hpp"
|
||||
#include "router.hpp"
|
||||
|
||||
#if(__FreeBSD__)
|
||||
#include <pthread_np.h>
|
||||
|
@ -95,6 +96,11 @@ namespace llarp
|
|||
|
||||
if(llarp_configure_router(router, config))
|
||||
{
|
||||
if(custom_dht_func)
|
||||
{
|
||||
llarp::Info(__FILE__, "using custom dht function");
|
||||
llarp_dht_set_msg_handler(router->dht, custom_dht_func);
|
||||
}
|
||||
llarp_run_router(router, nodedb);
|
||||
// run net io thread
|
||||
auto netio = mainloop;
|
||||
|
@ -234,6 +240,12 @@ llarp_main_init(const char *fname)
|
|||
return m;
|
||||
}
|
||||
|
||||
void
|
||||
llarp_main_set_dht_handler(struct llarp_main *ptr, llarp_dht_msg_handler func)
|
||||
{
|
||||
ptr->ctx->custom_dht_func = func;
|
||||
}
|
||||
|
||||
void
|
||||
llarp_main_signal(struct llarp_main *ptr, int sig)
|
||||
{
|
||||
|
|
|
@ -2,11 +2,11 @@
|
|||
#define LLARP_CRYPTO_HPP
|
||||
|
||||
#include <llarp/crypto.h>
|
||||
#include <array>
|
||||
#include <llarp/aligned.hpp>
|
||||
|
||||
namespace llarp
|
||||
{
|
||||
typedef std::array< uint8_t, sizeof(llarp_pubkey_t) > pubkey;
|
||||
typedef AlignedBuffer< PUBKEYSIZE > pubkey;
|
||||
|
||||
struct pubkeyhash
|
||||
{
|
||||
|
|
|
@ -0,0 +1,303 @@
|
|||
#include <llarp/bencode.h>
|
||||
#include <llarp/dht.hpp>
|
||||
#include <llarp/messages/dht_immediate.hpp>
|
||||
#include "router.hpp"
|
||||
|
||||
namespace llarp
|
||||
{
|
||||
DHTImmeidateMessage::~DHTImmeidateMessage()
|
||||
{
|
||||
for(auto &msg : msgs)
|
||||
delete msg;
|
||||
msgs.clear();
|
||||
}
|
||||
|
||||
bool
|
||||
DHTImmeidateMessage::DecodeKey(llarp_buffer_t key, llarp_buffer_t *buf)
|
||||
{
|
||||
if(llarp_buffer_eq(key, "m"))
|
||||
return llarp::dht::DecodeMesssageList(remote.data(), buf, msgs);
|
||||
if(llarp_buffer_eq(key, "v"))
|
||||
{
|
||||
if(!bdecode_read_integer(buf, &version))
|
||||
return false;
|
||||
return version == LLARP_PROTO_VERSION;
|
||||
}
|
||||
// bad key
|
||||
return false;
|
||||
}
|
||||
|
||||
bool
|
||||
DHTImmeidateMessage::BEncode(llarp_buffer_t *buf) const
|
||||
{
|
||||
if(!bencode_start_dict(buf))
|
||||
return false;
|
||||
|
||||
if(!bencode_write_bytestring(buf, "a", 1))
|
||||
return false;
|
||||
if(!bencode_write_bytestring(buf, "m", 1))
|
||||
return false;
|
||||
|
||||
// dht messages
|
||||
if(!bencode_write_bytestring(buf, "m", 1))
|
||||
return false;
|
||||
// begin list
|
||||
if(!bencode_start_list(buf))
|
||||
return false;
|
||||
for(const auto &msg : msgs)
|
||||
{
|
||||
if(!msg->BEncode(buf))
|
||||
return false;
|
||||
}
|
||||
// end list
|
||||
if(!bencode_end(buf))
|
||||
return false;
|
||||
|
||||
if(!bencode_write_version_entry(buf))
|
||||
return false;
|
||||
|
||||
return bencode_end(buf);
|
||||
}
|
||||
|
||||
bool
|
||||
DHTImmeidateMessage::HandleMessage(llarp_router *router) const
|
||||
{
|
||||
DHTImmeidateMessage *reply = new DHTImmeidateMessage(remote);
|
||||
bool result = true;
|
||||
for(auto &msg : msgs)
|
||||
{
|
||||
result &= msg->HandleMessage(router, reply->msgs);
|
||||
}
|
||||
return result && router->SendToOrQueue(remote.data(), {reply});
|
||||
}
|
||||
|
||||
namespace dht
|
||||
{
|
||||
GotRouterMessage::~GotRouterMessage()
|
||||
{
|
||||
for(auto &rc : R)
|
||||
llarp_rc_free(&rc);
|
||||
R.clear();
|
||||
}
|
||||
|
||||
bool
|
||||
GotRouterMessage::BEncode(llarp_buffer_t *buf) const
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
bool
|
||||
GotRouterMessage::DecodeKey(llarp_buffer_t key, llarp_buffer_t *val)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
bool
|
||||
GotRouterMessage::HandleMessage(llarp_router *router,
|
||||
std::vector< IMessage * > &replies) const
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
FindRouterMessage::~FindRouterMessage()
|
||||
{
|
||||
}
|
||||
|
||||
bool
|
||||
FindRouterMessage::BEncode(llarp_buffer_t *buf) const
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
bool
|
||||
FindRouterMessage::DecodeKey(llarp_buffer_t key, llarp_buffer_t *val)
|
||||
{
|
||||
llarp_buffer_t strbuf;
|
||||
if(llarp_buffer_eq(key, "K"))
|
||||
{
|
||||
if(!bdecode_read_string(val, &strbuf))
|
||||
return false;
|
||||
if(strbuf.sz != K.size())
|
||||
return false;
|
||||
|
||||
memcpy(K.data(), strbuf.base, K.size());
|
||||
return true;
|
||||
}
|
||||
if(llarp_buffer_eq(key, "T"))
|
||||
{
|
||||
return bdecode_read_integer(val, &txid);
|
||||
}
|
||||
if(llarp_buffer_eq(key, "V"))
|
||||
{
|
||||
if(!bdecode_read_integer(val, &version))
|
||||
return false;
|
||||
return version == LLARP_PROTO_VERSION;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
bool
|
||||
FindRouterMessage::HandleMessage(llarp_router *router,
|
||||
std::vector< IMessage * > &replies) const
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
struct MessageDecoder
|
||||
{
|
||||
Key_t From;
|
||||
bool firstKey = true;
|
||||
IMessage *msg = nullptr;
|
||||
|
||||
MessageDecoder(const Key_t &from) : From(from)
|
||||
{
|
||||
}
|
||||
|
||||
static bool
|
||||
on_key(dict_reader *r, llarp_buffer_t *key)
|
||||
{
|
||||
llarp_buffer_t strbuf;
|
||||
MessageDecoder *dec = static_cast< MessageDecoder * >(r->user);
|
||||
// check for empty dict
|
||||
if(!key)
|
||||
return !dec->firstKey;
|
||||
|
||||
// first key
|
||||
if(dec->firstKey)
|
||||
{
|
||||
if(!llarp_buffer_eq(*key, "A"))
|
||||
return false;
|
||||
if(!bdecode_read_string(r->buffer, &strbuf))
|
||||
return false;
|
||||
// bad msg size?
|
||||
if(strbuf.sz != 1)
|
||||
return false;
|
||||
switch(*strbuf.base)
|
||||
{
|
||||
case 'R':
|
||||
dec->msg = new FindRouterMessage(dec->From);
|
||||
break;
|
||||
case 'S':
|
||||
dec->msg = new GotRouterMessage(dec->From);
|
||||
break;
|
||||
default:
|
||||
// bad msg type
|
||||
return false;
|
||||
}
|
||||
dec->firstKey = false;
|
||||
return true;
|
||||
}
|
||||
else
|
||||
return dec->msg->DecodeKey(*key, r->buffer);
|
||||
}
|
||||
};
|
||||
|
||||
IMessage *
|
||||
DecodeMesssage(const Key_t &from, llarp_buffer_t *buf)
|
||||
{
|
||||
MessageDecoder dec(from);
|
||||
dict_reader r;
|
||||
r.user = &dec;
|
||||
r.on_key = &MessageDecoder::on_key;
|
||||
if(bdecode_read_dict(buf, &r))
|
||||
return dec.msg;
|
||||
else
|
||||
{
|
||||
if(dec.msg)
|
||||
delete dec.msg;
|
||||
return nullptr;
|
||||
}
|
||||
}
|
||||
|
||||
struct ListDecoder
|
||||
{
|
||||
ListDecoder(const Key_t &from, std::vector< IMessage * > &list)
|
||||
: From(from), l(list){};
|
||||
Key_t From;
|
||||
std::vector< IMessage * > &l;
|
||||
|
||||
static bool
|
||||
on_item(list_reader *r, bool has)
|
||||
{
|
||||
ListDecoder *dec = static_cast< ListDecoder * >(r->user);
|
||||
if(!has)
|
||||
return true;
|
||||
auto msg = DecodeMesssage(dec->From, r->buffer);
|
||||
if(msg)
|
||||
{
|
||||
dec->l.push_back(msg);
|
||||
return true;
|
||||
}
|
||||
else
|
||||
return false;
|
||||
}
|
||||
};
|
||||
|
||||
bool
|
||||
DecodeMesssageList(const Key_t &from, llarp_buffer_t *buf,
|
||||
std::vector< IMessage * > &list)
|
||||
{
|
||||
ListDecoder dec(from, list);
|
||||
|
||||
list_reader r;
|
||||
r.user = &dec;
|
||||
r.on_item = &ListDecoder::on_item;
|
||||
return bdecode_read_list(buf, &r);
|
||||
}
|
||||
|
||||
Node::Node()
|
||||
{
|
||||
llarp_rc_clear(&rc);
|
||||
}
|
||||
|
||||
Node::~Node()
|
||||
{
|
||||
llarp_rc_free(&rc);
|
||||
}
|
||||
|
||||
Context::Context()
|
||||
{
|
||||
}
|
||||
|
||||
Context::~Context()
|
||||
{
|
||||
if(nodes)
|
||||
delete nodes;
|
||||
}
|
||||
|
||||
void
|
||||
Context::Init(const Key_t &us)
|
||||
{
|
||||
ourKey = us;
|
||||
nodes = new Bucket(ourKey);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
extern "C" {
|
||||
|
||||
struct llarp_dht_context *
|
||||
llarp_dht_context_new()
|
||||
{
|
||||
return new llarp_dht_context;
|
||||
}
|
||||
|
||||
void
|
||||
llarp_dht_context_free(struct llarp_dht_context *ctx)
|
||||
{
|
||||
delete ctx;
|
||||
}
|
||||
|
||||
void
|
||||
llarp_dht_set_msg_handler(struct llarp_dht_context *ctx,
|
||||
llarp_dht_msg_handler handler)
|
||||
{
|
||||
ctx->impl.custom_handler = handler;
|
||||
}
|
||||
|
||||
void
|
||||
llarp_dht_context_set_our_key(struct llarp_dht_context *ctx, const byte_t *key)
|
||||
{
|
||||
ctx->impl.Init(key);
|
||||
}
|
||||
}
|
|
@ -0,0 +1,75 @@
|
|||
#include <llarp/bencode.h>
|
||||
#include <llarp/router_contact.h>
|
||||
#include <llarp/messages/link_intro.hpp>
|
||||
#include "logger.hpp"
|
||||
|
||||
namespace llarp
|
||||
{
|
||||
LinkIntroMessage::~LinkIntroMessage()
|
||||
{
|
||||
}
|
||||
|
||||
bool
|
||||
LinkIntroMessage::DecodeKey(llarp_buffer_t key, llarp_buffer_t* buf)
|
||||
{
|
||||
if(llarp_buffer_eq(key, "r"))
|
||||
{
|
||||
if(!llarp_rc_bdecode(RC, buf))
|
||||
{
|
||||
llarp::Warn(__FILE__, "failed to decode RC");
|
||||
return false;
|
||||
}
|
||||
remote = RC->pubkey;
|
||||
return true;
|
||||
}
|
||||
else if(llarp_buffer_eq(key, "v"))
|
||||
{
|
||||
if(!bdecode_read_integer(buf, &version))
|
||||
return false;
|
||||
if(version != LLARP_PROTO_VERSION)
|
||||
{
|
||||
llarp::Warn(__FILE__, "llarp protocol version missmatch ", version,
|
||||
" != ", LLARP_PROTO_VERSION);
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
else
|
||||
{
|
||||
llarp::Warn(__FILE__, "invalid LIM key: ", *key.cur);
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
bool
|
||||
LinkIntroMessage::BEncode(llarp_buffer_t* buf) const
|
||||
{
|
||||
if(!bencode_start_dict(buf))
|
||||
return false;
|
||||
|
||||
if(!bencode_write_bytestring(buf, "a", 1))
|
||||
return false;
|
||||
if(!bencode_write_bytestring(buf, "i", 1))
|
||||
return false;
|
||||
|
||||
if(RC)
|
||||
{
|
||||
if(!bencode_write_bytestring(buf, "r", 1))
|
||||
return false;
|
||||
if(!llarp_rc_bencode(RC, buf))
|
||||
return false;
|
||||
}
|
||||
|
||||
if(!bencode_write_version_entry(buf))
|
||||
return false;
|
||||
|
||||
return bencode_end(buf);
|
||||
}
|
||||
|
||||
bool
|
||||
LinkIntroMessage::HandleMessage(llarp_router* router) const
|
||||
{
|
||||
llarp::Info(__FILE__, "got LIM from ", remote);
|
||||
return true;
|
||||
}
|
||||
}
|
|
@ -1,12 +1,15 @@
|
|||
#include <llarp/router_contact.h>
|
||||
#include <llarp/link_message.hpp>
|
||||
#include <llarp/messages/dht_immediate.hpp>
|
||||
#include <llarp/messages/link_intro.hpp>
|
||||
#include <llarp/messages/relay_commit.hpp>
|
||||
#include "buffer.hpp"
|
||||
#include "logger.hpp"
|
||||
#include "router.hpp"
|
||||
|
||||
namespace llarp
|
||||
{
|
||||
InboundMessageHandler::InboundMessageHandler(llarp_router* _router)
|
||||
InboundMessageParser::InboundMessageParser(llarp_router* _router)
|
||||
: router(_router)
|
||||
{
|
||||
reader.user = this;
|
||||
|
@ -14,10 +17,10 @@ namespace llarp
|
|||
}
|
||||
|
||||
bool
|
||||
InboundMessageHandler::OnKey(dict_reader* r, llarp_buffer_t* key)
|
||||
InboundMessageParser::OnKey(dict_reader* r, llarp_buffer_t* key)
|
||||
{
|
||||
InboundMessageHandler* handler =
|
||||
static_cast< InboundMessageHandler* >(r->user);
|
||||
InboundMessageParser* handler =
|
||||
static_cast< InboundMessageParser* >(r->user);
|
||||
llarp_buffer_t strbuf;
|
||||
|
||||
// we are reading the first key
|
||||
|
@ -44,31 +47,29 @@ namespace llarp
|
|||
llarp::Warn(__FILE__, "bad mesage type size: ", strbuf.sz);
|
||||
return false;
|
||||
}
|
||||
handler->msgtype = *strbuf.cur;
|
||||
switch(*strbuf.cur)
|
||||
{
|
||||
case 'i':
|
||||
handler->msg = new LinkIntroMessage(
|
||||
handler->from->get_remote_router(handler->from));
|
||||
break;
|
||||
case 'm':
|
||||
handler->msg = new DHTImmeidateMessage(handler->GetCurrentFrom());
|
||||
break;
|
||||
case 'c':
|
||||
handler->msg = new LR_CommitMessage(handler->GetCurrentFrom());
|
||||
}
|
||||
handler->firstkey = false;
|
||||
return true;
|
||||
return handler->msg != nullptr;
|
||||
}
|
||||
// check for last element
|
||||
if(!key)
|
||||
return handler->MessageDone();
|
||||
|
||||
switch(handler->msgtype)
|
||||
{
|
||||
// link introduce
|
||||
case 'i':
|
||||
return handler->DecodeLIM(*key, r->buffer);
|
||||
// immidate dht
|
||||
case 'd':
|
||||
return handler->DecodeDHT(*key, r->buffer);
|
||||
// relay commit
|
||||
case 'c':
|
||||
return handler->DecodeLRCM(*key, r->buffer);
|
||||
// unknown message type
|
||||
default:
|
||||
return false;
|
||||
}
|
||||
return handler->msg->DecodeKey(*key, r->buffer);
|
||||
}
|
||||
|
||||
/*
|
||||
bool
|
||||
InboundMessageHandler::DecodeLIM(llarp_buffer_t key, llarp_buffer_t* buff)
|
||||
{
|
||||
|
@ -102,6 +103,15 @@ namespace llarp
|
|||
bool
|
||||
InboundMessageHandler::DecodeDHT(llarp_buffer_t key, llarp_buffer_t* buf)
|
||||
{
|
||||
if(llarp_buffer_eq(key, "d"))
|
||||
return llarp::dht::DecodeMesssageList(buf, dhtmsgs);
|
||||
if(llarp_buffer_eq(key, "v"))
|
||||
{
|
||||
if(!bdecode_read_integer(buf, &proto))
|
||||
return false;
|
||||
return proto == LLARP_PROTO_VERSION;
|
||||
}
|
||||
// bad key
|
||||
return false;
|
||||
}
|
||||
|
||||
|
@ -111,39 +121,33 @@ namespace llarp
|
|||
return false;
|
||||
}
|
||||
|
||||
bool
|
||||
InboundMessageHandler::MessageDone()
|
||||
*/
|
||||
|
||||
RouterID
|
||||
InboundMessageParser::GetCurrentFrom()
|
||||
{
|
||||
switch(msgtype)
|
||||
{
|
||||
case 'c':
|
||||
return router->ProcessLRCM(lrcm);
|
||||
default:
|
||||
return true;
|
||||
}
|
||||
auto rc = from->get_remote_router(from);
|
||||
return rc->pubkey;
|
||||
}
|
||||
|
||||
bool
|
||||
InboundMessageHandler::ProcessFrom(llarp_link_session* src,
|
||||
llarp_buffer_t buf)
|
||||
InboundMessageParser::MessageDone()
|
||||
{
|
||||
bool result = false;
|
||||
if(msg)
|
||||
{
|
||||
result = msg->HandleMessage(router);
|
||||
delete msg;
|
||||
msg = nullptr;
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
bool
|
||||
InboundMessageParser::ProcessFrom(llarp_link_session* src, llarp_buffer_t buf)
|
||||
{
|
||||
from = src;
|
||||
msgtype = 0;
|
||||
firstkey = true;
|
||||
return bdecode_read_dict(&buf, &reader);
|
||||
}
|
||||
|
||||
bool
|
||||
InboundMessageHandler::FlushReplies()
|
||||
{
|
||||
bool success = true;
|
||||
while(sendq.size())
|
||||
{
|
||||
auto& msg = sendq.front();
|
||||
auto buf = llarp::Buffer< decltype(msg) >(msg);
|
||||
success &= from->sendto(from, buf);
|
||||
sendq.pop();
|
||||
}
|
||||
return success;
|
||||
}
|
||||
}
|
||||
|
|
|
@ -166,4 +166,11 @@ llarp_nodedb_async_verify(struct llarp_nodedb *nodedb,
|
|||
struct llarp_async_verify_rc *job)
|
||||
{
|
||||
}
|
||||
|
||||
bool
|
||||
llarp_nodedb_find_rc(struct llarp_nodedb *nodedb, struct llarp_rc *dst,
|
||||
llarp_pubkey_t k)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
|
|
@ -0,0 +1,29 @@
|
|||
#include <llarp/messages/relay_commit.hpp>
|
||||
|
||||
namespace llarp
|
||||
{
|
||||
LR_CommitMessage::~LR_CommitMessage()
|
||||
{
|
||||
}
|
||||
|
||||
bool
|
||||
LR_CommitMessage::DecodeKey(llarp_buffer_t key, llarp_buffer_t* buf)
|
||||
{
|
||||
// TODO: implement
|
||||
return false;
|
||||
}
|
||||
|
||||
bool
|
||||
LR_CommitMessage::BEncode(llarp_buffer_t* buf) const
|
||||
{
|
||||
// TODO: implement
|
||||
return false;
|
||||
}
|
||||
|
||||
bool
|
||||
LR_CommitMessage::HandleMessage(llarp_router* router) const
|
||||
{
|
||||
// TODO: implement
|
||||
return false;
|
||||
}
|
||||
}
|
119
llarp/router.cpp
119
llarp/router.cpp
|
@ -27,13 +27,15 @@ namespace llarp
|
|||
|
||||
} // namespace llarp
|
||||
|
||||
llarp_router::llarp_router() : ready(false), inbound_msg_handler(this)
|
||||
llarp_router::llarp_router()
|
||||
: ready(false), dht(llarp_dht_context_new()), inbound_msg_parser(this)
|
||||
{
|
||||
llarp_rc_clear(&rc);
|
||||
}
|
||||
|
||||
llarp_router::~llarp_router()
|
||||
{
|
||||
llarp_dht_context_free(dht);
|
||||
llarp_rc_free(&rc);
|
||||
}
|
||||
|
||||
|
@ -41,18 +43,54 @@ bool
|
|||
llarp_router::HandleRecvLinkMessage(llarp_link_session *session,
|
||||
llarp_buffer_t buf)
|
||||
{
|
||||
if(inbound_msg_handler.ProcessFrom(session, buf))
|
||||
{
|
||||
return inbound_msg_handler.FlushReplies();
|
||||
}
|
||||
else
|
||||
return false;
|
||||
return inbound_msg_parser.ProcessFrom(session, buf);
|
||||
}
|
||||
|
||||
bool
|
||||
llarp_router::ProcessLRCM(llarp::LR_CommitMessage msg)
|
||||
llarp_router::SendToOrQueue(const llarp::RouterID &remote,
|
||||
std::vector< llarp::ILinkMessage * > msgs)
|
||||
{
|
||||
return false;
|
||||
bool has = false;
|
||||
for(auto &link : links)
|
||||
has |= link->has_session_to(link, remote);
|
||||
|
||||
if(!has)
|
||||
{
|
||||
llarp_rc rc;
|
||||
llarp_rc_clear(&rc);
|
||||
llarp_pubkey_t k;
|
||||
memcpy(k, remote, sizeof(llarp_pubkey_t));
|
||||
|
||||
if(!llarp_nodedb_find_rc(nodedb, &rc, k))
|
||||
{
|
||||
llarp::Warn(__FILE__, "cannot find router ", remote,
|
||||
" locally so we are dropping ", msgs.size(),
|
||||
" messages to them");
|
||||
|
||||
for(auto &msg : msgs)
|
||||
delete msg;
|
||||
|
||||
msgs.clear();
|
||||
return false;
|
||||
}
|
||||
|
||||
for(const auto &msg : msgs)
|
||||
{
|
||||
// this will create an entry in the obmq if it's not already there
|
||||
outboundMesssageQueue[remote].push(msg);
|
||||
}
|
||||
// queued
|
||||
llarp_router_try_connect(this, &rc);
|
||||
llarp_rc_clear(&rc);
|
||||
return true;
|
||||
}
|
||||
|
||||
for(const auto &msg : msgs)
|
||||
{
|
||||
outboundMesssageQueue[remote].push(msg);
|
||||
}
|
||||
FlushOutboundFor(remote);
|
||||
return true;
|
||||
}
|
||||
|
||||
void
|
||||
|
@ -205,11 +243,10 @@ llarp_router::on_verify_server_rc(llarp_async_verify_rc *job)
|
|||
// this was an outbound establish job
|
||||
if(ctx->establish_job->session)
|
||||
{
|
||||
auto session = ctx->establish_job->session;
|
||||
|
||||
llarp::pubkey pubkey;
|
||||
memcpy(&pubkey[0], job->rc.pubkey, pubkey.size());
|
||||
|
||||
// refresh valid routers RC value if it's there
|
||||
auto v = router->validRouters.find(pubkey);
|
||||
if(v != router->validRouters.end())
|
||||
{
|
||||
|
@ -218,22 +255,7 @@ llarp_router::on_verify_server_rc(llarp_async_verify_rc *job)
|
|||
}
|
||||
router->validRouters[pubkey] = job->rc;
|
||||
|
||||
auto itr = router->pendingMessages.find(pubkey);
|
||||
if(itr != router->pendingMessages.end())
|
||||
{
|
||||
// flush pending
|
||||
if(itr->second.size())
|
||||
{
|
||||
llarp::Debug(__FILE__, "flush ", itr->second.size(),
|
||||
" pending messages");
|
||||
}
|
||||
for(auto &msg : itr->second)
|
||||
{
|
||||
auto buf = llarp::Buffer< decltype(msg) >(msg);
|
||||
session->sendto(session, buf);
|
||||
}
|
||||
router->pendingMessages.erase(itr);
|
||||
}
|
||||
router->FlushOutboundFor(pubkey);
|
||||
}
|
||||
else
|
||||
llarp_rc_free(&job->rc);
|
||||
|
@ -241,6 +263,49 @@ llarp_router::on_verify_server_rc(llarp_async_verify_rc *job)
|
|||
delete job;
|
||||
}
|
||||
|
||||
void
|
||||
llarp_router::FlushOutboundFor(const llarp::RouterID &remote)
|
||||
{
|
||||
auto itr = outboundMesssageQueue.find(remote);
|
||||
if(itr == outboundMesssageQueue.end())
|
||||
return;
|
||||
while(itr->second.size())
|
||||
{
|
||||
auto buf = llarp::StackBuffer< decltype(linkmsg_buffer) >(linkmsg_buffer);
|
||||
|
||||
auto &msg = itr->second.front();
|
||||
|
||||
if(!msg->BEncode(&buf))
|
||||
{
|
||||
llarp::Warn(__FILE__,
|
||||
"failed to encode outbound message, buffer size left: ",
|
||||
llarp_buffer_size_left(buf));
|
||||
delete msg;
|
||||
itr->second.pop();
|
||||
continue;
|
||||
}
|
||||
// set size of message
|
||||
buf.sz = buf.cur - buf.base;
|
||||
buf.cur = buf.base;
|
||||
|
||||
bool sent = false;
|
||||
for(auto &link : links)
|
||||
{
|
||||
if(!sent)
|
||||
{
|
||||
sent = link->sendto(link, remote, buf);
|
||||
}
|
||||
}
|
||||
if(!sent)
|
||||
{
|
||||
llarp::Warn(__FILE__, "failed to flush outboud message queue for ",
|
||||
remote);
|
||||
}
|
||||
delete msg;
|
||||
itr->second.pop();
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
llarp_router::on_try_connect_result(llarp_link_establish_job *job)
|
||||
{
|
||||
|
|
|
@ -1,15 +1,18 @@
|
|||
#ifndef LLARP_ROUTER_HPP
|
||||
#define LLARP_ROUTER_HPP
|
||||
#include <llarp/dht.h>
|
||||
#include <llarp/link.h>
|
||||
#include <llarp/nodedb.h>
|
||||
#include <llarp/path.h>
|
||||
#include <llarp/router.h>
|
||||
#include <llarp/router_contact.h>
|
||||
|
||||
#include <functional>
|
||||
#include <list>
|
||||
#include <map>
|
||||
#include <unordered_map>
|
||||
|
||||
#include <llarp/dht.hpp>
|
||||
#include <llarp/link_message.hpp>
|
||||
|
||||
#include "crypto.hpp"
|
||||
|
@ -51,15 +54,24 @@ struct llarp_router
|
|||
llarp_path_context *paths;
|
||||
llarp_seckey_t identity;
|
||||
llarp_threadpool *disk;
|
||||
llarp_dht_context *dht;
|
||||
|
||||
llarp_nodedb *nodedb;
|
||||
|
||||
llarp::InboundMessageHandler inbound_msg_handler;
|
||||
// buffer for serializing link messages
|
||||
byte_t linkmsg_buffer[MAX_LINK_MSG_SIZE];
|
||||
|
||||
llarp::InboundMessageParser inbound_msg_parser;
|
||||
|
||||
std::list< llarp_link * > links;
|
||||
|
||||
std::map< llarp::pubkey, std::vector< llarp::Message > > pendingMessages;
|
||||
typedef std::queue< llarp::ILinkMessage * > MessageQueue;
|
||||
|
||||
/// outbound message queue
|
||||
std::unordered_map< llarp::pubkey, MessageQueue, llarp::pubkeyhash >
|
||||
outboundMesssageQueue;
|
||||
|
||||
/// loki verified routers
|
||||
std::unordered_map< llarp::pubkey, llarp_rc, llarp::pubkeyhash > validRouters;
|
||||
|
||||
llarp_router();
|
||||
|
@ -95,11 +107,20 @@ struct llarp_router
|
|||
void
|
||||
try_connect(fs::path rcfile);
|
||||
|
||||
void
|
||||
QueueSendTo(const byte_t *pubkey, const std::vector< llarp::Message > &msgs);
|
||||
|
||||
/// send to remote router or queue for sending
|
||||
/// returns false on overflow
|
||||
/// returns true on successful queue
|
||||
bool
|
||||
ProcessLRCM(llarp::LR_CommitMessage msg);
|
||||
SendToOrQueue(const llarp::RouterID &remote,
|
||||
std::vector< llarp::ILinkMessage * > msgs);
|
||||
|
||||
/// manually flush outbound message queue for just 1 router
|
||||
void
|
||||
FlushOutboundFor(const llarp::RouterID &remote);
|
||||
|
||||
/// flush outbound message queue
|
||||
void
|
||||
FlushOutbound();
|
||||
|
||||
void
|
||||
async_verify_RC(llarp_link_session *session, bool isExpectingClient,
|
||||
|
|
Loading…
Reference in New Issue