mirror of
https://github.com/oxen-io/lokinet
synced 2023-12-14 06:53:00 +01:00
all the files
This commit is contained in:
parent
8b456f1f1f
commit
02ca1796b2
38 changed files with 276 additions and 134 deletions
16
Makefile
16
Makefile
|
@ -11,13 +11,18 @@ CXX ?= c++
|
|||
TARGETS = lokinet
|
||||
SIGS = $(TARGETS:=.sig)
|
||||
|
||||
|
||||
SHADOW_ROOT ?= $(HOME)/.shadow
|
||||
SHADOW_BIN=$(SHADOW_ROOT)/bin/shadow
|
||||
SHADOW_CONFIG=$(REPO)/shadow.config.xml
|
||||
SHADOW_PLUGIN=$(REPO)/libshadow-plugin-llarp.so
|
||||
SHADOW_LOG=$(REPO)/shadow.log.txt
|
||||
|
||||
TESTNET_ROOT=$(REPO)/testnet_tmp
|
||||
SHADOW_SRC ?= $(HOME)/git/shadow
|
||||
SHADOW_PARSE ?= python $(SHADOW_SRC)/src/tools/parse-shadow.py - -m 0 --packet-data
|
||||
SHADOW_PLOT ?= python $(SHADOW_SRC)/src/tools/plot-shadow.py -d $(REPO) LokiNET -c $(SHADOW_CONFIG) -r 10000 -e '.*'
|
||||
|
||||
TESTNET_ROOT=/tmp/lokinet_testnet_tmp
|
||||
TESTNET_CONF=$(TESTNET_ROOT)/supervisor.conf
|
||||
TESTNET_LOG=$(TESTNET_ROOT)/testnet.log
|
||||
|
||||
|
@ -63,9 +68,14 @@ shadow-build: shadow-configure
|
|||
ninja clean
|
||||
ninja
|
||||
|
||||
shadow: shadow-build
|
||||
shadow-run: shadow-build
|
||||
python3 contrib/shadow/genconf.py $(SHADOW_CONFIG)
|
||||
bash -c "$(SHADOW_BIN) -w $$(cat /proc/cpuinfo | grep processor | wc -l) $(SHADOW_CONFIG) &> $(SHADOW_LOG)"
|
||||
bash -c "$(SHADOW_BIN) -w $$(cat /proc/cpuinfo | grep processor | wc -l) $(SHADOW_CONFIG) | $(SHADOW_PARSE)"
|
||||
|
||||
shadow-plot: shadow-run
|
||||
$(SHADOW_PLOT)
|
||||
|
||||
shadow: shadow-plot
|
||||
|
||||
testnet-configure: clean
|
||||
cmake -GNinja -DCMAKE_BUILD_TYPE=Debug -DCMAKE_C_COMPILER=$(CC) -DCMAKE_CXX_COMPILER=$(CXX)
|
||||
|
|
|
@ -71,6 +71,7 @@ def makeSVCNode(settings, name, id, port):
|
|||
|
||||
def genconf(settings, outf):
|
||||
root = etree.Element('shadow')
|
||||
root.attrib["environment"] = 'LLARP_SHADOW=1'
|
||||
topology = etree.SubElement(root, 'topology')
|
||||
topology.attrib['path'] = getSetting(settings, 'topology', os.path.join(
|
||||
shadowRoot, 'share', 'topology.graphml.xml'))
|
||||
|
|
|
@ -7,7 +7,7 @@ ident-privkey=server-ident.key
|
|||
#public-port=1090
|
||||
|
||||
[netdb]
|
||||
dir=./tmp-nodes
|
||||
dir=/tmp/nodes
|
||||
|
||||
[connect]
|
||||
#i2p.rocks=i2p.rocks.signed.txt
|
||||
|
|
|
@ -3,6 +3,7 @@
|
|||
#include <llarp/logger.h>
|
||||
#include <signal.h>
|
||||
#include <sys/param.h> // for MIN
|
||||
#include <string>
|
||||
|
||||
struct llarp_main *ctx = 0;
|
||||
|
||||
|
@ -13,13 +14,15 @@ handle_signal(int sig)
|
|||
llarp_main_signal(ctx, sig);
|
||||
}
|
||||
|
||||
#ifndef TESTNET
|
||||
#define TESTNET 0
|
||||
#endif
|
||||
|
||||
int
|
||||
main(int argc, char *argv[])
|
||||
{
|
||||
bool multiThreaded = true;
|
||||
const char *singleThreadVar = getenv("LLARP_SHADOW");
|
||||
if(singleThreadVar && std::string(singleThreadVar) == "1")
|
||||
{
|
||||
multiThreaded = false;
|
||||
}
|
||||
const char *conffname = "daemon.ini";
|
||||
int c;
|
||||
while(1)
|
||||
|
@ -65,13 +68,13 @@ main(int argc, char *argv[])
|
|||
}
|
||||
}
|
||||
|
||||
ctx = llarp_main_init(conffname, !TESTNET);
|
||||
ctx = llarp_main_init(conffname, multiThreaded);
|
||||
int code = 1;
|
||||
if(ctx)
|
||||
{
|
||||
signal(SIGINT, handle_signal);
|
||||
code = llarp_main_run(ctx);
|
||||
// llarp_main_free(ctx);
|
||||
llarp_main_free(ctx);
|
||||
}
|
||||
return code;
|
||||
}
|
||||
|
|
|
@ -25,18 +25,8 @@ namespace llarp
|
|||
{
|
||||
}
|
||||
};
|
||||
|
||||
template < typename T, typename GetTime, typename PutTime,
|
||||
typename Mutex_t = std::mutex,
|
||||
typename Lock_t = std::unique_lock< Mutex_t >,
|
||||
llarp_time_t dropMs = 20, llarp_time_t initialIntervalMs = 100 >
|
||||
struct CoDelQueue
|
||||
{
|
||||
CoDelQueue(const std::string& name) : m_name(name)
|
||||
{
|
||||
}
|
||||
|
||||
struct CoDelCompare
|
||||
template < typename T, typename GetTime >
|
||||
struct CoDelCompareTime
|
||||
{
|
||||
bool
|
||||
operator()(const T& left, const T& right) const
|
||||
|
@ -45,6 +35,26 @@ namespace llarp
|
|||
}
|
||||
};
|
||||
|
||||
template < typename T >
|
||||
struct CoDelComparePriority
|
||||
{
|
||||
bool
|
||||
operator()(const T& left, const T& right) const
|
||||
{
|
||||
return left < right;
|
||||
}
|
||||
};
|
||||
|
||||
template < typename T, typename GetTime, typename PutTime, typename Compare,
|
||||
typename Mutex_t = std::mutex,
|
||||
typename Lock_t = std::unique_lock< Mutex_t >,
|
||||
llarp_time_t dropMs = 5, llarp_time_t initialIntervalMs = 100 >
|
||||
struct CoDelQueue
|
||||
{
|
||||
CoDelQueue(const std::string& name) : m_name(name)
|
||||
{
|
||||
}
|
||||
|
||||
size_t
|
||||
Size()
|
||||
{
|
||||
|
@ -53,7 +63,7 @@ namespace llarp
|
|||
}
|
||||
|
||||
void
|
||||
Put(const T& i)
|
||||
Put(T i)
|
||||
{
|
||||
Lock_t lock(m_QueueMutex);
|
||||
// llarp::LogInfo("CoDelQueue::Put - adding item, queue now has ",
|
||||
|
@ -111,7 +121,7 @@ namespace llarp
|
|||
size_t dropNum = 0;
|
||||
llarp_time_t nextTickInterval = initialIntervalMs;
|
||||
Mutex_t m_QueueMutex;
|
||||
std::priority_queue< T, std::vector< T >, CoDelCompare > m_Queue;
|
||||
std::priority_queue< T, std::vector< T >, Compare > m_Queue;
|
||||
std::string m_name;
|
||||
};
|
||||
} // namespace util
|
||||
|
|
|
@ -106,4 +106,8 @@ llarp_crypto_libsodium_init(struct llarp_crypto *c);
|
|||
bool
|
||||
llarp_crypto_initialized(struct llarp_crypto *c);
|
||||
|
||||
/// return random 64bit unsigned interger
|
||||
uint64_t
|
||||
llarp_randint();
|
||||
|
||||
#endif
|
||||
|
|
|
@ -196,6 +196,15 @@ struct FrameGetTime
|
|||
}
|
||||
};
|
||||
|
||||
struct FrameCompareTime
|
||||
{
|
||||
bool
|
||||
operator()(const iwp_async_frame *left, iwp_async_frame *right) const
|
||||
{
|
||||
return left->created < right->created;
|
||||
}
|
||||
};
|
||||
|
||||
/// synchronously decrypt a frame
|
||||
bool
|
||||
iwp_decrypt_frame(struct iwp_async_frame *frame);
|
||||
|
|
|
@ -2,6 +2,7 @@
|
|||
#define LLARP_DHT_MESSAGES_GOT_INTRO_HPP
|
||||
#include <llarp/dht/message.hpp>
|
||||
#include <llarp/service/IntroSet.hpp>
|
||||
#include <vector>
|
||||
|
||||
namespace llarp
|
||||
{
|
||||
|
@ -10,14 +11,14 @@ namespace llarp
|
|||
/// acknologement to PublishIntroMessage or reply to FinIntroMessage
|
||||
struct GotIntroMessage : public IMessage
|
||||
{
|
||||
std::set< llarp::service::IntroSet > I;
|
||||
std::vector< llarp::service::IntroSet > I;
|
||||
uint64_t T = 0;
|
||||
|
||||
GotIntroMessage(const Key_t& from) : IMessage(from)
|
||||
{
|
||||
}
|
||||
|
||||
GotIntroMessage(const std::set< llarp::service::IntroSet >& results,
|
||||
GotIntroMessage(const std::vector< llarp::service::IntroSet >& results,
|
||||
uint64_t txid);
|
||||
|
||||
~GotIntroMessage();
|
||||
|
|
|
@ -2,6 +2,8 @@
|
|||
#define LLARP_DHT_MESSAGES_PUB_INTRO_HPP
|
||||
#include <llarp/dht/message.hpp>
|
||||
#include <llarp/service/IntroSet.hpp>
|
||||
#include <vector>
|
||||
|
||||
namespace llarp
|
||||
{
|
||||
namespace dht
|
||||
|
@ -9,7 +11,7 @@ namespace llarp
|
|||
struct PublishIntroMessage : public IMessage
|
||||
{
|
||||
llarp::service::IntroSet I;
|
||||
std::set< Key_t > E;
|
||||
std::vector< Key_t > E;
|
||||
uint64_t R = 0;
|
||||
uint64_t S = 0;
|
||||
uint64_t txID = 0;
|
||||
|
@ -19,7 +21,7 @@ namespace llarp
|
|||
}
|
||||
|
||||
PublishIntroMessage(const llarp::service::IntroSet& i, uint64_t tx,
|
||||
uint64_t s, const std::set< Key_t >& exclude = {})
|
||||
uint64_t s, const std::vector< Key_t >& exclude = {})
|
||||
: IMessage({}), E(exclude), txID(tx)
|
||||
{
|
||||
I = i;
|
||||
|
|
|
@ -7,6 +7,7 @@
|
|||
#include <llarp/dht/key.hpp>
|
||||
#include <llarp/service/IntroSet.hpp>
|
||||
#include <set>
|
||||
#include <vector>
|
||||
|
||||
namespace llarp
|
||||
{
|
||||
|
@ -17,7 +18,8 @@ namespace llarp
|
|||
{
|
||||
const static uint64_t JobTimeout = 30000;
|
||||
|
||||
typedef std::function< void(const std::set< llarp::service::IntroSet >&) >
|
||||
typedef std::function< void(
|
||||
const std::vector< llarp::service::IntroSet >&) >
|
||||
IntroSetHookFunc;
|
||||
SearchJob();
|
||||
/// for routers
|
||||
|
@ -36,7 +38,8 @@ namespace llarp
|
|||
FoundRouter(const llarp_rc* router) const;
|
||||
|
||||
void
|
||||
FoundIntros(const std::set< llarp::service::IntroSet >& introset) const;
|
||||
FoundIntros(
|
||||
const std::vector< llarp::service::IntroSet >& introset) const;
|
||||
|
||||
void
|
||||
Timeout() const;
|
||||
|
|
|
@ -8,6 +8,7 @@
|
|||
#include "llarp/time.h"
|
||||
#include "llarp/types.h"
|
||||
#include "sendbuf.hpp"
|
||||
#include "sendqueue.hpp"
|
||||
#include "transit_message.hpp"
|
||||
|
||||
#include <queue>
|
||||
|
@ -49,10 +50,12 @@ struct frame_state
|
|||
rx;
|
||||
std::unordered_map< uint64_t, transit_message * > tx;
|
||||
|
||||
typedef std::queue< sendbuf_t * > sendqueue_t;
|
||||
// typedef std::queue< sendbuf_t * > sendqueue_t;
|
||||
|
||||
typedef llarp::util::CoDelQueue<
|
||||
InboundMessage *, InboundMessage::GetTime, InboundMessage::PutTime,
|
||||
llarp::util::DummyMutex, llarp::util::DummyLock >
|
||||
InboundMessage::OrderCompare, llarp::util::DummyMutex,
|
||||
llarp::util::DummyLock >
|
||||
recvqueue_t;
|
||||
|
||||
llarp_link_session *parent = nullptr;
|
||||
|
@ -62,7 +65,9 @@ struct frame_state
|
|||
uint64_t nextMsgID = 0;
|
||||
|
||||
frame_state(llarp_link_session *session)
|
||||
: parent(session), recvqueue("iwp_inbound_message")
|
||||
: parent(session)
|
||||
, sendqueue("iwp_outbound_message")
|
||||
, recvqueue("iwp_inbound_message")
|
||||
{
|
||||
}
|
||||
|
||||
|
|
|
@ -1,7 +1,7 @@
|
|||
#pragma once
|
||||
|
||||
#include "llarp/buffer.h"
|
||||
|
||||
#include <llarp/buffer.h>
|
||||
#include <llarp/time.h>
|
||||
#include <queue>
|
||||
|
||||
struct sendbuf_t
|
||||
|
@ -19,6 +19,8 @@ struct sendbuf_t
|
|||
|
||||
size_t sz;
|
||||
|
||||
byte_t priority = 255;
|
||||
|
||||
size_t
|
||||
size() const
|
||||
{
|
||||
|
@ -31,8 +33,45 @@ struct sendbuf_t
|
|||
return _buf;
|
||||
}
|
||||
|
||||
llarp_buffer_t
|
||||
Buffer()
|
||||
{
|
||||
llarp_buffer_t buf;
|
||||
buf.base = _buf;
|
||||
buf.sz = sz;
|
||||
buf.cur = buf.base;
|
||||
return buf;
|
||||
}
|
||||
|
||||
struct GetTime
|
||||
{
|
||||
llarp_time_t
|
||||
operator()(const sendbuf_t *buf) const
|
||||
{
|
||||
return buf->timestamp;
|
||||
}
|
||||
};
|
||||
|
||||
struct PutTime
|
||||
{
|
||||
void
|
||||
operator()(sendbuf_t *&buf) const
|
||||
{
|
||||
buf->timestamp = llarp_time_now_ms();
|
||||
}
|
||||
};
|
||||
|
||||
struct Compare
|
||||
{
|
||||
bool
|
||||
operator()(const sendbuf_t *left, const sendbuf_t *right) const
|
||||
{
|
||||
return left->priority < right->priority;
|
||||
}
|
||||
};
|
||||
|
||||
llarp_time_t timestamp = 0;
|
||||
|
||||
private:
|
||||
byte_t *_buf = nullptr;
|
||||
};
|
||||
|
||||
typedef std::queue< sendbuf_t * > sendqueue_t;
|
|
@ -1,10 +1,11 @@
|
|||
#ifndef LLARP_IWP_SENDQUEUE_HPP
|
||||
#define LLARP_IWP_SENDQUEUE_HPP
|
||||
#include <llarp/iwp/sendbuf.hpp>
|
||||
#include <llarp/codel.hpp>
|
||||
#include <llarp/iwp/sendbuf.hpp>
|
||||
|
||||
typedef llarp::util::CoDelQueue<sendbuf_t *, sendbuf_t::GetTime, sendbuf_t::PutTime,
|
||||
sendbuf_t::Compare,
|
||||
llarp::util::DummyMutex, llarp::util::DummyLock> sendqueue_t;
|
||||
typedef llarp::util::CoDelQueue<
|
||||
sendbuf_t *, sendbuf_t::GetTime, sendbuf_t::PutTime, sendbuf_t::Compare,
|
||||
llarp::util::DummyMutex, llarp::util::DummyLock >
|
||||
sendqueue_t;
|
||||
|
||||
#endif
|
|
@ -46,7 +46,7 @@ struct llarp_link
|
|||
|
||||
SessionMap_t m_Connected;
|
||||
mtx_t m_Connected_Mutex;
|
||||
bool pumpingLogic = false;
|
||||
std::atomic< bool > pumpingLogic;
|
||||
|
||||
typedef std::unordered_map< llarp::Addr, llarp_link_session *,
|
||||
llarp::addrhash >
|
||||
|
@ -65,6 +65,7 @@ struct llarp_link
|
|||
{
|
||||
strncpy(keyfile, args.keyfile, sizeof(keyfile));
|
||||
iwp = llarp_async_iwp_new(crypto, logic, worker);
|
||||
pumpingLogic.store(false);
|
||||
}
|
||||
|
||||
~llarp_link()
|
||||
|
@ -126,6 +127,20 @@ struct llarp_link
|
|||
}
|
||||
for(const auto &addr : remove)
|
||||
RemoveSessionByAddr(addr);
|
||||
|
||||
{
|
||||
lock_t lock(m_PendingSessions_Mutex);
|
||||
auto itr = m_PendingSessions.begin();
|
||||
while(itr != m_PendingSessions.end())
|
||||
{
|
||||
if(itr->second->timedout(now))
|
||||
{
|
||||
itr = m_PendingSessions.erase(itr);
|
||||
}
|
||||
else
|
||||
++itr;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static bool
|
||||
|
|
|
@ -117,13 +117,15 @@ struct llarp_link_session
|
|||
uint32_t frames = 0;
|
||||
std::atomic< bool > working;
|
||||
|
||||
llarp::util::CoDelQueue< iwp_async_frame *, FrameGetTime, FramePutTime >
|
||||
llarp::util::CoDelQueue< iwp_async_frame *, FrameGetTime, FramePutTime,
|
||||
FrameCompareTime >
|
||||
outboundFrames;
|
||||
/*
|
||||
std::mutex m_EncryptedFramesMutex;
|
||||
std::queue< iwp_async_frame > encryptedFrames;
|
||||
*/
|
||||
llarp::util::CoDelQueue< iwp_async_frame *, FrameGetTime, FramePutTime >
|
||||
llarp::util::CoDelQueue< iwp_async_frame *, FrameGetTime, FramePutTime,
|
||||
FrameCompareTime >
|
||||
decryptedFrames;
|
||||
|
||||
uint32_t pump_send_timer_id = 0;
|
||||
|
@ -133,8 +135,6 @@ struct llarp_link_session
|
|||
iwp_async_intro intro;
|
||||
iwp_async_introack introack;
|
||||
iwp_async_session_start start;
|
||||
// frame_state frame;
|
||||
bool started_inbound_codel = false;
|
||||
|
||||
byte_t token[32];
|
||||
byte_t workbuf[MAX_PAD + 128];
|
||||
|
|
|
@ -2,6 +2,7 @@
|
|||
|
||||
#include "llarp/types.h"
|
||||
#include "sendbuf.hpp"
|
||||
#include "sendqueue.hpp"
|
||||
#include "xmit.hpp"
|
||||
|
||||
#include <bitset>
|
||||
|
|
|
@ -9,7 +9,7 @@
|
|||
#include <llarp/service/Intro.hpp>
|
||||
#include <llarp/service/tag.hpp>
|
||||
|
||||
#include <set>
|
||||
#include <vector>
|
||||
|
||||
namespace llarp
|
||||
{
|
||||
|
@ -20,7 +20,7 @@ namespace llarp
|
|||
struct IntroSet : public llarp::IBEncodeMessage
|
||||
{
|
||||
ServiceInfo A;
|
||||
std::set< Introduction > I;
|
||||
std::vector< Introduction > I;
|
||||
Tag topic;
|
||||
llarp::PoW* W = nullptr;
|
||||
llarp::Signature Z;
|
||||
|
|
|
@ -106,10 +106,10 @@ namespace llarp
|
|||
|
||||
uint64_t sequenceNo = 0;
|
||||
llarp::SharedSecret sharedKey;
|
||||
llarp::util::CoDelQueue< ProtocolMessage*, ProtocolMessage::GetTime,
|
||||
ProtocolMessage::PutTime,
|
||||
llarp::util::DummyMutex,
|
||||
llarp::util::DummyLock >
|
||||
llarp::util::CoDelQueue<
|
||||
ProtocolMessage*, ProtocolMessage::GetTime,
|
||||
ProtocolMessage::PutTime, ProtocolMessage::Compare,
|
||||
llarp::util::DummyMutex, llarp::util::DummyLock >
|
||||
m_SendQueue;
|
||||
Endpoint* m_Parent;
|
||||
};
|
||||
|
|
|
@ -17,12 +17,13 @@ namespace llarp
|
|||
|
||||
struct ProtocolMessage : public llarp::IBEncodeMessage
|
||||
{
|
||||
ProtocolMessage(ProtocolType t);
|
||||
ProtocolMessage(ProtocolType t, uint64_t seqno);
|
||||
~ProtocolMessage();
|
||||
ProtocolType proto;
|
||||
llarp_time_t queued = 0;
|
||||
std::vector< byte_t > payload;
|
||||
llarp::KeyExchangeNonce N;
|
||||
uint64_t sequenceNum;
|
||||
|
||||
bool
|
||||
DecodeKey(llarp_buffer_t key, llarp_buffer_t* val);
|
||||
|
@ -32,6 +33,16 @@ namespace llarp
|
|||
void
|
||||
PutBuffer(llarp_buffer_t payload);
|
||||
|
||||
struct Compare
|
||||
{
|
||||
bool
|
||||
operator()(const ProtocolMessage* left,
|
||||
const ProtocolMessage* right) const
|
||||
{
|
||||
return left->sequenceNum < right->sequenceNum;
|
||||
}
|
||||
};
|
||||
|
||||
struct GetTime
|
||||
{
|
||||
llarp_time_t
|
||||
|
|
|
@ -159,3 +159,11 @@ llarp_crypto_libsodium_init(struct llarp_crypto *c)
|
|||
c->randbytes(&seed, sizeof(seed));
|
||||
srand(seed);
|
||||
}
|
||||
|
||||
uint64_t
|
||||
llarp_randint()
|
||||
{
|
||||
uint64_t i;
|
||||
randombytes((byte_t *)&i, sizeof(i));
|
||||
return i;
|
||||
}
|
|
@ -2,6 +2,7 @@
|
|||
#include <llarp/dht/messages/gotrouter.hpp>
|
||||
#include <llarp/messages/dht.hpp>
|
||||
#include <llarp/messages/dht_immediate.hpp>
|
||||
#include <vector>
|
||||
#include "router.hpp"
|
||||
|
||||
namespace llarp
|
||||
|
@ -57,7 +58,7 @@ namespace llarp
|
|||
}
|
||||
|
||||
void
|
||||
OnResult(const std::set< service::IntroSet > &results)
|
||||
OnResult(const std::vector< service::IntroSet > &results)
|
||||
{
|
||||
auto path =
|
||||
m_router->paths.GetByUpstream(m_router->dht->impl.OurKey(), pathID);
|
||||
|
@ -68,7 +69,13 @@ namespace llarp
|
|||
localtags.insert(introset);
|
||||
}
|
||||
llarp::routing::DHTMessage msg;
|
||||
msg.M.push_back(new llarp::dht::GotIntroMessage(localtags, txid));
|
||||
auto sz = localtags.size();
|
||||
std::vector< service::IntroSet > intros(sz);
|
||||
for(const auto &i : localtags)
|
||||
{
|
||||
intros[--sz] = i;
|
||||
}
|
||||
msg.M.push_back(new llarp::dht::GotIntroMessage(intros, txid));
|
||||
path->SendRoutingMessage(&msg, m_router);
|
||||
}
|
||||
else
|
||||
|
@ -92,7 +99,8 @@ namespace llarp
|
|||
TXOwner ownerKey;
|
||||
ownerKey.node = peer;
|
||||
ownerKey.txid = id;
|
||||
SearchJob job(from, txid, [](const std::set< service::IntroSet > &) {});
|
||||
SearchJob job(from, txid,
|
||||
[](const std::vector< service::IntroSet > &) {});
|
||||
pendingTX[ownerKey] = job;
|
||||
auto msg = new llarp::DHTImmeidateMessage(peer);
|
||||
msg->msgs.push_back(new PublishIntroMessage(introset, id, S));
|
||||
|
@ -130,7 +138,7 @@ namespace llarp
|
|||
|
||||
auto itr = nodes.begin();
|
||||
// start at random middle point
|
||||
auto start = rand() % nodes.size();
|
||||
auto start = llarp_randint() % nodes.size();
|
||||
std::advance(itr, start);
|
||||
auto end = itr;
|
||||
while(itr != nodes.end())
|
||||
|
@ -308,7 +316,7 @@ namespace llarp
|
|||
}
|
||||
|
||||
void
|
||||
OnResult(const std::set< llarp::service::IntroSet > &results)
|
||||
OnResult(const std::vector< llarp::service::IntroSet > &results)
|
||||
{
|
||||
if(replyNode != m_Router->dht->impl.OurKey())
|
||||
{
|
||||
|
|
|
@ -148,7 +148,9 @@ namespace llarp
|
|||
{
|
||||
if(iterative)
|
||||
{
|
||||
auto introsets = dht.FindRandomIntroSetsWithTag(N, 8);
|
||||
std::vector< service::IntroSet > introsets;
|
||||
for(const auto& introset : dht.FindRandomIntroSetsWithTag(N, 8))
|
||||
introsets.push_back(introset);
|
||||
// we are iterative and don't have it, reply with a direct reply
|
||||
replies.push_back(new GotIntroMessage(introsets, T));
|
||||
}
|
||||
|
|
|
@ -9,7 +9,7 @@ namespace llarp
|
|||
namespace dht
|
||||
{
|
||||
GotIntroMessage::GotIntroMessage(
|
||||
const std::set< llarp::service::IntroSet > &results, uint64_t tx)
|
||||
const std::vector< llarp::service::IntroSet > &results, uint64_t tx)
|
||||
: IMessage({}), I(results), T(tx)
|
||||
{
|
||||
}
|
||||
|
@ -24,7 +24,6 @@ namespace llarp
|
|||
{
|
||||
auto &dht = ctx->impl;
|
||||
auto crypto = &dht.router->crypto;
|
||||
std::set< service::IntroSet > introsets;
|
||||
|
||||
for(const auto &introset : I)
|
||||
{
|
||||
|
@ -36,22 +35,11 @@ namespace llarp
|
|||
From);
|
||||
return false;
|
||||
}
|
||||
llarp::dht::Key_t addr;
|
||||
if(!introset.A.CalculateAddress(addr))
|
||||
{
|
||||
llarp::LogWarn(
|
||||
"failed to calculate hidden service address for direct "
|
||||
"GotIntro "
|
||||
"message from ",
|
||||
From);
|
||||
return false;
|
||||
}
|
||||
introsets.insert(introset);
|
||||
}
|
||||
auto pending = dht.FindPendingTX(From, T);
|
||||
if(pending)
|
||||
{
|
||||
pending->FoundIntros(introsets);
|
||||
pending->FoundIntros(I);
|
||||
dht.RemovePendingLookup(From, T);
|
||||
return true;
|
||||
}
|
||||
|
@ -82,7 +70,7 @@ namespace llarp
|
|||
{
|
||||
if(llarp_buffer_eq(key, "I"))
|
||||
{
|
||||
return BEncodeReadSet(I, buf);
|
||||
return BEncodeReadList(I, buf);
|
||||
}
|
||||
bool read = false;
|
||||
if(!BEncodeMaybeReadDictInt("T", T, read, key, buf))
|
||||
|
|
|
@ -19,7 +19,7 @@ namespace llarp
|
|||
bool read = false;
|
||||
if(llarp_buffer_eq(key, "E"))
|
||||
{
|
||||
return BEncodeReadSet(E, val);
|
||||
return BEncodeReadList(E, val);
|
||||
}
|
||||
if(!BEncodeMaybeReadDictEntry("I", I, read, key, val))
|
||||
return false;
|
||||
|
@ -69,8 +69,11 @@ namespace llarp
|
|||
dht.services->PutNode(I);
|
||||
replies.push_back(new GotIntroMessage({I}, txID));
|
||||
Key_t peer;
|
||||
std::set< Key_t > exclude = E;
|
||||
std::set< Key_t > exclude;
|
||||
for(const auto &e : E)
|
||||
exclude.insert(e);
|
||||
exclude.insert(From);
|
||||
exclude.insert(dht.OurKey());
|
||||
if(S && dht.nodes->FindCloseExcluding(addr, peer, exclude))
|
||||
{
|
||||
dht.PropagateIntroSetTo(From, txID, I, peer, S - 1);
|
||||
|
|
|
@ -46,7 +46,7 @@ namespace llarp
|
|||
|
||||
void
|
||||
SearchJob::FoundIntros(
|
||||
const std::set< llarp::service::IntroSet > &introsets) const
|
||||
const std::vector< llarp::service::IntroSet > &introsets) const
|
||||
{
|
||||
if(foundIntroHook)
|
||||
foundIntroHook(introsets);
|
||||
|
|
|
@ -27,19 +27,29 @@ frame_state::process_inbound_queue()
|
|||
// TODO: is this right?
|
||||
auto &front = q.top();
|
||||
// the items are already sorted anyways so this doesn't really do much
|
||||
nextMsgID = std::max(nextMsgID, front->msgid);
|
||||
|
||||
if(front->msgid < nextMsgID && nextMsgID - front->msgid > 1)
|
||||
{
|
||||
// re queue
|
||||
recvqueue.Put(front);
|
||||
nextMsgID = front->msgid;
|
||||
}
|
||||
else
|
||||
{
|
||||
auto buffer = front->Buffer();
|
||||
if(!Router()->HandleRecvLinkMessage(parent, buffer))
|
||||
{
|
||||
llarp::LogWarn("failed to process inbound message ", front->msgid);
|
||||
llarp::DumpBuffer< llarp_buffer_t, 128 >(buffer);
|
||||
}
|
||||
delete front;
|
||||
q.pop();
|
||||
increment = true;
|
||||
else
|
||||
{
|
||||
nextMsgID = std::max(front->msgid, nextMsgID + 1);
|
||||
}
|
||||
delete front;
|
||||
}
|
||||
q.pop();
|
||||
}
|
||||
if(increment)
|
||||
++nextMsgID;
|
||||
// TODO: this isn't right
|
||||
return true;
|
||||
}
|
||||
|
@ -145,13 +155,13 @@ frame_state::got_frag(frame_header hdr, size_t sz)
|
|||
auto idItr = rxIDs.find(msgid);
|
||||
if(idItr == rxIDs.end())
|
||||
{
|
||||
llarp::LogWarn("no such RX fragment, msgid=", msgid);
|
||||
push_ackfor(msgid, 0);
|
||||
return true;
|
||||
}
|
||||
auto itr = rx.find(idItr->second);
|
||||
if(itr == rx.end())
|
||||
{
|
||||
llarp::LogWarn("no such RX fragment, msgid=", msgid);
|
||||
push_ackfor(msgid, 0);
|
||||
return true;
|
||||
}
|
||||
auto fragsize = itr->second->msginfo.fragsize();
|
||||
|
@ -184,11 +194,12 @@ void
|
|||
frame_state::push_ackfor(uint64_t id, uint32_t bitmask)
|
||||
{
|
||||
llarp::LogDebug("ACK for msgid=", id, " mask=", bitmask);
|
||||
sendqueue.push(new sendbuf_t(12 + 6));
|
||||
auto body_ptr = init_sendbuf(sendqueue.back(), eACKS, 12, txflags);
|
||||
auto pkt = new sendbuf_t(12 + 6);
|
||||
auto body_ptr = init_sendbuf(pkt, eACKS, 12, txflags);
|
||||
// TODO: this assumes big endian
|
||||
memcpy(body_ptr, &id, 8);
|
||||
memcpy(body_ptr + 8, &bitmask, 4);
|
||||
sendqueue.Put(pkt);
|
||||
}
|
||||
|
||||
bool
|
||||
|
@ -331,6 +342,7 @@ frame_state::process(byte_t *buf, size_t sz)
|
|||
}
|
||||
}
|
||||
|
||||
/*
|
||||
bool
|
||||
frame_state::next_frame(llarp_buffer_t *buf)
|
||||
{
|
||||
|
@ -354,6 +366,7 @@ frame_state::pop_next_frame()
|
|||
delete buf;
|
||||
sendqueue.pop();
|
||||
}
|
||||
*/
|
||||
|
||||
void
|
||||
frame_state::queue_tx(uint64_t id, transit_message *msg)
|
||||
|
|
|
@ -424,6 +424,7 @@ llarp_link_session::TickLogic()
|
|||
q.pop();
|
||||
}
|
||||
frame.process_inbound_queue();
|
||||
frame.retransmit(now);
|
||||
pump();
|
||||
}
|
||||
|
||||
|
@ -453,15 +454,9 @@ llarp_link_session::Tick(llarp_time_t now)
|
|||
if(now - lastKeepalive > KEEP_ALIVE_INTERVAL)
|
||||
send_keepalive(this);
|
||||
}
|
||||
|
||||
// pump frame state
|
||||
if(state == eEstablished)
|
||||
{
|
||||
// llarp::LogDebug("Tick - pumping and retransmitting because we're
|
||||
// eEstablished");
|
||||
|
||||
frame.retransmit(now);
|
||||
pump();
|
||||
this->now = now;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
@ -558,7 +553,7 @@ llarp_link_session::introduce(uint8_t *pub)
|
|||
llarp::LogDebug("session introduce");
|
||||
memcpy(remote, pub, PUBKEYSIZE);
|
||||
intro.buf = workbuf;
|
||||
size_t w0sz = (rand() % MAX_PAD);
|
||||
size_t w0sz = (llarp_randint() % MAX_PAD);
|
||||
intro.sz = (32 * 3) + w0sz;
|
||||
// randomize w0
|
||||
if(w0sz)
|
||||
|
@ -576,8 +571,6 @@ llarp_link_session::introduce(uint8_t *pub)
|
|||
intro.user = this;
|
||||
intro.hook = &handle_generated_intro;
|
||||
working = true;
|
||||
llarp::LogInfo("try introduce to transport adddress ",
|
||||
llarp::RouterID(remote));
|
||||
iwp_call_async_gen_intro(iwp, &intro);
|
||||
// start introduce timer
|
||||
establish_job_id = llarp_logic_call_later(
|
||||
|
@ -630,7 +623,7 @@ void
|
|||
llarp_link_session::session_start()
|
||||
{
|
||||
llarp::LogInfo("session gen start");
|
||||
size_t w2sz = rand() % MAX_PAD;
|
||||
size_t w2sz = llarp_randint() % MAX_PAD;
|
||||
start.buf = workbuf;
|
||||
start.sz = w2sz + (32 * 3);
|
||||
start.nonce = workbuf + 32;
|
||||
|
@ -682,7 +675,7 @@ llarp_link_session::intro_ack()
|
|||
return;
|
||||
}
|
||||
llarp::LogDebug("session introack");
|
||||
uint16_t w1sz = rand() % MAX_PAD;
|
||||
uint16_t w1sz = llarp_randint() % MAX_PAD;
|
||||
introack.buf = workbuf;
|
||||
introack.sz = (32 * 3) + w1sz;
|
||||
// randomize padding
|
||||
|
@ -785,7 +778,7 @@ llarp_link_session::encrypt_frame_async_send(const void *buf, size_t sz)
|
|||
iwp_async_frame *frame = alloc_frame(nullptr, sz + 64);
|
||||
memcpy(frame->buf + 64, buf, sz);
|
||||
// maybe add upto 128 random bytes to the packet
|
||||
auto padding = rand() % MAX_PAD;
|
||||
auto padding = llarp_randint() % MAX_PAD;
|
||||
if(padding)
|
||||
crypto->randbytes(frame->buf + 64 + sz, padding);
|
||||
frame->sz += padding;
|
||||
|
@ -802,10 +795,15 @@ llarp_link_session::pump()
|
|||
bool flush = false;
|
||||
now = llarp_time_now_ms();
|
||||
llarp_buffer_t buf;
|
||||
while(frame.next_frame(&buf))
|
||||
std::queue< sendbuf_t * > q;
|
||||
frame.sendqueue.Process(q);
|
||||
while(q.size())
|
||||
{
|
||||
auto &front = q.front();
|
||||
buf = front->Buffer();
|
||||
encrypt_frame_async_send(buf.base, buf.sz);
|
||||
frame.pop_next_frame();
|
||||
delete front;
|
||||
q.pop();
|
||||
flush = true;
|
||||
}
|
||||
if(flush)
|
||||
|
|
|
@ -98,11 +98,12 @@ void
|
|||
transit_message::generate_xmit(sendqueue_t &queue, byte_t flags)
|
||||
{
|
||||
uint16_t sz = lastfrag.size() + sizeof(msginfo.buffer);
|
||||
queue.push(new sendbuf_t(sz + 6));
|
||||
auto body_ptr = init_sendbuf(queue.back(), eXMIT, sz, flags);
|
||||
auto pkt = new sendbuf_t(sz + 6);
|
||||
auto body_ptr = init_sendbuf(pkt, eXMIT, sz, flags);
|
||||
memcpy(body_ptr, msginfo.buffer, sizeof(msginfo.buffer));
|
||||
body_ptr += sizeof(msginfo.buffer);
|
||||
memcpy(body_ptr, lastfrag.data(), lastfrag.size());
|
||||
queue.Put(pkt);
|
||||
}
|
||||
|
||||
// template < typename T >
|
||||
|
@ -116,12 +117,13 @@ transit_message::retransmit_frags(sendqueue_t &queue, byte_t flags)
|
|||
if(status.test(frag.first))
|
||||
continue;
|
||||
uint16_t sz = 9 + fragsize;
|
||||
queue.push(new sendbuf_t(sz + 6));
|
||||
auto body_ptr = init_sendbuf(queue.back(), eFRAG, sz, flags);
|
||||
auto pkt = new sendbuf_t(sz + 6);
|
||||
auto body_ptr = init_sendbuf(pkt, eFRAG, sz, flags);
|
||||
// TODO: assumes big endian
|
||||
memcpy(body_ptr, &msgid, 8);
|
||||
body_ptr[8] = frag.first;
|
||||
memcpy(body_ptr + 9, frag.second.data(), fragsize);
|
||||
queue.Put(pkt);
|
||||
}
|
||||
lastRetransmit = llarp_time_now_ms();
|
||||
}
|
||||
|
|
|
@ -51,6 +51,8 @@ namespace llarp
|
|||
if(idx % align == 0)
|
||||
printf("\n");
|
||||
}
|
||||
printf("\n");
|
||||
fflush(stdout);
|
||||
}
|
||||
|
||||
} // namespace llarp
|
||||
|
|
|
@ -439,7 +439,7 @@ llarp_nodedb_select_random_hop(struct llarp_nodedb *n, struct llarp_rc *prev,
|
|||
auto itr = n->entries.begin();
|
||||
if(sz > 1)
|
||||
{
|
||||
auto idx = rand() % sz;
|
||||
auto idx = llarp_randint() % sz;
|
||||
std::advance(itr, idx);
|
||||
}
|
||||
if(memcmp(prev->pubkey, itr->second.pubkey, PUBKEYSIZE) == 0)
|
||||
|
@ -453,7 +453,7 @@ llarp_nodedb_select_random_hop(struct llarp_nodedb *n, struct llarp_rc *prev,
|
|||
auto itr = n->entries.begin();
|
||||
if(sz > 1)
|
||||
{
|
||||
auto idx = rand() % sz;
|
||||
auto idx = llarp_randint() % sz;
|
||||
std::advance(itr, idx);
|
||||
}
|
||||
llarp_rc_copy(result, &itr->second);
|
||||
|
|
|
@ -64,7 +64,7 @@ namespace llarp
|
|||
PathContext::ForwardLRCM(const RouterID& nextHop,
|
||||
std::deque< EncryptedFrame >& frames)
|
||||
{
|
||||
llarp::LogInfo("fowarding LRCM to ", nextHop);
|
||||
llarp::LogDebug("fowarding LRCM to ", nextHop);
|
||||
LR_CommitMessage* msg = new LR_CommitMessage;
|
||||
while(frames.size())
|
||||
{
|
||||
|
@ -226,7 +226,7 @@ namespace llarp
|
|||
if(itr->second->Expired(now))
|
||||
{
|
||||
TransitHop* path = itr->second;
|
||||
llarp::LogInfo("transit path expired ", path->info);
|
||||
llarp::LogDebug("transit path expired ", path->info);
|
||||
removePaths.insert(path);
|
||||
}
|
||||
++itr;
|
||||
|
@ -335,7 +335,7 @@ namespace llarp
|
|||
if(dlt > 5000 && m_LastLatencyTestID == 0)
|
||||
{
|
||||
llarp::routing::PathLatencyMessage latency;
|
||||
latency.T = rand();
|
||||
latency.T = llarp_randint();
|
||||
m_LastLatencyTestID = latency.T;
|
||||
m_LastLatencyTestTime = now;
|
||||
SendRoutingMessage(&latency, r);
|
||||
|
@ -432,7 +432,7 @@ namespace llarp
|
|||
m_BuiltHook = nullptr;
|
||||
|
||||
llarp::routing::PathLatencyMessage latency;
|
||||
latency.T = rand();
|
||||
latency.T = llarp_randint();
|
||||
m_LastLatencyTestID = latency.T;
|
||||
m_LastLatencyTestTime = llarp_time_now_ms();
|
||||
return SendRoutingMessage(&latency, r);
|
||||
|
|
|
@ -121,7 +121,7 @@ namespace llarp
|
|||
auto sz = established.size();
|
||||
if(sz)
|
||||
{
|
||||
return established[rand() % sz];
|
||||
return established[llarp_randint() % sz];
|
||||
}
|
||||
else
|
||||
return nullptr;
|
||||
|
|
|
@ -249,7 +249,7 @@ namespace llarp
|
|||
if(self->record.work
|
||||
&& self->record.work->IsValid(self->context->Crypto()->shorthash))
|
||||
{
|
||||
llarp::LogInfo("LRCM extended lifetime by ",
|
||||
llarp::LogDebug("LRCM extended lifetime by ",
|
||||
self->record.work->extendedLifetime, " seconds for ",
|
||||
info);
|
||||
self->hop->lifetime += 1000 * self->record.work->extendedLifetime;
|
||||
|
@ -257,13 +257,13 @@ namespace llarp
|
|||
else if(self->record.lifetime < 600 && self->record.lifetime > 10)
|
||||
{
|
||||
self->hop->lifetime = self->record.lifetime;
|
||||
llarp::LogInfo("LRCM short lifespan set to ", self->hop->lifetime,
|
||||
llarp::LogDebug("LRCM short lifespan set to ", self->hop->lifetime,
|
||||
" seconds for ", info);
|
||||
}
|
||||
|
||||
// TODO: check if we really want to accept it
|
||||
self->hop->started = llarp_time_now_ms();
|
||||
llarp::LogInfo("Accepted ", self->hop->info);
|
||||
llarp::LogDebug("Accepted ", self->hop->info);
|
||||
self->context->PutTransitHop(self->hop);
|
||||
|
||||
size_t sz = self->frames.front().size();
|
||||
|
@ -277,7 +277,7 @@ namespace llarp
|
|||
if(self->context->HopIsUs(info.upstream))
|
||||
{
|
||||
// we are the farthest hop
|
||||
llarp::LogInfo("We are the farthest hop for ", info);
|
||||
llarp::LogDebug("We are the farthest hop for ", info);
|
||||
// send a LRAM down the path
|
||||
llarp_logic_queue_job(self->context->Logic(), {self, &SendPathConfirm});
|
||||
}
|
||||
|
|
|
@ -716,13 +716,13 @@ llarp_router::Run()
|
|||
// initialize as service node
|
||||
InitServiceNode();
|
||||
// immediate connect all for service node
|
||||
uint64_t delay = rand() % 100;
|
||||
uint64_t delay = llarp_randint() % 100;
|
||||
llarp_logic_call_later(logic, {delay, this, &ConnectAll});
|
||||
}
|
||||
else
|
||||
{
|
||||
// delayed connect all for clients
|
||||
uint64_t delay = ((rand() % 10) * 500) + 1000;
|
||||
uint64_t delay = ((llarp_randint() % 10) * 500) + 500;
|
||||
llarp_logic_call_later(logic, {delay, this, &ConnectAll});
|
||||
}
|
||||
|
||||
|
|
|
@ -22,7 +22,7 @@ namespace llarp
|
|||
|
||||
if(llarp_buffer_eq(key, "i"))
|
||||
{
|
||||
return BEncodeReadSet(I, buf);
|
||||
return BEncodeReadList(I, buf);
|
||||
}
|
||||
|
||||
if(!BEncodeMaybeReadDictEntry("n", topic, read, key, buf))
|
||||
|
|
|
@ -73,7 +73,9 @@ namespace llarp
|
|||
" because we couldn't get any introductions");
|
||||
return;
|
||||
}
|
||||
m_IntroSet.I = I;
|
||||
m_IntroSet.I.clear();
|
||||
for(const auto& intro : I)
|
||||
m_IntroSet.I.push_back(intro);
|
||||
m_IntroSet.topic = m_Tag;
|
||||
if(!m_Identity.SignIntroSet(m_IntroSet, &m_Router->crypto))
|
||||
{
|
||||
|
@ -125,7 +127,7 @@ namespace llarp
|
|||
uint64_t
|
||||
Endpoint::GenTXID()
|
||||
{
|
||||
uint64_t txid = rand();
|
||||
uint64_t txid = llarp_randint();
|
||||
while(m_PendingLookups.find(txid) != m_PendingLookups.end())
|
||||
++txid;
|
||||
return txid;
|
||||
|
@ -172,7 +174,7 @@ namespace llarp
|
|||
{
|
||||
llarp::LogWarn("invalid lookup response for hidden service endpoint ",
|
||||
Name(), " txid=", msg->T);
|
||||
return false;
|
||||
return true;
|
||||
}
|
||||
bool result = itr->second->HandleResponse(remote);
|
||||
m_PendingLookups.erase(itr);
|
||||
|
@ -255,7 +257,7 @@ namespace llarp
|
|||
auto path = PickRandomEstablishedPath();
|
||||
if(path)
|
||||
{
|
||||
m_CurrentPublishTX = rand();
|
||||
m_CurrentPublishTX = llarp_randint();
|
||||
llarp::routing::DHTMessage msg;
|
||||
msg.M.push_back(new llarp::dht::PublishIntroMessage(
|
||||
m_IntroSet, m_CurrentPublishTX, 3));
|
||||
|
@ -371,7 +373,7 @@ namespace llarp
|
|||
{
|
||||
auto sendto =
|
||||
std::bind(&OutboundContext::SendMessage, this, std::placeholders::_1);
|
||||
ProtocolMessage* msg = new ProtocolMessage(protocol);
|
||||
ProtocolMessage* msg = new ProtocolMessage(protocol, sequenceNo);
|
||||
msg->PutBuffer(data);
|
||||
if(sequenceNo)
|
||||
{
|
||||
|
|
|
@ -4,7 +4,8 @@ namespace llarp
|
|||
{
|
||||
namespace service
|
||||
{
|
||||
ProtocolMessage::ProtocolMessage(ProtocolType t) : proto(t)
|
||||
ProtocolMessage::ProtocolMessage(ProtocolType t, uint64_t seqno)
|
||||
: proto(t), sequenceNum(seqno)
|
||||
{
|
||||
}
|
||||
|
||||
|
|
|
@ -36,7 +36,7 @@ TEST_F(HiddenServiceTest, TestGenerateIntroSet)
|
|||
intro.expiresAt = 1000;
|
||||
intro.router.Randomize();
|
||||
intro.pathID.Randomize();
|
||||
I.I.insert(intro);
|
||||
I.I.push_back(intro);
|
||||
}
|
||||
ASSERT_TRUE(ident.SignIntroSet(I, Crypto()));
|
||||
ASSERT_TRUE(I.VerifySignature(Crypto()));
|
||||
|
|
Loading…
Reference in a new issue