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

* logging refactor to be concise

Browse Source 
* don't inline bencode

* refactor initial start of dht code a bit
pull/1/head
Jeff Becker 6 years ago
parent 0724479eba
commit 9816fd65e9
No known key found for this signature in database
GPG Key ID: F357B3B42F6F9B05
21 changed files with 492 additions and 461 deletions
Show Stats Download Patch File Download Diff File

18
CMakeLists.txt
Unescape Escape View File

@ -1,13 +1,16 @@
cmake_minimum_required(VERSION 2.8.10)
set(WITH_SHARED OFF)
set(DEBUG_FLAGS "")
set(OPTIMIZE_FLAGS "-Os")
if(ASAN)
set(DEBUG_FLAGS "${DEBUG_FLAGS} -O1 -g -fsanitize=address -fno-omit-frame-pointer")
set(DEBUG_FLAGS "${DEBUG_FLAGS} -g -fsanitize=address -fno-omit-frame-pointer")
set(OPTIMIZE_FLAGS "-O0")
endif(ASAN)
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -std=c11 -Wall -fPIC ${DEBUG_FLAGS}")
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++17 -Wall -fPIC ${DEBUG_FLAGS}")
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -std=c11 -Wall ${DEBUG_FLAGS} ${OPTIMIZE_FLAGS}")
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++17 -Wall ${DEBUG_FLAGS} ${OPTIMIZE_FLAGS}")
if(NOT GIT_VERSION)
exec_program("git" ${CMAKE_CURRENT_SOURCE_DIR} ARGS "rev-parse --short HEAD" OUTPUT_VARIABLE GIT_VERSION)
@ -39,6 +42,7 @@ set(STATIC_LIB ${LIB}-static)
set(LIB_SRC
llarp/address_info.cpp
llarp/bencode.c
llarp/buffer.cpp
llarp/config.cpp
llarp/context.cpp
@ -69,12 +73,14 @@ set(LIB_SRC
include_directories(include)
add_library(${STATIC_LIB} STATIC ${LIB_SRC})
add_library(${SHARED_LIB} SHARED ${LIB_SRC})
if(WITH_SHARED)
add_library(${SHARED_LIB} SHARED ${LIB_SRC})
target_link_libraries(${SHARED_LIB} ${LIBS})
endif()
add_executable(${EXE} ${EXE_SRC})
target_link_libraries(${STATIC_LIB} ${LIBS})
target_link_libraries(${EXE} ${STATIC_LIB})
target_link_libraries(${SHARED_LIB} ${STATIC_LIB} ${LIBS})
add_executable(rcutil daemon/rcutil.cpp)
target_link_libraries(rcutil ${STATIC_LIB} ${LIBS})

51
include/llarp/aligned.hpp
Unescape Escape View File

@ -5,6 +5,7 @@
#include <sodium.h>
#include <iomanip>
#include <iostream>
#include <llarp/logger.hpp>
namespace llarp
{
@ -14,22 +15,24 @@ namespace llarp
{
AlignedBuffer()
{
Zero();
}
AlignedBuffer(const byte_t* data)
AlignedBuffer(const AlignedBuffer& other) : AlignedBuffer(other.data())
{
memcpy(buf.b, data, sz);
}
AlignedBuffer(const AlignedBuffer& other)
AlignedBuffer(const byte_t* data)
{
memcpy(buf.b, other.data(), sz);
for(size_t idx = 0; idx < sz; ++idx)
buf.b[idx] = data[idx];
}
AlignedBuffer&
operator=(const AlignedBuffer& other)
operator=(const byte_t* data)
{
memcpy(buf.b, other.data(), sz);
for(size_t idx = 0; idx < sz; ++idx)
buf.b[idx] = data[idx];
return *this;
}
@ -38,19 +41,16 @@ namespace llarp
return buf.b[idx];
}
std::string
Hex() const
friend std::ostream&
operator<<(std::ostream& out, const AlignedBuffer& self)
{
std::stringstream out;
std::string str;
size_t idx = 0;
out << std::hex << std::setw(2) << std::setfill('0');
while(idx < sz)
{
out << std::hex << std::setw(2) << std::setfill('0')
<< (int)buf.b[++idx];
out << (int)self.buf.b[idx++];
}
str = out.str();
return str;
return out << std::dec << std::setw(0) << std::setfill(' ');
}
bool
@ -87,37 +87,42 @@ namespace llarp
byte_t*
data()
{
return buf.b;
return &buf.b[0];
}
const byte_t*
data() const
{
return buf.b;
return &buf.b[0];
}
uint64_t*
data_l()
{
return &buf.l[0];
}
const uint64_t*
data_l() const
{
return buf.l;
return &buf.l[0];
}
uint64_t*
data_l()
operator const byte_t*() const
{
return buf.l;
return &buf.b[0];
}
operator const byte_t*() const
operator byte_t*()
{
return buf.b;
return &buf.b[0];
}
private:
union {
byte_t b[sz];
uint64_t l[sz / 8];
} buf = {0};
} buf;
};
}

173
include/llarp/bencode.h
Unescape Escape View File

