From 973f86c900214f51379c75016fac529e7d22e7d4 Mon Sep 17 00:00:00 2001 From: Jeff Becker Date: Fri, 31 Aug 2018 08:46:54 -0400 Subject: [PATCH] it compiles --- daemon/rcutil.cpp | 227 +++++--------------- include/llarp/address_info.hpp | 17 +- include/llarp/crypto.h | 2 +- include/llarp/exit_info.hpp | 8 +- llarp/address_info.cpp | 374 +++++++++++---------------------- llarp/context.cpp | 70 ------ llarp/dht/context.cpp | 52 ++++- llarp/exit_info.cpp | 194 ++--------------- llarp/nodedb.cpp | 6 + llarp/router.cpp | 8 +- llarp/router_contact.cpp | 105 +++++++++ 11 files changed, 377 insertions(+), 686 deletions(-) diff --git a/daemon/rcutil.cpp b/daemon/rcutil.cpp index ed107bd67..7497cf1bd 100644 --- a/daemon/rcutil.cpp +++ b/daemon/rcutil.cpp @@ -28,44 +28,20 @@ handle_signal(int sig) #define TESTNET 0 #endif -bool -printNode(struct llarp_nodedb_iter *iter) -{ - char ftmp[68] = {0}; - const char *hexname = - llarp::HexEncode< llarp::PubKey, decltype(ftmp) >(iter->rc->pubkey, ftmp); - - printf("[%zu]=>[%s]\n", iter->index, hexname); - return false; -} - -bool -aiLister(struct llarp_ai_list_iter *request, struct llarp_ai *addr) -{ - static size_t count = 0; - count++; - llarp::Addr a(*addr); - std::cout << "AddressInfo " << count << ": " << a << std::endl; - return true; -} - void -displayRC(llarp_rc *rc) +displayRC(const llarp::RouterContact &rc) { - char ftmp[68] = {0}; - const char *hexPubSigKey = - llarp::HexEncode< llarp::PubKey, decltype(ftmp) >(rc->pubkey, ftmp); - printf("PubSigKey [%s]\n", hexPubSigKey); - - struct llarp_ai_list_iter iter; - // iter.user - iter.visit = &aiLister; - llarp_ai_list_iterate(rc->addrs, &iter); + std::cout << rc.pubkey << std::endl; + for(const auto &addr : rc.addrs) + { + std::cout << "AddressInfo: " << addr << std::endl; + } } // fwd declr struct check_online_request; +/* void HandleDHTLocate(llarp_router_lookup_job *job) { @@ -88,6 +64,7 @@ HandleDHTLocate(llarp_router_lookup_job *job) // still need to exit this logic thread... llarp_main_abort(ctx); } +*/ int main(int argc, char *argv[]) @@ -135,6 +112,8 @@ main(int argc, char *argv[]) conffname = defaultConfName; char *rcfname = nullptr; char *nodesdir = nullptr; + + llarp::RouterContact rc; while(1) { static struct option long_options[] = { @@ -243,62 +222,54 @@ main(int argc, char *argv[]) { llarp_crypto crypto; llarp_crypto_libsodium_init(&crypto); - llarp_rc rc; - if(!llarp_rc_read(rcfname, &rc)) + if(!rc.Read(rcfname)) { std::cout << "failed to read " << rcfname << std::endl; return 1; } - if(!llarp_rc_verify_sig(&crypto, &rc)) + if(!rc.VerifySignature(&crypto)) { std::cout << rcfname << " has invalid signature" << std::endl; return 1; } - if(!llarp_rc_is_public_router(&rc)) + if(!rc.IsPublicRouter()) { std::cout << rcfname << " is not a public router"; - if(llarp_ai_list_size(rc.addrs) == 0) + if(rc.addrs.size() == 0) { std::cout << " because it has no public addresses"; } std::cout << std::endl; return 1; } - llarp::PubKey pubkey(rc.pubkey); - llarp::PubKey enckey(rc.enckey); - std::cout << "router identity and dht routing key: " << pubkey << std::endl; - std::cout << "router encryption key: " << enckey << std::endl; + std::cout << "router identity and dht routing key: " << rc.pubkey + << std::endl; + + std::cout << "router encryption key: " << rc.enckey << std::endl; if(rc.HasNick()) std::cout << "router nickname: " << rc.Nick() << std::endl; - std::cout << "advertised addresses: "; - llarp_ai_list_iter a_itr; - a_itr.user = nullptr; - a_itr.visit = [](llarp_ai_list_iter *, llarp_ai *addrInfo) -> bool { - llarp::Addr addr(*addrInfo); - std::cout << addr << " "; - return true; - }; - llarp_ai_list_iterate(rc.addrs, &a_itr); + std::cout << "advertised addresses: " << std::endl; + for(const auto &addr : rc.addrs) + { + std::cout << addr << std::endl; + } std::cout << std::endl; std::cout << "advertised exits: "; - - if(llarp_xi_list_size(rc.exits)) + if(rc.exits.size()) { - llarp_xi_list_iter e_itr; - e_itr.user = nullptr; - e_itr.visit = [](llarp_xi_list_iter *, llarp_xi *xi) -> bool { - std::cout << *xi << " "; - return true; - }; - llarp_xi_list_iterate(rc.exits, &e_itr); + for(const auto &exit : rc.exits) + { + std::cout << exit << std::endl; + } } else + { std::cout << "none"; - + } std::cout << std::endl; return 0; } @@ -310,7 +281,7 @@ main(int argc, char *argv[]) auto nodedb = llarp_nodedb_new(&crypto); llarp_nodedb_iter itr; itr.visit = [](llarp_nodedb_iter *i) -> bool { - std::cout << llarp::PubKey(i->rc->pubkey) << std::endl; + std::cout << i->rc->pubkey << std::endl; return true; }; if(llarp_nodedb_load_dir(nodedb, nodesdir) > 0) @@ -336,27 +307,26 @@ main(int argc, char *argv[]) return 1; } llarp_nodedb_set_dir(nodedb, nodesdir); - llarp_rc rc; - if(!llarp_rc_read(rcfname, &rc)) + if(!rc.Read(rcfname)) { std::cout << "failed to read " << rcfname << " " << strerror(errno) << std::endl; return 1; } - if(!llarp_rc_verify_sig(&crypto, &rc)) + if(!rc.VerifySignature(&crypto)) { std::cout << rcfname << " has invalid signature" << std::endl; return 1; } - if(!llarp_nodedb_put_rc(nodedb, &rc)) + if(!llarp_nodedb_put_rc(nodedb, rc)) { std::cout << "failed to store " << strerror(errno) << std::endl; return 1; } - std::cout << "imported " << llarp::PubKey(rc.pubkey) << std::endl; + std::cout << "imported " << rc.pubkey << std::endl; return 0; } @@ -376,20 +346,12 @@ main(int argc, char *argv[]) return 0; } signal(SIGINT, handle_signal); - - llarp_rc tmp; if(genMode) { printf("Creating [%s]\n", rcfname); - // Jeff wanted tmp to be stack created - // do we still need to zero it out? - llarp_rc_clear(&tmp); // if we zero it out then - // allocate fresh pointers that the bencoder can expect to be ready - tmp.addrs = llarp_ai_list_new(); - tmp.exits = llarp_xi_list_new(); // set updated timestamp - tmp.last_updated = llarp_time_now_ms(); + rc.last_updated = llarp_time_now_ms(); // load longterm identity llarp_crypto crypt; llarp_crypto_libsodium_init(&crypt); @@ -400,123 +362,32 @@ main(int argc, char *argv[]) llarp::SecretKey encryption; llarp_findOrCreateEncryption(&crypt, encryption_keyfile.string().c_str(), - &encryption); + encryption); - llarp_rc_set_pubenckey(&tmp, llarp::seckey_topublic(encryption)); + rc.enckey = llarp::seckey_topublic(encryption); // get identity public sig key fs::path ident_keyfile = "identity.key"; - byte_t identity[SECKEYSIZE]; + llarp::SecretKey identity; llarp_findOrCreateIdentity(&crypt, ident_keyfile.string().c_str(), identity); - llarp_rc_set_pubsigkey(&tmp, llarp::seckey_topublic(identity)); + rc.pubkey = llarp::seckey_topublic(identity); // this causes a segfault - llarp_rc_sign(&crypt, identity, &tmp); + if(!rc.Sign(&crypt, identity)) + { + std::cout << "failed to sign" << std::endl; + return 1; + } // set filename fs::path our_rc_file = rcfname; // write file - llarp_rc_write(&tmp, our_rc_file.string().c_str()); - - // release memory for tmp lists - llarp_rc_free(&tmp); - } - if(updMode) - { - printf("rcutil.cpp - Loading [%s]\n", rcfname); - llarp_rc rc; - llarp_rc_clear(&rc); - llarp_rc_read(rcfname, &rc); - - // set updated timestamp - rc.last_updated = llarp_time_now_ms(); - // load longterm identity - llarp_crypto crypt; - llarp_crypto_libsodium_init(&crypt); - fs::path ident_keyfile = "identity.key"; - byte_t identity[SECKEYSIZE]; - llarp_findOrCreateIdentity(&crypt, ident_keyfile.string().c_str(), - identity); - // get identity public key - const uint8_t *pubkey = llarp::seckey_topublic(identity); - llarp_rc_set_pubsigkey(&rc, pubkey); - llarp_rc_sign(&crypt, identity, &rc); - - // set filename - fs::path our_rc_file_out = "update_debug.rc"; - // write file - llarp_rc_write(&tmp, our_rc_file_out.string().c_str()); - } - if(listMode) - { - llarp_main_loadDatabase(ctx); - llarp_nodedb_iter iter; - iter.visit = printNode; - llarp_main_iterateDatabase(ctx, iter); - } - - if(exportMode) - { - llarp_main_loadDatabase(ctx); - // llarp::LogInfo("Looking for string: ", rcfname); - - llarp::PubKey binaryPK; - llarp::HexDecode(rcfname, binaryPK.data()); - - llarp::LogInfo("Looking for binary: ", binaryPK); - struct llarp_rc *rc = llarp_main_getDatabase(ctx, binaryPK.data()); - if(!rc) - { - llarp::LogError("Can't load RC from database"); - } - std::string filename(rcfname); - filename.append(".signed"); - llarp::LogInfo("Writing out: ", filename); - llarp_rc_write(rc, filename.c_str()); - } - if(locateMode) - { - llarp::LogInfo("Going online"); - llarp_main_setup(ctx); - - llarp::PubKey binaryPK; - llarp::HexDecode(rcfname, binaryPK.data()); - - llarp::LogInfo("Queueing job"); - llarp_router_lookup_job *job = new llarp_router_lookup_job; - job->iterative = true; - job->found = false; - job->hook = &HandleDHTLocate; - llarp_rc_new(&job->result); - memcpy(job->target, binaryPK, PUBKEYSIZE); // set job's target - - // create query DHT request - check_online_request *request = new check_online_request; - request->ptr = ctx; - request->job = job; - request->online = false; - request->nodes = 0; - request->first = false; - llarp_main_queryDHT(request); - - llarp::LogInfo("Processing"); - // run system and wait - llarp_main_run(ctx); - } - if(localMode) - { - llarp_rc *rc = llarp_main_getLocalRC(ctx); - displayRC(rc); + rc.Write(our_rc_file.string().c_str()); } - if(readMode) { - llarp_rc result; - llarp_rc_clear(&result); - llarp_rc_read(rcfname, &result); - displayRC(&result); + if(rc.Read(rcfname)) + displayRC(rc); } - // it's a unique_ptr, should clean up itself - // llarp_main_free(ctx); - return 1; // success + return 0; // success } diff --git a/include/llarp/address_info.hpp b/include/llarp/address_info.hpp index 3c8937688..4d89c74e9 100644 --- a/include/llarp/address_info.hpp +++ b/include/llarp/address_info.hpp @@ -3,6 +3,7 @@ #include #include #include +#include #include #include @@ -16,7 +17,7 @@ /// address information model namespace llarp { - struct AddressInfo + struct AddressInfo : public IBEncodeMessage { uint16_t rank; std::string dialect; @@ -24,11 +25,21 @@ namespace llarp struct in6_addr ip; uint16_t port; + ~AddressInfo(); + bool - BEncode(llarp_buffer_t *buf) const; + BEncode(llarp_buffer_t* buf) const; bool - BDecode(llarp_buffer_t *buf); + DecodeKey(llarp_buffer_t k, llarp_buffer_t* buf); + + friend std::ostream& + operator<<(std::ostream& out, const AddressInfo& a) + { + char tmp[128] = {0}; + inet_ntop(AF_INET6, &a.ip, tmp, sizeof(tmp)); + return out << tmp << "." << std::to_string(a.port); + } }; } // namespace llarp diff --git a/include/llarp/crypto.h b/include/llarp/crypto.h index dc14c4f3a..eb02f42cb 100644 --- a/include/llarp/crypto.h +++ b/include/llarp/crypto.h @@ -57,7 +57,7 @@ typedef bool (*llarp_hmac_func)(byte_t *, llarp_buffer_t, const byte_t *); /// S(sig, secretkey, body) typedef bool (*llarp_sign_func)(byte_t *, const byte_t *, llarp_buffer_t); -/// V(sig, body, secretkey) +/// V(sig, body, pubkey) typedef bool (*llarp_verify_func)(const byte_t *, llarp_buffer_t, const byte_t *); diff --git a/include/llarp/exit_info.hpp b/include/llarp/exit_info.hpp index 5cf6a11a3..0ef7172b7 100644 --- a/include/llarp/exit_info.hpp +++ b/include/llarp/exit_info.hpp @@ -1,6 +1,6 @@ #ifndef LLARP_XI_HPP #define LLARP_XI_HPP -#include +#include #include #include #include @@ -15,17 +15,19 @@ /// Exit info model namespace llarp { - struct ExitInfo + struct ExitInfo : public IBEncodeMessage { struct in6_addr address; struct in6_addr netmask; PubKey pubkey; + ~ExitInfo(); + bool BEncode(llarp_buffer_t *buf) const; bool - BDecode(llarp_buffer_t *buf); + DecodeKey(llarp_buffer_t k, llarp_buffer_t *buf); friend std::ostream & operator<<(std::ostream &out, const ExitInfo &xi) diff --git a/llarp/address_info.cpp b/llarp/address_info.cpp index b3e804a6e..469d5033e 100644 --- a/llarp/address_info.cpp +++ b/llarp/address_info.cpp @@ -1,4 +1,4 @@ -#include "address_info.hpp" +#include #ifndef _WIN32 #include #endif @@ -6,274 +6,138 @@ #include #include -static bool -llarp_ai_decode_key(struct dict_reader *r, llarp_buffer_t *key) +namespace llarp { - uint64_t i; - char tmp[128] = {0}; - - llarp_buffer_t strbuf; - llarp_ai *ai = static_cast< llarp_ai * >(r->user); - - // done - if(!key) - return true; - - // rank - if(llarp_buffer_eq(*key, "c")) + AddressInfo::~AddressInfo() { - if(!bencode_read_integer(r->buffer, &i)) - return false; - - if(i > 65536 || i <= 0) - return false; - - ai->rank = i; - return true; } - // dialect - if(llarp_buffer_eq(*key, "d")) + bool + AddressInfo::DecodeKey(llarp_buffer_t key, llarp_buffer_t *buf) { - if(!bencode_read_string(r->buffer, &strbuf)) - return false; - - if(strbuf.sz >= sizeof(ai->dialect)) - return false; - - memcpy(ai->dialect, strbuf.base, strbuf.sz); - ai->dialect[strbuf.sz] = 0; - return true; + uint64_t i; + char tmp[128] = {0}; + + llarp_buffer_t strbuf; + + // rank + if(llarp_buffer_eq(key, "c")) + { + if(!bencode_read_integer(buf, &i)) + return false; + + if(i > 65536 || i <= 0) + return false; + + rank = i; + return true; + } + + // dialect + if(llarp_buffer_eq(key, "d")) + { + if(!bencode_read_string(buf, &strbuf)) + return false; + if(strbuf.sz > sizeof(tmp)) + return false; + memcpy(tmp, strbuf.base, strbuf.sz); + tmp[strbuf.sz] = 0; + dialect = std::string(tmp); + return true; + } + + // encryption public key + if(llarp_buffer_eq(key, "e")) + { + if(!bencode_read_string(buf, &strbuf)) + return false; + + if(strbuf.sz != PUBKEYSIZE) + return false; + + pubkey = strbuf.base; + return true; + } + + // ip address + if(llarp_buffer_eq(key, "i")) + { + if(!bencode_read_string(buf, &strbuf)) + return false; + + if(strbuf.sz >= sizeof(tmp)) + return false; + + memcpy(tmp, strbuf.base, strbuf.sz); + tmp[strbuf.sz] = 0; + return inet_pton(AF_INET6, tmp, &ip.s6_addr[0]) == 1; + } + + // port + if(llarp_buffer_eq(key, "p")) + { + if(!bencode_read_integer(buf, &i)) + return false; + + if(i > 65536 || i <= 0) + return false; + + port = i; + return true; + } + + // version + if(llarp_buffer_eq(key, "v")) + { + if(!bencode_read_integer(buf, &i)) + return false; + return i == LLARP_PROTO_VERSION; + } + + // bad key + return false; } - // encryption public key - if(llarp_buffer_eq(*key, "e")) + bool + AddressInfo::BEncode(llarp_buffer_t *buff) const { - if(!bencode_read_string(r->buffer, &strbuf)) + char ipbuff[128] = {0}; + const char *ipstr; + if(!bencode_start_dict(buff)) return false; - - if(strbuf.sz != PUBKEYSIZE) + /* rank */ + if(!bencode_write_bytestring(buff, "c", 1)) return false; - - memcpy(ai->enc_key, strbuf.base, PUBKEYSIZE); - return true; - } - - // ip address - if(llarp_buffer_eq(*key, "i")) - { - if(!bencode_read_string(r->buffer, &strbuf)) + if(!bencode_write_uint64(buff, rank)) return false; - - if(strbuf.sz >= sizeof(tmp)) + /* dialect */ + if(!bencode_write_bytestring(buff, "d", 1)) return false; - - memcpy(tmp, strbuf.base, strbuf.sz); - tmp[strbuf.sz] = 0; - return inet_pton(AF_INET6, tmp, &ai->ip.s6_addr[0]) == 1; - } - - // port - if(llarp_buffer_eq(*key, "p")) - { - if(!bencode_read_integer(r->buffer, &i)) + if(!bencode_write_bytestring(buff, dialect.c_str(), dialect.size())) return false; - - if(i > 65536 || i <= 0) + /* encryption key */ + if(!bencode_write_bytestring(buff, "e", 1)) return false; - - ai->port = i; - return true; - } - - // version - if(llarp_buffer_eq(*key, "v")) - { - if(!bencode_read_integer(r->buffer, &i)) + if(!bencode_write_bytestring(buff, pubkey, PUBKEYSIZE)) + return false; + /** ip */ + ipstr = inet_ntop(AF_INET6, &ip, ipbuff, sizeof(ipbuff)); + if(!ipstr) + return false; + if(!bencode_write_bytestring(buff, "i", 1)) + return false; + if(!bencode_write_bytestring(buff, ipstr, strnlen(ipstr, sizeof(ipbuff)))) + return false; + /** port */ + if(!bencode_write_bytestring(buff, "p", 1)) + return false; + if(!bencode_write_uint64(buff, port)) return false; - return i == LLARP_PROTO_VERSION; - } - - // bad key - return false; -} - -static bool -llarp_ai_list_bdecode_item(struct list_reader *r, bool more) -{ - if(!more) - return true; - llarp_ai_list *l = static_cast< llarp_ai_list * >(r->user); - llarp_ai ai; - - if(!llarp_ai_bdecode(&ai, r->buffer)) - return false; - - llarp_ai_list_pushback(l, &ai); - return true; -} - -static bool -llarp_ai_list_iter_bencode(struct llarp_ai_list_iter *iter, struct llarp_ai *ai) -{ - return llarp_ai_bencode(ai, static_cast< llarp_buffer_t * >(iter->user)); -} - -bool -llarp_ai_bdecode(struct llarp_ai *ai, llarp_buffer_t *buff) -{ -#ifndef _MSC_VER - struct dict_reader reader = { - .buffer = nullptr, .user = ai, .on_key = &llarp_ai_decode_key}; -#else - struct dict_reader reader = {nullptr, ai, &llarp_ai_decode_key}; -#endif - return bencode_read_dict(buff, &reader); -} - -bool -llarp_ai_bencode(struct llarp_ai *ai, llarp_buffer_t *buff) -{ - char ipbuff[128] = {0}; - const char *ipstr; - if(!bencode_start_dict(buff)) - return false; - /* rank */ - if(!bencode_write_bytestring(buff, "c", 1)) - return false; - if(!bencode_write_uint64(buff, ai->rank)) - return false; - /* dialect */ - if(!bencode_write_bytestring(buff, "d", 1)) - return false; - if(!bencode_write_bytestring(buff, ai->dialect, - strnlen(ai->dialect, sizeof(ai->dialect)))) - return false; - /* encryption key */ - if(!bencode_write_bytestring(buff, "e", 1)) - return false; - if(!bencode_write_bytestring(buff, ai->enc_key, PUBKEYSIZE)) - return false; - /** ip */ - ipstr = inet_ntop(AF_INET6, &ai->ip, ipbuff, sizeof(ipbuff)); - if(!ipstr) - return false; - if(!bencode_write_bytestring(buff, "i", 1)) - return false; - if(!bencode_write_bytestring(buff, ipstr, strnlen(ipstr, sizeof(ipbuff)))) - return false; - /** port */ - if(!bencode_write_bytestring(buff, "p", 1)) - return false; - if(!bencode_write_uint64(buff, ai->port)) - return false; - - /** version */ - if(!bencode_write_version_entry(buff)) - return false; - /** end */ - return bencode_end(buff); -} - -bool -llarp_ai_list_bencode(struct llarp_ai_list *l, llarp_buffer_t *buff) -{ - if(!bencode_start_list(buff)) - return false; -#ifndef _MSC_VER - struct llarp_ai_list_iter ai_itr = { - .user = buff, .list = nullptr, .visit = &llarp_ai_list_iter_bencode}; -#else - struct llarp_ai_list_iter ai_itr = {buff, nullptr, - &llarp_ai_list_iter_bencode}; -#endif - llarp_ai_list_iterate(l, &ai_itr); - return bencode_end(buff); -} - -struct llarp_ai_list * -llarp_ai_list_new() -{ - return new llarp_ai_list(); -} - -void -llarp_ai_list_free(struct llarp_ai_list *l) -{ - if(l) - { - l->list.clear(); - delete l; - } -} - -void -llarp_ai_copy(struct llarp_ai *dst, struct llarp_ai *src) -{ - memcpy(dst, src, sizeof(struct llarp_ai)); -} - -void -llarp_ai_list_copy(struct llarp_ai_list *dst, struct llarp_ai_list *src) -{ - dst->list.clear(); - for(auto &itr : src->list) - dst->list.emplace_back(itr); -} - -void -llarp_ai_list_pushback(struct llarp_ai_list *l, struct llarp_ai *ai) -{ - l->list.push_back(*ai); -} - -size_t -llarp_ai_list_size(struct llarp_ai_list *l) -{ - if(l) - { - return l->list.size(); - } - return 0; -} - -void -llarp_ai_list_iterate(struct llarp_ai_list *l, struct llarp_ai_list_iter *itr) -{ - if(l) - { - itr->list = l; - for(auto &ai : l->list) - if(!itr->visit(itr, &ai)) - return; - } -} - -bool -llarp_ai_list_index(struct llarp_ai_list *l, ssize_t idx, struct llarp_ai *dst) -{ - // TODO: implement negative indexes - if(idx < 0) - return false; - - size_t i = idx; - if(l->list.size() > i) - { - llarp_ai_copy(dst, &l->list[i]); - return true; + /** version */ + if(!bencode_write_version_entry(buff)) + return false; + /** end */ + return bencode_end(buff); } - return false; -} - -bool -llarp_ai_list_bdecode(struct llarp_ai_list *l, llarp_buffer_t *buff) -{ -#ifndef _MSC_VER - struct list_reader r = { - .buffer = nullptr, .user = l, .on_item = &llarp_ai_list_bdecode_item}; -#else - struct list_reader r = {nullptr, l, &llarp_ai_list_bdecode_item}; -#endif - return bencode_read_list(buff, &r); -} +} // namespace llarp diff --git a/llarp/context.cpp b/llarp/context.cpp index de12a72c1..da0959bbd 100644 --- a/llarp/context.cpp +++ b/llarp/context.cpp @@ -329,76 +329,6 @@ extern "C" llarp_logic_stop_timer(ptr->ctx->router->logic); } - int - llarp_main_loadDatabase(struct llarp_main *ptr) - { - return ptr->ctx->LoadDatabase(); - } - - int - llarp_main_iterateDatabase(struct llarp_main *ptr, struct llarp_nodedb_iter i) - { - return ptr->ctx->IterateDatabase(i); - } - - bool - llarp_main_putDatabase(struct llarp_main *ptr, struct llarp_rc *rc) - { - return ptr->ctx->PutDatabase(rc); - } - - struct llarp_rc * - llarp_main_getDatabase(struct llarp_main *ptr, byte_t *pk) - { - return ptr->ctx->GetDatabase(pk); - } - - void - llarp_main_checkOnline(void *u, uint64_t orig, uint64_t left) - { - // llarp::LogInfo("checkOnline - check ", left); - if(left) - return; - struct check_online_request *request = - static_cast< struct check_online_request * >(u); - // llarp::LogDebug("checkOnline - running"); - // llarp::LogInfo("checkOnline - DHT nodes ", - // request->ptr->ctx->router->dht->impl.nodes->nodes.size()); - request->online = false; - request->nodes = request->ptr->ctx->router->dht->impl.nodes->nodes.size(); - if(request->ptr->ctx->router->dht->impl.nodes->nodes.size()) - { - // llarp::LogInfo("checkOnline - Going to say we're online"); - request->online = true; - } - request->hook(request); - // reschedue our self - llarp_main_queryDHT(request); - } - - void - llarp_main_queryDHT_online(struct check_online_request *request) - { - // Info("llarp_main_queryDHT_online: ", request->online ? "online" : - // "offline"); - if(request->online && !request->first) - { - request->first = true; - llarp::LogInfo("llarp_main_queryDHT_online - We're online"); - llarp::LogInfo("llarp_main_queryDHT_online - Querying DHT"); - } - } - - void - llarp_main_queryDHT(struct check_online_request *request) - { - // llarp::LogInfo("llarp_main_queryDHT - setting up timer"); - request->hook = &llarp_main_queryDHT_online; - llarp_logic_call_later(request->ptr->ctx->router->logic, - {1000, request, &llarp_main_checkOnline}); - // llarp_dht_lookup_router(ptr->ctx->router->dht, job); - } - void llarp_main_free(struct llarp_main *ptr) { diff --git a/llarp/dht/context.cpp b/llarp/dht/context.cpp index 47890de66..359b197cb 100644 --- a/llarp/dht/context.cpp +++ b/llarp/dht/context.cpp @@ -636,7 +636,7 @@ namespace llarp return parent->DHTSendTo(peer, msg); } - void + virtual void SendReply() { if(resultHandler) @@ -652,6 +652,56 @@ namespace llarp } }; + struct LocalRouterLookup : public RecursiveRouterLookup + { + PathID_t localPath; + + LocalRouterLookup(const PathID_t &path, uint64_t txid, + const RouterID &target, Context *ctx) + : RecursiveRouterLookup(TXOwner{ctx->OurKey(), txid}, target, ctx, + nullptr) + , localPath(path) + { + } + + void + SendReply() + { + auto path = + parent->router->paths.GetByUpstream(parent->OurKey(), localPath); + if(!path) + { + llarp::LogWarn( + "did not send reply for relayed dht request, no such local path " + "for pathid=", + localPath); + return; + } + routing::DHTMessage msg; + msg.M.push_back(new GotRouterMessage(parent->OurKey(), whoasked.txid, + valuesFound, true)); + if(!path->SendRoutingMessage(&msg, parent->router)) + { + llarp::LogWarn( + "failed to send routing message when informing result of dht " + "request, pathid=", + localPath); + } + } + }; + + void + Context::LookupRouterForPath(const RouterID &target, uint64_t txid, + const llarp::PathID_t &path, + const Key_t &askpeer) + + { + TXOwner peer(askpeer, ++ids); + auto tx = pendingRouterLookups.NewTX( + peer, target, new LocalRouterLookup(path, txid, target, this)); + tx->Start(peer); + } + void Context::LookupRouterRecursive(const RouterID &target, const Key_t &whoasked, uint64_t txid, diff --git a/llarp/exit_info.cpp b/llarp/exit_info.cpp index 9cb8f4638..99ab0c99e 100644 --- a/llarp/exit_info.cpp +++ b/llarp/exit_info.cpp @@ -3,197 +3,49 @@ #endif #include -#include +#include #include #include #include -struct llarp_xi_list +namespace llarp { - std::list< llarp_xi > list; -}; - -struct llarp_xi_list * -llarp_xi_list_new() -{ - return new llarp_xi_list; -} - -void -llarp_xi_list_free(struct llarp_xi_list *l) -{ - if(l) + ExitInfo::~ExitInfo() { - delete l; } -} - -static bool -llarp_xi_iter_bencode(struct llarp_xi_list_iter *iter, struct llarp_xi *xi) -{ - return llarp_xi_bencode(xi, static_cast< llarp_buffer_t * >(iter->user)); -} - -bool -llarp_xi_list_bencode(struct llarp_xi_list *l, llarp_buffer_t *buff) -{ - if(!bencode_start_list(buff)) - return false; - struct llarp_xi_list_iter xi_itr = {buff, nullptr, &llarp_xi_iter_bencode}; - llarp_xi_list_iterate(l, &xi_itr); - return bencode_end(buff); -} - -void -llarp_xi_list_iterate(struct llarp_xi_list *l, struct llarp_xi_list_iter *iter) -{ - iter->list = l; - for(auto &item : l->list) - if(!iter->visit(iter, &item)) - return; -} - -size_t -llarp_xi_list_size(const struct llarp_xi_list *l) -{ - if(l) - return l->list.size(); - return 0; -} - -bool -llarp_xi_bencode(const struct llarp_xi *xi, llarp_buffer_t *buff) -{ - char addr_buff[128] = {0}; - const char *addr; - if(!bencode_start_dict(buff)) - return false; - - /** address */ - addr = inet_ntop(AF_INET6, &xi->address, addr_buff, sizeof(addr_buff)); - if(!addr) - return false; - if(!bencode_write_bytestring(buff, "a", 1)) - return false; - if(!bencode_write_bytestring(buff, addr, strnlen(addr, sizeof(addr_buff)))) - return false; - - /** netmask */ - addr = inet_ntop(AF_INET6, &xi->netmask, addr_buff, sizeof(addr_buff)); - if(!addr) - return false; - if(!bencode_write_bytestring(buff, "b", 1)) - return false; - if(!bencode_write_bytestring(buff, addr, strnlen(addr, sizeof(addr_buff)))) - return false; - - /** public key */ - if(!bencode_write_bytestring(buff, "k", 1)) - return false; - if(!bencode_write_bytestring(buff, xi->pubkey, PUBKEYSIZE)) - return false; - - /** version */ - if(!bencode_write_version_entry(buff)) - return false; - - return bencode_end(buff); -} - -static bool -llarp_xi_decode_dict(struct dict_reader *r, llarp_buffer_t *key) -{ - if(!key) - return true; - - llarp_xi *xi = static_cast< llarp_xi * >(r->user); - llarp_buffer_t strbuf; - uint64_t v; - char tmp[128] = {0}; - // address - if(llarp_buffer_eq(*key, "a")) + bool + ExitInfo::BEncode(llarp_buffer_t* buf) const { - if(!bencode_read_string(r->buffer, &strbuf)) + char tmp[128] = {0}; + if(!bencode_start_dict(buf)) return false; - if(strbuf.sz >= sizeof(tmp)) - return false; - memcpy(tmp, strbuf.base, strbuf.sz); - return inet_pton(AF_INET6, tmp, xi->address.s6_addr) == 1; - } - if(llarp_buffer_eq(*key, "b")) - { - if(!bencode_read_string(r->buffer, &strbuf)) + if(!inet_ntop(AF_INET6, &address, tmp, sizeof(tmp))) return false; - if(strbuf.sz >= sizeof(tmp)) + if(!BEncodeWriteDictString("a", std::string(tmp), buf)) return false; - memcpy(tmp, strbuf.base, strbuf.sz); - return inet_pton(AF_INET6, tmp, xi->netmask.s6_addr) == 1; - } - if(llarp_buffer_eq(*key, "k")) - { - if(!bencode_read_string(r->buffer, &strbuf)) + if(!inet_ntop(AF_INET6, &netmask, tmp, sizeof(tmp))) return false; - if(strbuf.sz != PUBKEYSIZE) + if(!BEncodeWriteDictString("b", std::string(tmp), buf)) return false; - memcpy(xi->pubkey, strbuf.base, PUBKEYSIZE); - return true; - } - if(llarp_buffer_eq(*key, "v")) - { - if(!bencode_read_integer(r->buffer, &v)) + if(!BEncodeWriteDictEntry("k", pubkey, buf)) return false; - return v == LLARP_PROTO_VERSION; - } - - return false; -} - -bool -llarp_xi_bdecode(struct llarp_xi *xi, llarp_buffer_t *buf) -{ - struct dict_reader r = {buf, xi, &llarp_xi_decode_dict}; - return bencode_read_dict(buf, &r); -} -void -llarp_xi_list_pushback(struct llarp_xi_list *l, struct llarp_xi *xi) -{ - l->list.emplace_back(); - llarp_xi_copy(&l->list.back(), xi); -} - -void -llarp_xi_copy(struct llarp_xi *dst, struct llarp_xi *src) -{ - memcpy(dst, src, sizeof(struct llarp_xi)); -} + if(!BEncodeWriteDictInt("v", version, buf)) + return false; -static bool -llarp_xi_list_decode_item(struct list_reader *r, bool more) -{ - if(!more) - return true; + return bencode_end(buf); + } - llarp_xi_list *l = static_cast< llarp_xi_list * >(r->user); - l->list.emplace_back(); - return llarp_xi_bdecode(&l->list.back(), r->buffer); -} + bool + ExitInfo::DecodeKey(llarp_buffer_t k, llarp_buffer_t* buf) + { + bool read = false; -void -llarp_xi_list_copy(struct llarp_xi_list *dst, struct llarp_xi_list *src) -{ - dst->list.clear(); - for(auto &itr : src->list) - dst->list.emplace_back(itr); -} + return read; + } -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 bencode_read_list(buff, &r); -} +} // namespace llarp diff --git a/llarp/nodedb.cpp b/llarp/nodedb.cpp index 4384c2937..1e290f61a 100644 --- a/llarp/nodedb.cpp +++ b/llarp/nodedb.cpp @@ -276,6 +276,12 @@ llarp_nodedb_free(struct llarp_nodedb **n) } } +bool +llarp_nodedb_put_rc(struct llarp_nodedb *n, const llarp::RouterContact &rc) +{ + return n->Insert(rc); +} + bool llarp_nodedb_ensure_dir(const char *dir) { diff --git a/llarp/router.cpp b/llarp/router.cpp index 5495f56a7..3b2a6ecb5 100644 --- a/llarp/router.cpp +++ b/llarp/router.cpp @@ -906,7 +906,7 @@ llarp_findOrCreateIdentity(llarp_crypto *crypto, const char *fpath, // C++ ... bool llarp_findOrCreateEncryption(llarp_crypto *crypto, const char *fpath, - llarp::SecretKey *encryption) + llarp::SecretKey &encryption) { llarp::LogDebug("find or create ", fpath); fs::path path(fpath); @@ -914,18 +914,18 @@ llarp_findOrCreateEncryption(llarp_crypto *crypto, const char *fpath, if(!fs::exists(path, ec)) { llarp::LogInfo("generating new encryption key"); - crypto->encryption_keygen(*encryption); + crypto->encryption_keygen(encryption); std::ofstream f(path.string(), std::ios::binary); if(f.is_open()) { - f.write((char *)encryption, SECKEYSIZE); + f.write((char *)encryption.data(), SECKEYSIZE); } } std::ifstream f(path.string(), std::ios::binary); if(f.is_open()) { - f.read((char *)encryption, SECKEYSIZE); + f.read((char *)encryption.data(), SECKEYSIZE); return true; } llarp::LogInfo("failed to get encryption key"); diff --git a/llarp/router_contact.cpp b/llarp/router_contact.cpp index dc72c9cb4..d6fe269e0 100644 --- a/llarp/router_contact.cpp +++ b/llarp/router_contact.cpp @@ -6,6 +6,8 @@ #include "logger.hpp" #include "mem.hpp" +#include + namespace llarp { bool @@ -95,4 +97,107 @@ namespace llarp return read; } + bool + RouterContact::IsPublicRouter() const + { + return addrs.size() > 0; + } + + bool + RouterContact::HasNick() const + { + return nickname[0] != 0; + } + + void + RouterContact::SetNick(const std::string &nick) + { + nickname.Zero(); + memcpy(nickname, nick.c_str(), std::min(nick.size(), nickname.size())); + } + + std::string + RouterContact::Nick() const + { + const char *n = (const char *)nickname.data(); + return std::string(n, strnlen(n, nickname.size())); + } + + bool + RouterContact::Sign(llarp_crypto *crypto, const SecretKey &secretkey) + { + byte_t tmp[MAX_RC_SIZE] = {0}; + auto buf = llarp::StackBuffer< decltype(tmp) >(tmp); + signature.Zero(); + if(!BEncode(&buf)) + return false; + buf.sz = buf.cur - buf.base; + buf.cur = buf.base; + return crypto->sign(signature, secretkey, buf); + } + + bool + RouterContact::VerifySignature(llarp_crypto *crypto) const + { + RouterContact copy = *this; + copy.signature.Zero(); + byte_t tmp[MAX_RC_SIZE] = {0}; + auto buf = llarp::StackBuffer< decltype(tmp) >(tmp); + if(!copy.BEncode(&buf)) + return false; + buf.sz = buf.cur - buf.base; + buf.cur = buf.base; + return crypto->verify(signature, buf, pubkey); + } + + bool + RouterContact::Write(const char *fname) const + { + byte_t tmp[MAX_RC_SIZE] = {0}; + auto buf = llarp::StackBuffer< decltype(tmp) >(tmp); + if(!BEncode(&buf)) + return false; + buf.sz = buf.cur - buf.base; + buf.cur = buf.base; + { + std::ofstream f; + f.open(fname); + if(!f.is_open()) + return false; + f.write((char *)buf.base, buf.sz); + } + return true; + } + + bool + RouterContact::Read(const char *fname) + { + byte_t tmp[MAX_RC_SIZE] = {0}; + { + std::ifstream f; + f.open(fname); + if(!f.is_open()) + return false; + f.seekg(0, std::ios::end); + auto l = f.tellg(); + f.seekg(0, std::ios::beg); + f.read((char *)tmp, l); + } + auto buf = llarp::StackBuffer< decltype(tmp) >(tmp); + return BDecode(&buf); + } + + RouterContact & + RouterContact::operator=(const RouterContact &other) + { + addrs = other.addrs; + signature = other.signature; + exits = other.exits; + last_updated = other.last_updated; + enckey = other.enckey; + pubkey = other.pubkey; + nickname = other.nickname; + return *this; + } + } // namespace llarp