@ -18,122 +18,41 @@
extern "C" {
#endif
static bool INLINE
bencode_write_bytestring(llarp_buffer_t* buff, const void* data, size_t sz)
{
if(!llarp_buffer_writef(buff, "%ld:", sz))
return false;
return llarp_buffer_write(buff, data, sz);
}
bool
bencode_write_bytestring(llarp_buffer_t* buff, const void* data, size_t sz);
static bool INLINE
bencode_write_int(llarp_buffer_t* buff, int i)
{
return llarp_buffer_writef(buff, "i%de", i);
}
bool
bencode_write_int(llarp_buffer_t* buff, int i);
static bool INLINE
bencode_write_uint16(llarp_buffer_t* buff, uint16_t i)
{
return llarp_buffer_writef(buff, "i%de", i);
}
bool
bencode_write_uint16(llarp_buffer_t* buff, uint16_t i);
static bool INLINE
bencode_write_int64(llarp_buffer_t* buff, int64_t i)
{
return llarp_buffer_writef(buff, "i%lde", i);
}
bool
bencode_write_int64(llarp_buffer_t* buff, int64_t i);
static bool INLINE
bencode_write_uint64(llarp_buffer_t* buff, uint64_t i)
{
return llarp_buffer_writef(buff, "i%lde", i);
}
bool
bencode_write_uint64(llarp_buffer_t* buff, uint64_t i);
static bool INLINE
bencode_write_sizeint(llarp_buffer_t* buff, size_t i)
{
return llarp_buffer_writef(buff, "i%lde", i);
}
bool
bencode_write_sizeint(llarp_buffer_t* buff, size_t i);
static bool INLINE
bencode_start_list(llarp_buffer_t* buff)
{
return llarp_buffer_write(buff, "l", 1);
}
bool
bencode_start_list(llarp_buffer_t* buff);
static bool INLINE
bencode_start_dict(llarp_buffer_t* buff)
{
return llarp_buffer_write(buff, "d", 1);
}
bool
bencode_start_dict(llarp_buffer_t* buff);
static bool INLINE
bencode_end(llarp_buffer_t* buff)
{
return llarp_buffer_write(buff, "e", 1);
}
bool
bencode_end(llarp_buffer_t* buff);
static bool INLINE
bencode_write_version_entry(llarp_buffer_t* buff)
{
return llarp_buffer_writef(buff, "1:vi%de", LLARP_PROTO_VERSION);
}
bool
bencode_write_version_entry(llarp_buffer_t* buff);
static bool INLINE
bdecode_read_integer(struct llarp_buffer_t* buffer, uint64_t* result)
{
size_t len;
if(*buffer->cur != 'i')
return false;
char numbuf[32];
buffer->cur++;
len =
llarp_buffer_read_until(buffer, 'e', (byte_t*)numbuf, sizeof(numbuf) - 1);
if(!len)
return false;
buffer->cur++;
numbuf[len] = 0;
*result = atol(numbuf);
return true;
}
static bool INLINE
bdecode_read_string(llarp_buffer_t* buffer, llarp_buffer_t* result)
{
size_t len, slen;
int num;
char numbuf[10];
len =
llarp_buffer_read_until(buffer, ':', (byte_t*)numbuf, sizeof(numbuf) - 1);
if(!len)
return false;
bool
bencode_read_integer(struct llarp_buffer_t* buffer, uint64_t* result);
numbuf[len] = 0;
num = atoi(numbuf);
if(num < 0)
return false;
slen = num;
buffer->cur++;
len = llarp_buffer_size_left(*buffer);
if(len < slen)
return false;
result->base = buffer->cur;
result->cur = buffer->cur;
result->sz = slen;
buffer->cur += slen;
return true;
}
bool
bencode_read_string(llarp_buffer_t* buffer, llarp_buffer_t* result);
struct dict_reader
{
@ -149,28 +68,8 @@ struct dict_reader
bool (*on_key)(struct dict_reader*, llarp_buffer_t*);
};
static bool INLINE
bdecode_read_dict(llarp_buffer_t* buff, struct dict_reader* r)
{
llarp_buffer_t strbuf; // temporary buffer for current element
r->buffer = buff; // set up dict_reader
if(*r->buffer->cur != 'd') // ensure is a dictionary
return false;
r->buffer->cur++;
while(llarp_buffer_size_left(*r->buffer) && *r->buffer->cur != 'e')
{
if(bdecode_read_string(r->buffer, &strbuf))
{
if(!r->on_key(r, &strbuf)) // check for early abort
return false;
}
}
if(*r->buffer->cur != 'e') // make sure we're at dictionary end
return false;
r->buffer->cur++;
return r->on_key(r, 0);
}
bool
bencode_read_dict(llarp_buffer_t* buff, struct dict_reader* r);
struct list_reader
{
@ -186,24 +85,8 @@ struct list_reader
bool (*on_item)(struct list_reader*, bool);
};
static bool INLINE
bdecode_read_list(llarp_buffer_t* buff, struct list_reader* r)
{
r->buffer = buff;
if(*r->buffer->cur != 'l') // ensure is a list
return false;
r->buffer->cur++;
while(llarp_buffer_size_left(*r->buffer) && *r->buffer->cur != 'e')
{
if(!r->on_item(r, true)) // check for early abort
return false;
}
if(*r->buffer->cur != 'e') // make sure we're at a list end
return false;
r->buffer->cur++;
return r->on_item(r, false);
}
bool
bencode_read_list(llarp_buffer_t* buff, struct list_reader* r);
#ifdef __cplusplus
}

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

@ -20,12 +20,10 @@ namespace llarp
struct ILinkMessage
{
/// who did this message come from (rc.k)
RouterID remote;
RouterID remote = {};
uint64_t version = 0;
ILinkMessage(const RouterID& from) : remote(from)
{
}
ILinkMessage(const RouterID& id);
virtual ~ILinkMessage(){};
@ -62,7 +60,6 @@ namespace llarp
private:
bool firstkey;
uint64_t proto;
llarp_router* router;
llarp_link_session* from;
ILinkMessage* msg = nullptr;

53
include/llarp/logger.hpp
Unescape Escape View File

@ -5,6 +5,7 @@
#include <iomanip>
#include <iostream>
#include <sstream>
#include <string>
namespace llarp
{
@ -30,14 +31,14 @@ namespace llarp
/** internal */
template < typename TArg >
void
LogAppend(std::stringstream& ss, TArg&& arg)
LogAppend(std::stringstream& ss, TArg&& arg) noexcept
{
ss << std::forward< TArg >(arg);
}
/** internal */
template < typename TArg, typename... TArgs >
void
LogAppend(std::stringstream& ss, TArg&& arg, TArgs&&... args)
LogAppend(std::stringstream& ss, TArg&& arg, TArgs&&... args) noexcept
{
LogAppend(ss, std::forward< TArg >(arg));
LogAppend(ss, std::forward< TArgs >(args)...);
@ -46,12 +47,12 @@ namespace llarp
/** internal */
template < typename... TArgs >
void
Log(LogLevel lvl, const char* tag, TArgs&&... args)
_Log(LogLevel lvl, const char* fname, TArgs&&... args) noexcept
{
if(_glog.minlevel > lvl)
return;
std::stringstream ss;
std::stringstream ss("");
switch(lvl)
{
case eLogDebug:
@ -71,41 +72,25 @@ namespace llarp
ss << "[ERR] ";
break;
}
auto t = std::time(nullptr);
auto now = std::localtime(&t);
auto t = std::time(nullptr);
auto now = std::localtime(&t);
std::string tag = fname;
auto pos = tag.rfind('/');
if(pos != std::string::npos)
tag = tag.substr(pos + 1);
while(tag.size() % 8)
tag += " ";
ss << std::put_time(now, "%F %T") << " " << tag << "\t";
LogAppend(ss, std::forward< TArgs >(args)...);
ss << (char)27 << "[0;0m";
_glog.out << ss.str() << std::endl;
}
template < typename... TArgs >
void
Debug(const char* tag, TArgs&&... args)
{
Log(eLogDebug, tag, std::forward< TArgs >(args)...);
}
template < typename... TArgs >
void
Info(const char* tag, TArgs&&... args)
{
Log(eLogInfo, tag, std::forward< TArgs >(args)...);
}
template < typename... TArgs >
void
Warn(const char* tag, TArgs&&... args)
{
Log(eLogWarn, tag, std::forward< TArgs >(args)...);
}
template < typename... TArgs >
void
Error(const char* tag, TArgs&&... args)
{
Log(eLogError, tag, std::forward< TArgs >(args)...);
}
}
#define Debug(x, ...) _Log(llarp::eLogDebug, __FILE__, x, ##__VA_ARGS__)
#define Info(x, ...) _Log(llarp::eLogInfo, __FILE__, x, ##__VA_ARGS__)
#define Warn(x, ...) _Log(llarp::eLogWarn, __FILE__, x, ##__VA_ARGS__)
#define Error(x, ...) _Log(llarp::eLogError, __FILE__, x, ##__VA_ARGS__)
#endif

16
llarp/address_info.cpp
Unescape Escape View File

@ -26,7 +26,7 @@ llarp_ai_decode_key(struct dict_reader *r, llarp_buffer_t *key)
// rank
if(llarp_buffer_eq(*key, "c"))
{
if(!bdecode_read_integer(r->buffer, &i))
if(!bencode_read_integer(r->buffer, &i))
return false;
if(i > 65536 || i <= 0)
@ -39,7 +39,7 @@ llarp_ai_decode_key(struct dict_reader *r, llarp_buffer_t *key)
// dialect
if(llarp_buffer_eq(*key, "d"))
{
if(!bdecode_read_string(r->buffer, &strbuf))
if(!bencode_read_string(r->buffer, &strbuf))
return false;
if(strbuf.sz >= sizeof(ai->dialect))
@ -53,7 +53,7 @@ llarp_ai_decode_key(struct dict_reader *r, llarp_buffer_t *key)
// encryption public key
if(llarp_buffer_eq(*key, "e"))
{
if(!bdecode_read_string(r->buffer, &strbuf))
if(!bencode_read_string(r->buffer, &strbuf))
return false;
if(strbuf.sz != sizeof(llarp_pubkey_t))
@ -66,7 +66,7 @@ llarp_ai_decode_key(struct dict_reader *r, llarp_buffer_t *key)
// ip address
if(llarp_buffer_eq(*key, "i"))
{
if(!bdecode_read_string(r->buffer, &strbuf))
if(!bencode_read_string(r->buffer, &strbuf))
return false;
if(strbuf.sz >= sizeof(tmp))
@ -80,7 +80,7 @@ llarp_ai_decode_key(struct dict_reader *r, llarp_buffer_t *key)
// port
if(llarp_buffer_eq(*key, "p"))
{
if(!bdecode_read_integer(r->buffer, &i))
if(!bencode_read_integer(r->buffer, &i))
return false;
if(i > 65536 || i <= 0)
@ -93,7 +93,7 @@ llarp_ai_decode_key(struct dict_reader *r, llarp_buffer_t *key)
// version
if(llarp_buffer_eq(*key, "v"))
{
if(!bdecode_read_integer(r->buffer, &i))
if(!bencode_read_integer(r->buffer, &i))
return false;
return i == LLARP_PROTO_VERSION;
}
@ -130,7 +130,7 @@ llarp_ai_bdecode(struct llarp_ai *ai, llarp_buffer_t *buff)
{
struct dict_reader reader = {
.buffer = nullptr, .user = ai, .on_key = &llarp_ai_decode_key};
return bdecode_read_dict(buff, &reader);
return bencode_read_dict(buff, &reader);
}
bool
@ -255,6 +255,6 @@ llarp_ai_list_bdecode(struct llarp_ai_list *l, llarp_buffer_t *buff)
{
struct list_reader r = {
.buffer = nullptr, .user = l, .on_item = &llarp_ai_list_bdecode_item};
return bdecode_read_list(buff, &r);
return bencode_read_list(buff, &r);
}
}

160
llarp/bencode.c
Unescape Escape View File

@ -0,0 +1,160 @@
#include <llarp/bencode.h>
bool
bencode_write_bytestring(llarp_buffer_t* buff, const void* data, size_t sz)
{
if(!llarp_buffer_writef(buff, "%ld:", sz))
return false;
return llarp_buffer_write(buff, data, sz);
}
bool
bencode_write_int(llarp_buffer_t* buff, int i)
{
return llarp_buffer_writef(buff, "i%de", i);
}
bool
bencode_write_uint16(llarp_buffer_t* buff, uint16_t i)
{
return llarp_buffer_writef(buff, "i%de", i);
}
bool
bencode_write_int64(llarp_buffer_t* buff, int64_t i)
{
return llarp_buffer_writef(buff, "i%lde", i);
}
bool
bencode_write_uint64(llarp_buffer_t* buff, uint64_t i)
{
return llarp_buffer_writef(buff, "i%lde", i);
}
bool
bencode_write_sizeint(llarp_buffer_t* buff, size_t i)
{
return llarp_buffer_writef(buff, "i%lde", i);
}
bool
bencode_start_list(llarp_buffer_t* buff)
{
return llarp_buffer_write(buff, "l", 1);
}
bool
bencode_start_dict(llarp_buffer_t* buff)
{
return llarp_buffer_write(buff, "d", 1);
}
bool
bencode_end(llarp_buffer_t* buff)
{
return llarp_buffer_write(buff, "e", 1);
}
bool
bencode_write_version_entry(llarp_buffer_t* buff)
{
return llarp_buffer_writef(buff, "1:vi%de", LLARP_PROTO_VERSION);
}
bool
bencode_read_integer(struct llarp_buffer_t* buffer, uint64_t* result)
{
size_t len;
if(*buffer->cur != 'i')
return false;
char numbuf[32];
buffer->cur++;
len =
llarp_buffer_read_until(buffer, 'e', (byte_t*)numbuf, sizeof(numbuf) - 1);
if(!len)
return false;
buffer->cur++;
numbuf[len] = 0;
*result = atol(numbuf);
return *result != -1;
}
bool
bencode_read_string(llarp_buffer_t* buffer, llarp_buffer_t* result)
{
size_t len, slen;
int num;
char numbuf[10];
len =
llarp_buffer_read_until(buffer, ':', (byte_t*)numbuf, sizeof(numbuf) - 1);
if(!len)
return false;
numbuf[len] = 0;
num = atoi(numbuf);
if(num < 0)
return false;
slen = num;
buffer->cur++;
len = llarp_buffer_size_left(*buffer);
if(len < slen)
return false;
result->base = buffer->cur;
result->cur = buffer->cur;
result->sz = slen;
buffer->cur += slen;
return true;
}
bool
bencode_read_dict(llarp_buffer_t* buff, struct dict_reader* r)
{
llarp_buffer_t strbuf; // temporary buffer for current element
r->buffer = buff; // set up dict_reader
if(*r->buffer->cur != 'd') // ensure is a dictionary
return false;
r->buffer->cur++;
while(llarp_buffer_size_left(*r->buffer) && *r->buffer->cur != 'e')
{
if(bencode_read_string(r->buffer, &strbuf))
{
if(!r->on_key(r, &strbuf)) // check for early abort
return false;
}
}
if(*r->buffer->cur != 'e') // make sure we're at dictionary end
return false;
r->buffer->cur++;
return r->on_key(r, 0);
}
bool
bencode_read_list(llarp_buffer_t* buff, struct list_reader* r)
{
r->buffer = buff;
if(*r->buffer->cur != 'l') // ensure is a list
return false;
r->buffer->cur++;
while(llarp_buffer_size_left(*r->buffer) && *r->buffer->cur != 'e')
{
if(!r->on_item(r, true)) // check for early abort
return false;
}
if(*r->buffer->cur != 'e') // make sure we're at a list end
return false;
r->buffer->cur++;
return r->on_item(r, false);
}

48
llarp/context.cpp
Unescape Escape View File

@ -12,7 +12,7 @@ namespace llarp
{
Context::Context(std::ostream &stdout) : out(stdout)
{
llarp::Info(__FILE__, LLARP_VERSION, " ", LLARP_RELEASE_MOTTO);
llarp::Info(LLARP_VERSION, " ", LLARP_RELEASE_MOTTO);
}
Context::~Context()
@ -28,18 +28,18 @@ namespace llarp
bool
Context::ReloadConfig()
{
llarp::Info(__FILE__, "loading config at ", configfile);
llarp::Info("loading config at ", configfile);
if(!llarp_load_config(config, configfile.c_str()))
{
llarp_config_iterator iter;
iter.user = this;
iter.visit = &iter_config;
llarp_config_iter(config, &iter);
llarp::Info(__FILE__, "config loaded");
llarp::Info("config loaded");
return true;
}
llarp_free_config(&config);
llarp::Error(__FILE__, "failed to load config file ", configfile);
llarp::Error("failed to load config file ", configfile);
return false;
}
@ -77,7 +77,7 @@ namespace llarp
int
Context::Run()
{
llarp::Info(__FILE__, "starting up");
llarp::Info("starting up");
llarp_ev_loop_alloc(&mainloop);
llarp_crypto_libsodium_init(&crypto);
nodedb = llarp_nodedb_new(&crypto);
@ -98,7 +98,7 @@ namespace llarp
{
if(custom_dht_func)
{
llarp::Info(__FILE__, "using custom dht function");
llarp::Info("using custom dht function");
llarp_dht_set_msg_handler(router->dht, custom_dht_func);
}
llarp_run_router(router, nodedb);
@ -117,18 +117,18 @@ namespace llarp
"llarp-netio");
#endif
}
llarp::Info(__FILE__, "Ready");
llarp::Info("Ready");
llarp_logic_mainloop(logic);
return 0;
}
else
llarp::Error(__FILE__, "failed to start router");
llarp::Error("failed to start router");
}
else
llarp::Error(__FILE__, "Failed to initialize nodedb");
llarp::Error("Failed to initialize nodedb");
}
else
llarp::Error(__FILE__, "no nodedb defined");
llarp::Error("no nodedb defined");
return 1;
}
@ -137,12 +137,12 @@ namespace llarp
{
if(sig == SIGINT)
{
llarp::Info(__FILE__, "SIGINT");
llarp::Info("SIGINT");
SigINT();
}
if(sig == SIGHUP)
{
llarp::Info(__FILE__, "SIGHUP");
llarp::Info("SIGHUP");
ReloadConfig();
}
}
@ -156,55 +156,55 @@ namespace llarp
void
Context::Close()
{
llarp::Debug(__FILE__, "stop router");
llarp::Debug("stop router");
if(router)
llarp_stop_router(router);
llarp::Debug(__FILE__, "stop workers");
llarp::Debug("stop workers");
if(worker)
llarp_threadpool_stop(worker);
llarp::Debug(__FILE__, "join workers");
llarp::Debug("join workers");
if(worker)
llarp_threadpool_join(worker);
llarp::Debug(__FILE__, "stop logic");
llarp::Debug("stop logic");
if(logic)
llarp_logic_stop(logic);
llarp::Debug(__FILE__, "free config");
llarp::Debug("free config");
llarp_free_config(&config);
llarp::Debug(__FILE__, "free workers");
llarp::Debug("free workers");
llarp_free_threadpool(&worker);
llarp::Debug(__FILE__, "free nodedb");
llarp::Debug("free nodedb");
llarp_nodedb_free(&nodedb);
for(size_t i = 0; i < netio_threads.size(); ++i)
{
if(mainloop)
{
llarp::Debug(__FILE__, "stopping event loop thread ", i);
llarp::Debug("stopping event loop thread ", i);
llarp_ev_loop_stop(mainloop);
}
}
llarp::Debug(__FILE__, "free router");
llarp::Debug("free router");
llarp_free_router(&router);
llarp::Debug(__FILE__, "free logic");
llarp::Debug("free logic");
llarp_free_logic(&logic);
for(auto &t : netio_threads)
{
llarp::Debug(__FILE__, "join netio thread");
llarp::Debug("join netio thread");
t.join();
}
netio_threads.clear();
llarp::Debug(__FILE__, "free mainloop");
llarp::Debug("free mainloop");
llarp_ev_loop_free(&mainloop);
}

14
llarp/dht.cpp
Unescape Escape View File

@ -19,7 +19,7 @@ namespace llarp
return llarp::dht::DecodeMesssageList(remote.data(), buf, msgs);
if(llarp_buffer_eq(key, "v"))
{
if(!bdecode_read_integer(buf, &version))
if(!bencode_read_integer(buf, &version))
return false;
return version == LLARP_PROTO_VERSION;
}
@ -115,7 +115,7 @@ namespace llarp
llarp_buffer_t strbuf;
if(llarp_buffer_eq(key, "K"))
{
if(!bdecode_read_string(val, &strbuf))
if(!bencode_read_string(val, &strbuf))
return false;
if(strbuf.sz != K.size())
return false;
@ -125,11 +125,11 @@ namespace llarp
}
if(llarp_buffer_eq(key, "T"))
{
return bdecode_read_integer(val, &txid);
return bencode_read_integer(val, &txid);
}
if(llarp_buffer_eq(key, "V"))
{
if(!bdecode_read_integer(val, &version))
if(!bencode_read_integer(val, &version))
return false;
return version == LLARP_PROTO_VERSION;
}
@ -167,7 +167,7 @@ namespace llarp
{
if(!llarp_buffer_eq(*key, "A"))
return false;
if(!bdecode_read_string(r->buffer, &strbuf))
if(!bencode_read_string(r->buffer, &strbuf))
return false;
// bad msg size?
if(strbuf.sz != 1)
@ -199,7 +199,7 @@ namespace llarp
dict_reader r;
r.user = &dec;
r.on_key = &MessageDecoder::on_key;
if(bdecode_read_dict(buf, &r))
if(bencode_read_dict(buf, &r))
return dec.msg;
else
{
@ -242,7 +242,7 @@ namespace llarp
list_reader r;
r.user = &dec;
r.on_item = &ListDecoder::on_item;
return bdecode_read_list(buf, &r);
return bencode_read_list(buf, &r);
}
Node::Node()

11
llarp/ev_epoll.hpp
Unescape Escape View File

@ -50,10 +50,11 @@ namespace llarp
default:
return -1;
}
llarp::Debug(__FILE__, "send ", sz, " bytes");
ssize_t sent = ::sendto(fd, data, sz, SOCK_NONBLOCK, to, slen);
if(sent == -1)
perror("sendto()");
{
llarp::Warn(strerror(errno));
}
return sent;
}
};
@ -116,7 +117,7 @@ struct llarp_epoll_loop : public llarp_ev_loop
// handle signalfd
if(events[idx].data.fd == pipefds[0])
{
llarp::Debug(__FILE__, "exiting epoll loop");
llarp::Debug("exiting epoll loop");
return 0;
}
llarp::ev_io* ev = static_cast< llarp::ev_io* >(events[idx].data.ptr);
@ -124,7 +125,7 @@ struct llarp_epoll_loop : public llarp_ev_loop
{
if(ev->read(readbuf, sizeof(readbuf)) == -1)
{
llarp::Debug(__FILE__, "close ev");
llarp::Debug("close ev");
close_ev(ev);
}
}
@ -173,7 +174,7 @@ struct llarp_epoll_loop : public llarp_ev_loop
}
}
llarp::Addr a(*addr);
llarp::Debug(__FILE__, "bind to ", a.to_string());
llarp::Debug("bind to ", a);
if(bind(fd, addr, slen) == -1)
{
perror("bind()");

12
llarp/exit_info.cpp
Unescape Escape View File

@ -106,7 +106,7 @@ llarp_xi_decode_dict(struct dict_reader *r, llarp_buffer_t *key)
// address
if(llarp_buffer_eq(*key, "a"))
{
if(!bdecode_read_string(r->buffer, &strbuf))
if(!bencode_read_string(r->buffer, &strbuf))
return false;
if(strbuf.sz >= sizeof(tmp))
return false;
@ -116,7 +116,7 @@ llarp_xi_decode_dict(struct dict_reader *r, llarp_buffer_t *key)
if(llarp_buffer_eq(*key, "b"))
{
if(!bdecode_read_string(r->buffer, &strbuf))
if(!bencode_read_string(r->buffer, &strbuf))
return false;
if(strbuf.sz >= sizeof(tmp))
return false;
@ -126,7 +126,7 @@ llarp_xi_decode_dict(struct dict_reader *r, llarp_buffer_t *key)
if(llarp_buffer_eq(*key, "k"))
{
if(!bdecode_read_string(r->buffer, &strbuf))
if(!bencode_read_string(r->buffer, &strbuf))
return false;
if(strbuf.sz != sizeof(llarp_pubkey_t))
return false;
@ -136,7 +136,7 @@ llarp_xi_decode_dict(struct dict_reader *r, llarp_buffer_t *key)
if(llarp_buffer_eq(*key, "v"))
{
if(!bdecode_read_integer(r->buffer, &v))
if(!bencode_read_integer(r->buffer, &v))
return false;
return v == LLARP_PROTO_VERSION;
}
@ -148,7 +148,7 @@ bool
llarp_xi_bdecode(struct llarp_xi *xi, llarp_buffer_t *buf)
{
struct dict_reader r = {buf, xi, &llarp_xi_decode_dict};
return bdecode_read_dict(buf, &r);
return bencode_read_dict(buf, &r);
}
void
@ -187,6 +187,6 @@ bool
llarp_xi_list_bdecode(struct llarp_xi_list *l, llarp_buffer_t *buff)
{
list_reader r = {buff, l, &llarp_xi_list_decode_item};
return bdecode_read_list(buff, &r);
return bencode_read_list(buff, &r);
}
}

163
llarp/iwp_link.cpp
Unescape Escape View File

@ -408,7 +408,7 @@ namespace iwp
void
push_ackfor(uint64_t id, uint32_t bitmask)
{
llarp::Debug(__FILE__, "ACK for msgid=", id, " mask=", bitmask);
llarp::Debug("ACK for msgid=", id, " mask=", bitmask);
sendqueue.emplace();
auto &buf = sendqueue.back();
// TODO: set flags to nonzero as needed
@ -424,8 +424,7 @@ namespace iwp
if(hdr.size() > sz)
{
// overflow
llarp::Warn(__FILE__, "invalid XMIT frame size ", hdr.size(), " > ",
sz);
llarp::Warn("invalid XMIT frame size ", hdr.size(), " > ", sz);
return false;
}
sz = hdr.size();
@ -438,7 +437,7 @@ namespace iwp
if(sz - bufsz < x.lastfrag())
{
// bad size of last fragment
llarp::Warn(__FILE__, "XMIT frag size missmatch ", sz - bufsz, " < ",
llarp::Warn("XMIT frag size missmatch ", sz - bufsz, " < ",
x.lastfrag());
return false;
}
@ -461,10 +460,10 @@ namespace iwp
return true;
}
else
llarp::Warn(__FILE__, "duplicate XMIT msgid=", x.msgid());
llarp::Warn("duplicate XMIT msgid=", x.msgid());
}
else
llarp::Warn(__FILE__, "LSB not set on flags");
llarp::Warn("LSB not set on flags");
return false;
}
@ -480,8 +479,7 @@ namespace iwp
if(hdr.size() > sz)
{
// overflow
llarp::Warn(__FILE__, "invalid FRAG frame size ", hdr.size(), " > ",
sz);
llarp::Warn("invalid FRAG frame size ", hdr.size(), " > ", sz);
return false;
}
sz = hdr.size();
@ -489,7 +487,7 @@ namespace iwp
if(sz <= 9)
{
// underflow
llarp::Warn(__FILE__, "invalid FRAG frame size ", sz, " <= 9");
llarp::Warn("invalid FRAG frame size ", sz, " <= 9");
return false;
}
@ -503,20 +501,18 @@ namespace iwp
auto itr = rx.find(msgid);
if(itr == rx.end())
{
llarp::Warn(__FILE__, "no such RX fragment, msgid=", msgid);
llarp::Warn("no such RX fragment, msgid=", msgid);
return false;
}
auto fragsize = itr->second.msginfo.fragsize();
if(fragsize != sz - 9)
{
llarp::Warn(__FILE__, "RX fragment size missmatch ", fragsize,
" != ", sz - 9);
llarp::Warn("RX fragment size missmatch ", fragsize, " != ", sz - 9);
return false;
}
if(!itr->second.put_frag(fragno, hdr.data() + 9))
{
llarp::Warn(__FILE__,
"inbound message does not have fragment msgid=", msgid,
llarp::Warn("inbound message does not have fragment msgid=", msgid,
" fragno=", (int)fragno);
return false;
}
@ -735,7 +731,7 @@ namespace iwp
{
// verify fail
// TODO: remove session?
llarp::Warn(__FILE__, "session start verify failed");
llarp::Warn("session start verify failed");
return;
}
self->send_LIM();
@ -744,7 +740,7 @@ namespace iwp
void
send_LIM()
{
llarp::Debug(__FILE__, "send LIM");
llarp::Debug("send LIM");
llarp_shorthash_t digest;
// 64 bytes overhead for link message
byte_t tmp[MAX_RC_SIZE + 64];
@ -766,7 +762,7 @@ namespace iwp
EnterState(eLIMSent);
}
else
llarp::Error(__FILE__, "LIM Encode failed");
llarp::Error("LIM Encode failed");
}
static void
@ -881,7 +877,7 @@ namespace iwp
if(introack->buf == nullptr)
{
// invalid signature
llarp::Error(__FILE__, "introack verify failed");
llarp::Error("introack verify failed");
return;
}
link->EnterState(eIntroAckRecv);
@ -930,10 +926,10 @@ namespace iwp
self->pump();
}
else
llarp::Error(__FILE__, "invalid frame");
llarp::Error("invalid frame");
}
else
llarp::Error(__FILE__, "decrypt frame fail");
llarp::Error("decrypt frame fail");
delete frame;
--self->frames;
@ -949,7 +945,7 @@ namespace iwp
iwp_call_async_frame_decrypt(iwp, frame);
}
else
llarp::Warn(__FILE__, "short packet of ", sz, " bytes");
llarp::Warn("short packet of ", sz, " bytes");
}
static void
@ -994,7 +990,7 @@ namespace iwp
session *self = static_cast< session * >(intro->user);
if(!intro->buf)
{
llarp::Error(__FILE__, "intro verify failed");
llarp::Error("intro verify failed");
delete self;
return;
}
@ -1037,7 +1033,7 @@ namespace iwp
if(sz >= sizeof(workbuf))
{
// too big?
llarp::Error(__FILE__, "intro too big");
llarp::Error("intro too big");
// TOOD: session destroy ?
return;
}
@ -1066,7 +1062,7 @@ namespace iwp
if(sz >= sizeof(workbuf))
{
// too big?
llarp::Error(__FILE__, "introack too big");
llarp::Error("introack too big");
// TOOD: session destroy ?
return;
}
@ -1091,17 +1087,17 @@ namespace iwp
session *link = static_cast< session * >(i->user);
if(i->buf)
{
llarp::Debug(__FILE__, "send intro");
llarp::Debug("send intro");
if(llarp_ev_udp_sendto(link->udp, link->addr, i->buf, i->sz) == -1)
{
llarp::Warn(__FILE__, "send intro failed");
llarp::Warn("send intro failed");
return;
}
link->EnterState(eIntroSent);
}
else
{
llarp::Warn(__FILE__, "failed to generate intro");
llarp::Warn("failed to generate intro");
}
}
@ -1167,6 +1163,12 @@ namespace iwp
LinkMap_t m_sessions;
mtx_t m_sessions_Mutex;
typedef std::unordered_map< llarp::pubkey, llarp::Addr, llarp::pubkeyhash >
SessionMap_t;
SessionMap_t m_Connected;
mtx_t m_Connected_Mutex;
llarp_seckey_t seckey;
server(llarp_router *r, llarp_crypto *c, llarp_logic *l,
@ -1183,6 +1185,55 @@ namespace iwp
llarp_async_iwp_free(iwp);
}
// set that src address has identity pubkey
void
MapAddr(const llarp::Addr &src, llarp::pubkey identity)
{
lock_t lock(m_Connected_Mutex);
m_Connected[identity] = src;
}
static bool
HasSessionToRouter(llarp_link *l, const byte_t *pubkey)
{
server *serv = static_cast< server * >(l->impl);
lock_t lock(serv->m_Connected_Mutex);
return serv->m_Connected.find(pubkey) != serv->m_Connected.end();
}
static bool
SendToSession(llarp_link *l, const byte_t *pubkey, llarp_buffer_t buf)
{
server *serv = static_cast< server * >(l->impl);
{
lock_t lock(serv->m_Connected_Mutex);
auto itr = serv->m_Connected.find(pubkey);
if(itr != serv->m_Connected.end())
{
lock_t innerlock(serv->m_sessions_Mutex);
auto inner_itr = serv->m_sessions.find(itr->second);
if(inner_itr != serv->m_sessions.end())
{
auto link = &inner_itr->second;
return link->sendto(link, buf);
}
}
}
return false;
}
void
UnmapAddr(const llarp::Addr &src)
{
lock_t lock(m_Connected_Mutex);
auto itr = std::find_if(
m_Connected.begin(), m_Connected.end(),
[src](const auto &item) -> bool { return src == item.second; });
if(itr == std::end(m_Connected))
return;
m_Connected.erase(itr);
}
session *
create_session(const llarp::Addr &src, const byte_t *seckey)
{
@ -1261,8 +1312,8 @@ namespace iwp
auto itr = m_sessions.find(addr);
if(itr != m_sessions.end())
{
llarp::Debug(__FILE__, "session with ", addr.to_string(),
" is stale, removing");
llarp::Debug("session with ", addr, " is stale, removing");
UnmapAddr(addr);
session *s = static_cast< session * >(itr->second.impl);
m_sessions.erase(itr);
if(s->keepalive_timer_id)
@ -1284,7 +1335,7 @@ namespace iwp
}
if(s->frames)
{
llarp::Warn(__FILE__, "session has ", s->frames,
llarp::Warn("session has ", s->frames,
" left but is idle, not deallocating session so we "
"leak but don't die");
}
@ -1304,7 +1355,7 @@ namespace iwp
bool
ensure_privkey()
{
llarp::Debug(__FILE__, "ensure transport private key at ", keyfile);
llarp::Debug("ensure transport private key at ", keyfile);
std::error_code ec;
if(!fs::exists(keyfile, ec))
{
@ -1324,7 +1375,7 @@ namespace iwp
keygen(const char *fname)
{
crypto->encryption_keygen(seckey);
llarp::Info(__FILE__, "new transport key generated");
llarp::Info("new transport key generated");
std::ofstream f(fname);
if(f.is_open())
{
@ -1394,16 +1445,20 @@ namespace iwp
{
alive();
session *impl = static_cast< session * >(parent->impl);
if(id == 0 && impl->state == session::eSessionStartSent)
if(id == 0)
{
// send our LIM
impl->send_LIM();
// send our LIM if we are an outbound session
if(impl->state == session::eSessionStartSent)
{
impl->send_LIM();
}
impl->serv->MapAddr(impl->addr, impl->remote_router.pubkey);
}
}
}
else
{
llarp::Warn(__FILE__, "failed to reassemble message ", id);
llarp::Warn("failed to reassemble message ", id);
}
rx.erase(id);
return success;
@ -1414,13 +1469,13 @@ namespace iwp
{
if(hdr.size() > sz)
{
llarp::Error(__FILE__, "invalid ACKS frame size ", hdr.size(), " > ", sz);
llarp::Error("invalid ACKS frame size ", hdr.size(), " > ", sz);
return false;
}
sz = hdr.size();
if(sz < 12)
{
llarp::Error(__FILE__, "invalid ACKS frame size ", sz, " < 12");
llarp::Error("invalid ACKS frame size ", sz, " < 12");
return false;
}
@ -1433,7 +1488,7 @@ namespace iwp
auto itr = tx.find(msgid);
if(itr == tx.end())
{
llarp::Error(__FILE__, "ACK for missing TX frame msgid=", msgid);
llarp::Error("ACK for missing TX frame msgid=", msgid);
return false;
}
@ -1443,7 +1498,7 @@ namespace iwp
if(itr->second->completed())
{
llarp::Debug(__FILE__, "message transmitted msgid=", msgid);
llarp::Debug("message transmitted msgid=", msgid);
delete itr->second;
tx.erase(itr);
session *impl = static_cast< session * >(parent->impl);
@ -1455,7 +1510,7 @@ namespace iwp
}
else
{
llarp::Debug(__FILE__, "message ", msgid, " retransmit fragments");
llarp::Debug("message ", msgid, " retransmit fragments");
itr->second->retransmit_frags(sendqueue);
}
@ -1498,12 +1553,11 @@ namespace iwp
if(!link->ensure_privkey())
{
llarp::Error(__FILE__, "failed to ensure private key");
llarp::Error("failed to ensure private key");
return false;
}
llarp::Debug(__FILE__, "configure link ifname=", ifname, " af=", af,
" port=", port);
llarp::Debug("configure link ifname=", ifname, " af=", af, " port=", port);
// bind
sockaddr_in ip4addr;
sockaddr_in6 ip6addr;
@ -1529,8 +1583,7 @@ namespace iwp
{
if(!llarp_getifaddr(ifname, af, addr))
{
llarp::Error(__FILE__, "failed to get address of network interface ",
ifname);
llarp::Error("failed to get address of network interface ", ifname);
return false;
}
}
@ -1552,10 +1605,10 @@ namespace iwp
link->netloop = netloop;
link->udp.recvfrom = &server::handle_recvfrom;
link->udp.user = link;
llarp::Debug(__FILE__, "bind IWP link to ", link->addr.to_string());
llarp::Debug("bind IWP link to ", link->addr);
if(llarp_ev_add_udp(link->netloop, &link->udp, link->addr) == -1)
{
llarp::Error(__FILE__, "failed to bind to ", link->addr.to_string());
llarp::Error("failed to bind to ", link->addr);
return false;
}
return true;
@ -1601,7 +1654,7 @@ namespace iwp
server *link = static_cast< server * >(l->impl);
{
llarp::Addr dst(job->ai);
llarp::Debug(__FILE__, "establish session to ", dst.to_string());
llarp::Debug("establish session to ", dst);
session *s = link->find_session(dst);
if(s == nullptr)
{
@ -1662,24 +1715,24 @@ namespace iwp
if(link->serv->has_session_to(link->addr))
{
// duplicate session
llarp::Warn(__FILE__, "duplicate session to ", link->addr.to_string());
llarp::Warn("duplicate session to ", link->addr);
delete link;
return;
}
link->serv->put_session(link->addr, link);
llarp::Debug(__FILE__, "send introack");
llarp::Debug("send introack");
if(llarp_ev_udp_sendto(link->udp, link->addr, i->buf, i->sz) == -1)
{
llarp::Warn(__FILE__, "sendto failed");
llarp::Warn("sendto failed");
return;
}
llarp::Debug(__FILE__, "sent");
llarp::Debug("sent");
link->EnterState(eIntroAckSent);
}
else
{
// failed to generate?
llarp::Warn(__FILE__, "failed to generate introack");
llarp::Warn("failed to generate introack");
delete link;
}
}
@ -1699,6 +1752,8 @@ iwp_link_init(struct llarp_link *link, struct llarp_iwp_args args)
link->stop_link = iwp::link_stop;
link->iter_sessions = iwp::link_iter_sessions;
link->try_establish = iwp::link_try_establish;
link->has_session_to = iwp::server::HasSessionToRouter;
link->sendto = iwp::server::SendToSession;
link->mark_session_active = iwp::link_mark_session_active;
link->free_impl = iwp::link_free;
}

4
llarp/link.c
Unescape Escape View File

@ -5,8 +5,8 @@ llarp_link_initialized(struct llarp_link* link)
{
return link && link->impl && link->name && link->get_our_address
&& link->configure && link->start_link && link->stop_link
&& link->iter_sessions && link->try_establish && link->mark_session_active
&& link->free_impl;
&& link->iter_sessions && link->try_establish && link->sendto
&& link->has_session_to && link->mark_session_active && link->free_impl;
}
bool

14
llarp/link_intro.cpp
Unescape Escape View File

@ -16,27 +16,29 @@ namespace llarp
{
if(!llarp_rc_bdecode(RC, buf))
{
llarp::Warn(__FILE__, "failed to decode RC");
llarp::Warn("failed to decode RC");
return false;
}
remote = RC->pubkey;
remote = (byte_t*)RC->pubkey;
llarp::Debug("decoded RC from ", remote);
return true;
}
else if(llarp_buffer_eq(key, "v"))
{
if(!bdecode_read_integer(buf, &version))
if(!bencode_read_integer(buf, &version))
return false;
if(version != LLARP_PROTO_VERSION)
{
llarp::Warn(__FILE__, "llarp protocol version missmatch ", version,
llarp::Warn("llarp protocol version missmatch ", version,
" != ", LLARP_PROTO_VERSION);
return false;
}
llarp::Debug("LIM version ", version);
return true;
}
else
{
llarp::Warn(__FILE__, "invalid LIM key: ", *key.cur);
llarp::Warn("invalid LIM key: ", *key.cur);
return false;
}
}
@ -69,7 +71,7 @@ namespace llarp
bool
LinkIntroMessage::HandleMessage(llarp_router* router) const
{
llarp::Info(__FILE__, "got LIM from ", remote.Hex());
llarp::Info("got LIM from ", remote);
return true;
}
}

66
llarp/link_message.cpp
Unescape Escape View File

@ -9,6 +9,11 @@
namespace llarp
{
ILinkMessage::ILinkMessage(const RouterID& id)
{
remote = id;
}
InboundMessageParser::InboundMessageParser(llarp_router* _router)
: router(_router)
{
@ -36,7 +41,7 @@ namespace llarp
return false;
}
if(!bdecode_read_string(r->buffer, &strbuf))
if(!bencode_read_string(r->buffer, &strbuf))
{
llarp::Warn(__FILE__, "could not read value of message type");
return false;
@ -58,6 +63,9 @@ namespace llarp
break;
case 'c':
handler->msg = new LR_CommitMessage(handler->GetCurrentFrom());
break;
default:
return false;
}
handler->firstkey = false;
return handler->msg != nullptr;
@ -69,60 +77,6 @@ namespace llarp
return handler->msg->DecodeKey(*key, r->buffer);
}
/*
bool
InboundMessageHandler::DecodeLIM(llarp_buffer_t key, llarp_buffer_t* buff)
{
if(llarp_buffer_eq(key, "r"))
{
if(!llarp_rc_bdecode(from->get_remote_router(from), buff))
{
llarp::Warn(__FILE__, "failed to decode RC");
return false;
}
return true;
}
else if(llarp_buffer_eq(key, "v"))
{
if(!bdecode_read_integer(buff, &proto))
return false;
if(proto != LLARP_PROTO_VERSION)
{
llarp::Warn(__FILE__, "llarp protocol version missmatch ", proto);
return false;
}
return true;
}
else
{
llarp::Warn(__FILE__, "invalid LIM key: ", *key.cur);
return false;
}
}
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;
}
bool
InboundMessageHandler::DecodeLRCM(llarp_buffer_t key, llarp_buffer_t* buf)
{
return false;
}
*/
RouterID
InboundMessageParser::GetCurrentFrom()
{
@ -148,6 +102,6 @@ namespace llarp
{
from = src;
firstkey = true;
return bdecode_read_dict(&buf, &reader);
return bencode_read_dict(&buf, &reader);
}
}

4
llarp/logic.cpp
Unescape Escape View File

@ -36,7 +36,7 @@ llarp_free_logic(struct llarp_logic** logic)
void
llarp_logic_stop(struct llarp_logic* logic)
{
llarp::Debug(__FILE__, "logic thread stop");
llarp::Debug("logic thread stop");
if(logic->thread)
{
llarp_threadpool_stop(logic->thread);
@ -44,7 +44,7 @@ llarp_logic_stop(struct llarp_logic* logic)
}
llarp_free_threadpool(&logic->thread);
llarp::Debug(__FILE__, "logic timer stop");
llarp::Debug("logic timer stop");
if(logic->timer)
llarp_timer_stop(logic->timer);
}

27
llarp/net.hpp
Unescape Escape View File

@ -2,7 +2,7 @@
#define LLARP_NET_HPP
#include <llarp/address_info.h>
#include <llarp/net.h>
#include <string>
#include <iostream>
#include "mem.hpp"
bool
@ -103,32 +103,31 @@ namespace llarp
}
}
std::string
to_string() const
friend std::ostream&
operator<<(std::ostream& out, const Addr& a)
{
std::string str;
char tmp[128];
char tmp[128] = {0};
socklen_t sz;
const void* ptr = nullptr;
if(af() == AF_INET6)
if(a.af() == AF_INET6)
{
str += "[";
out << "[";
sz = sizeof(sockaddr_in6);
ptr = addr6();
ptr = a.addr6();
}
else
{
sz = sizeof(sockaddr_in);
ptr = addr4();
ptr = a.addr4();
}
if(inet_ntop(af(), ptr, tmp, sz))
if(inet_ntop(a.af(), ptr, tmp, sz))
{
str += tmp;
if(af() == AF_INET6)
str += "]";
out << tmp;
if(a.af() == AF_INET6)
out << "]";
}
return str + ":" + std::to_string(port());
return out << ":" << a.port();
}
operator const sockaddr*() const

60
llarp/router.cpp
Unescape Escape View File

@ -63,9 +63,8 @@ llarp_router::SendToOrQueue(const llarp::RouterID &remote,
if(!llarp_nodedb_find_rc(nodedb, &rc, k))
{
llarp::Warn(__FILE__, "cannot find router ", remote.Hex(),
" locally so we are dropping ", msgs.size(),
" messages to them");
llarp::Warn("cannot find router ", remote, " locally so we are dropping ",
msgs.size(), " messages to them");
for(auto &msg : msgs)
delete msg;
@ -113,11 +112,11 @@ llarp_router::try_connect(fs::path rcfile)
f.read((char *)buf.base, sz);
}
else
llarp::Error(__FILE__, rcfile, " too large");
llarp::Error(rcfile, " too large");
}
else
{
llarp::Error(__FILE__, "failed to open ", rcfile);
llarp::Error("failed to open ", rcfile);
return;
}
}
@ -125,17 +124,17 @@ llarp_router::try_connect(fs::path rcfile)
{
if(llarp_rc_verify_sig(&crypto, &remote))
{
llarp::Debug(__FILE__, "verified signature");
llarp::Debug("verified signature");
if(!llarp_router_try_connect(this, &remote))
{
llarp::Warn(__FILE__, "session already made");
llarp::Warn("session already made");
}
}
else
llarp::Error(__FILE__, "failed to verify signature of RC");
llarp::Error("failed to verify signature of RC");
}
else
llarp::Error(__FILE__, "failed to decode RC");
llarp::Error("failed to decode RC");
llarp_rc_free(&remote);
}
@ -162,10 +161,10 @@ llarp_router::Ready()
bool
llarp_router::SaveRC()
{
llarp::Debug(__FILE__, "verify RC signature");
llarp::Debug("verify RC signature");
if(!llarp_rc_verify_sig(&crypto, &rc))
{
llarp::Error(__FILE__, "RC has bad signature not saving");
llarp::Error("RC has bad signature not saving");
return false;
}
@ -178,11 +177,11 @@ llarp_router::SaveRC()
if(f.is_open())
{
f.write((char *)buf.base, buf.cur - buf.base);
llarp::Info(__FILE__, "our RC saved to ", our_rc_file.c_str());
llarp::Info("our RC saved to ", our_rc_file.c_str());
return true;
}
}
llarp::Error(__FILE__, "did not save RC to ", our_rc_file.c_str());
llarp::Error("did not save RC to ", our_rc_file.c_str());
return false;
}
@ -204,7 +203,7 @@ llarp_router::connect_job_retry(void *user)
llarp_link_establish_job *job =
static_cast< llarp_link_establish_job * >(user);
llarp::Info(__FILE__, "trying to establish session again");
llarp::Info("trying to establish session again");
job->link->try_establish(job->link, job);
}
@ -225,7 +224,7 @@ llarp_router::on_verify_server_rc(llarp_async_verify_rc *job)
auto router = ctx->router;
if(!job->valid)
{
llarp::Warn(__FILE__, "invalid server RC");
llarp::Warn("invalid server RC");
if(ctx->establish_job)
{
// was an outbound attempt
@ -239,7 +238,7 @@ llarp_router::on_verify_server_rc(llarp_async_verify_rc *job)
return;
}
llarp::Debug(__FILE__, "rc verified");
llarp::Debug("rc verified");
// this was an outbound establish job
if(ctx->establish_job->session)
{
@ -277,8 +276,7 @@ llarp_router::FlushOutboundFor(const llarp::RouterID &remote)
if(!msg->BEncode(&buf))
{
llarp::Warn(__FILE__,
"failed to encode outbound message, buffer size left: ",
llarp::Warn("failed to encode outbound message, buffer size left: ",
llarp_buffer_size_left(buf));
delete msg;
itr->second.pop();
@ -298,8 +296,7 @@ llarp_router::FlushOutboundFor(const llarp::RouterID &remote)
}
if(!sent)
{
llarp::Warn(__FILE__, "failed to flush outboud message queue for ",
remote);
llarp::Warn("failed to flush outboud message queue for ", remote);
}
delete msg;
itr->second.pop();
@ -316,7 +313,7 @@ llarp_router::on_try_connect_result(llarp_link_establish_job *job)
router->async_verify_RC(session, false, job);
return;
}
llarp::Info(__FILE__, "session not established");
llarp::Info("session not established");
llarp_logic_queue_job(router->logic, {job, &llarp_router::connect_job_retry});
}
void
@ -362,29 +359,23 @@ llarp_router::Run()
return;
}
char tmp[68] = {0};
llarp::pubkey ourPubkey = pubkey();
llarp::pubkey ourPubkey;
memcpy(&ourPubkey[0], pubkey(), 32);
const char *us =
llarp::HexEncode< llarp::pubkey, decltype(tmp) >(ourPubkey, tmp);
llarp::Debug(__FILE__, "our router has public key ", us);
llarp::Info("our router has public key ", ourPubkey);
// start links
for(auto link : links)
{
int result = link->start_link(link, logic);
if(result == -1)
llarp::Warn(__FILE__, "Link ", link->name(), " failed to start");
llarp::Warn("Link ", link->name(), " failed to start");
else
llarp::Debug(__FILE__, "Link ", link->name(), " started");
llarp::Debug("Link ", link->name(), " started");
}
for(const auto &itr : connect)
{
llarp::Info(__FILE__, "connecting to node ", itr.first);
llarp::Info("connecting to node ", itr.first);
try_connect(itr.second);
}
}
@ -640,8 +631,7 @@ namespace llarp
{
// we failed to configure IPv6
// try IPv4
llarp::Info(__FILE__, "link ", key,
" failed to configure IPv6, trying IPv4");
llarp::Info("link ", key, " failed to configure IPv6, trying IPv4");
af = AF_INET;
if(link->configure(link, self->netloop, key, af, proto))
{
@ -653,7 +643,7 @@ namespace llarp
}
}
}
llarp::Error(__FILE__, "link ", key, " failed to configure");
llarp::Error("link ", key, " failed to configure");
}
else if(StrEq(section, "iwp-connect"))
{

12
llarp/router_contact.cpp
Unescape Escape View File

@ -47,7 +47,7 @@ llarp_rc_decode_dict(struct dict_reader *r, llarp_buffer_t *key)
if(llarp_buffer_eq(*key, "k"))
{
if(!bdecode_read_string(r->buffer, &strbuf))
if(!bencode_read_string(r->buffer, &strbuf))
return false;
if(strbuf.sz != sizeof(llarp_pubkey_t))
return false;
@ -57,14 +57,14 @@ llarp_rc_decode_dict(struct dict_reader *r, llarp_buffer_t *key)
if(llarp_buffer_eq(*key, "u"))
{
if(!bdecode_read_integer(r->buffer, &rc->last_updated))
if(!bencode_read_integer(r->buffer, &rc->last_updated))
return false;
return true;
}
if(llarp_buffer_eq(*key, "v"))
{
if(!bdecode_read_integer(r->buffer, &v))
if(!bencode_read_integer(r->buffer, &v))
return false;
return v == LLARP_PROTO_VERSION;
}
@ -81,7 +81,7 @@ llarp_rc_decode_dict(struct dict_reader *r, llarp_buffer_t *key)
if(llarp_buffer_eq(*key, "z"))
{
if(!bdecode_read_string(r->buffer, &strbuf))
if(!bencode_read_string(r->buffer, &strbuf))
return false;
if(strbuf.sz != sizeof(llarp_sig_t))
return false;
@ -96,7 +96,7 @@ void
llarp_rc_copy(struct llarp_rc *dst, struct llarp_rc *src)
{
llarp_rc_free(dst);
llarp_rc_clear(dst);
memcpy(dst->pubkey, src->pubkey, sizeof(llarp_pubkey_t));
memcpy(dst->signature, src->signature, sizeof(llarp_sig_t));
dst->last_updated = src->last_updated;
@ -117,7 +117,7 @@ bool
llarp_rc_bdecode(struct llarp_rc *rc, llarp_buffer_t *buff)
{
dict_reader r = {buff, rc, &llarp_rc_decode_dict};
return bdecode_read_dict(buff, &r);
return bencode_read_dict(buff, &r);
}
bool

36
llarp/threadpool.cpp
Unescape Escape View File

@ -3,7 +3,7 @@
#include <cstring>
#include "logger.hpp"
#if (__FreeBSD__)
#if(__FreeBSD__)
#include <pthread_np.h>
#endif
@ -16,8 +16,17 @@ namespace llarp
stop = false;
while(workers--)
{
threads.emplace_back([this] {
threads.emplace_back([this, name] {
if(name)
{
#if(__APPLE__ && __MACH__)
pthread_setname_np(name);
#elif(__FreeBSD__)
pthread_set_name_np(pthread_self(), name);
#else
pthread_setname_np(pthread_self(), name);
#endif
}
for(;;)
{
llarp_thread_job job;
@ -35,21 +44,6 @@ namespace llarp
}
});
}
if(name)
{
#if (__APPLE__ && __MACH__)
//for(auto &t : threads)
// FIXME: send signal to thread
// name has to be set from inside the thread
//pthread_setname_np(name);
#elif (__FreeBSD__)
for(auto &t : threads)
pthread_set_name_np(t.native_handle(), name);
#else
for(auto &t : threads)
pthread_setname_np(t.native_handle(), name);
#endif
}
}
void
@ -112,7 +106,7 @@ llarp_init_threadpool(int workers, const char *name)
void
llarp_threadpool_join(struct llarp_threadpool *pool)
{
llarp::Debug(__FILE__, "threadpool join");
llarp::Debug("threadpool join");
pool->impl.Join();
}
@ -124,7 +118,7 @@ llarp_threadpool_start(struct llarp_threadpool *pool)
void
llarp_threadpool_stop(struct llarp_threadpool *pool)
{
llarp::Debug(__FILE__, "threadpool stop");
llarp::Debug("threadpool stop");
pool->impl.Stop();
}
@ -132,7 +126,7 @@ void
llarp_threadpool_wait(struct llarp_threadpool *pool)
{
std::mutex mtx;
llarp::Debug(__FILE__, "threadpool wait");
llarp::Debug("threadpool wait");
{
std::unique_lock< std::mutex > lock(mtx);
pool->impl.done.wait(lock);

4
llarp/timer.cpp
Unescape Escape View File

@ -175,10 +175,10 @@ llarp_timer_stop(struct llarp_timer_context* t)
{
// destroy all timers
// don't call callbacks on timers
llarp::Debug(__FILE__, "clear timers");
llarp::Debug("clear timers");
t->timers.clear();
t->stop();
llarp::Debug(__FILE__, "stop timers");
llarp::Debug("stop timers");
t->ticker.notify_all();
}

Write Preview
Loading…
Cancel
Save