pull/1/head
Jeff Becker 6 years ago
parent 1fdfdc0244
commit 58247343bf
No known key found for this signature in database
GPG Key ID: F357B3B42F6F9B05

@ -4,11 +4,10 @@
extern "C" {
#endif
struct llarp_dht_context;
struct llarp_dht_context;
struct llarp_dht_context * llarp_dht_context_new();
void llarp_dht_context_free(struct llarp_dht_context * dht);
struct llarp_dht_context* llarp_dht_context_new();
void llarp_dht_context_free(struct llarp_dht_context* dht);
#ifdef __cplusplus
}

@ -20,7 +20,7 @@ int llarp_ev_loop_run(struct llarp_ev_loop *ev);
void llarp_ev_loop_stop(struct llarp_ev_loop *ev);
struct llarp_udp_listener {
struct sockaddr_in6 * addr;
struct sockaddr_in6 *addr;
void *user;
void *impl;
void (*recvfrom)(struct llarp_udp_listener *, const struct sockaddr *, char *,

@ -7,7 +7,6 @@
extern "C" {
#endif
#ifdef __cplusplus
}
#endif

@ -1,12 +1,12 @@
#ifndef LLARP_LINK_H_
#define LLARP_LINK_H_
#include <llarp/crypto.h>
#include <llarp/msg_handler.h>
#include <llarp/mem.h>
#include <llarp/msg_handler.h>
#include <llarp/obmd.h>
#include <stdint.h>
#include <stdbool.h>
#include <stdint.h>
#ifdef __cplusplus
extern "C" {
@ -14,18 +14,19 @@ extern "C" {
struct llarp_link;
struct llarp_link *llarp_link_alloc(struct llarp_msg_muxer * muxer);
struct llarp_link *llarp_link_alloc(struct llarp_msg_muxer *muxer);
void llarp_link_free(struct llarp_link **link);
bool llarp_link_configure_addr(struct llarp_link *link, const char *ifname, int af, uint16_t port);
bool llarp_link_configure_addr(struct llarp_link *link, const char *ifname,
int af, uint16_t port);
/** get link listener for events */
struct llarp_udp_listener *llarp_link_udp_listener(struct llarp_link *link);
void llarp_link_start(struct llarp_link * link);
void llarp_link_start(struct llarp_link *link);
struct llarp_link_queue *llarp_link_frame_queue(struct llarp_link *link);
struct llarp_link_queue * llarp_link_frame_queue(struct llarp_link*link);
void llarp_link_stop(struct llarp_link *link);
struct llarp_link_session;

@ -8,24 +8,22 @@
extern "C" {
#endif
/* foward declare */
struct llarp_msg_muxer;
struct llarp_link_session;
struct llarp_router;
struct llarp_frame_handler {
/* foward declare */
struct llarp_msg_muxer;
struct llarp_link_session;
struct llarp_router;
struct llarp_frame_handler {
/**
* participating paths
*/
struct llarp_path_context * paths;
struct llarp_path_context *paths;
/**
* parent muxer
*/
struct llarp_msg_muxer * parent;
struct llarp_msg_muxer *parent;
/**
handle fully formed frame from link session
*/
@ -41,9 +39,11 @@ struct llarp_msg_handler {
struct llarp_msg_muxer {
/** get a message handler for a link level message given msg.a */
struct llarp_frame_handler *(*link_handler_for)(struct llarp_router *, const char);
struct llarp_frame_handler *(*link_handler_for)(struct llarp_router *,
const char);
/** get a message handler for a routing layer message given msg.A */
struct llarp_msg_handler *(*routing_handler_for)(struct llarp_router *, const char);
struct llarp_msg_handler *(*routing_handler_for)(struct llarp_router *,
const char);
};
/** fill function pointers with default values */

@ -3,8 +3,8 @@
#include "str.hpp"
namespace llarp {
template<>
bool BEncode(const llarp_ai &a, llarp_buffer_t *buff) {
template <>
bool BEncode(const llarp_ai &a, llarp_buffer_t *buff) {
return bencodeDict(buff) && bencodeDict_Int(buff, "c", a.rank) &&
bencodeDict_Bytes(buff, "e", a.enc_key, sizeof(a.enc_key)) &&
bencodeDict_Bytes(buff, "d", a.dialect,
@ -15,7 +15,6 @@ namespace llarp {
}
} // namespace llarp
extern "C" {
bool llarp_ai_bencode(struct llarp_ai *ai, llarp_buffer_t *buff) {

@ -13,11 +13,9 @@ size_t llarp_buffer_size_left(llarp_buffer_t *buff) {
return buff->sz - diff;
}
bool llarp_buffer_write(llarp_buffer_t * buff, const void * data, size_t sz)
{
bool llarp_buffer_write(llarp_buffer_t *buff, const void *data, size_t sz) {
size_t left = llarp_buffer_size_left(buff);
if (sz > left)
{
if (sz > left) {
return false;
}
std::memcpy(buff->cur, data, sz);

@ -97,7 +97,7 @@ static void udp_close_cb(uv_handle_t *handle) {
l->closed();
delete l;
}
} // namespace llarp
namespace llarp {
@ -143,13 +143,14 @@ int llarp_ev_add_udp_listener(struct llarp_ev_loop *ev,
ret = uv_udp_init(ev->loop(), l->udp());
if (ret == 0) {
ret = uv_udp_bind(l->udp(), (sockaddr*) listener->addr, 0);
ret = uv_udp_bind(l->udp(), (sockaddr *)listener->addr, 0);
if (ret == 0) {
char addr [128] = {0};
char addr[128] = {0};
uv_ip6_name(listener->addr, addr, sizeof(addr));
printf("bound udp listener at %s port %d\n", addr, ntohs(listener->addr->sin6_port));
ret =
uv_udp_recv_start(l->udp(), &llarp::udp_alloc_cb, &llarp::udp_recv_cb);
printf("bound udp listener at %s port %d\n", addr,
ntohs(listener->addr->sin6_port));
ret = uv_udp_recv_start(l->udp(), &llarp::udp_alloc_cb,
&llarp::udp_recv_cb);
}
}
return ret;
@ -161,7 +162,7 @@ int llarp_ev_close_udp_listener(struct llarp_udp_listener *listener) {
llarp::udp_listener *l = static_cast<llarp::udp_listener *>(listener->impl);
if (l) {
if (!uv_udp_recv_stop(l->udp())) {
uv_close((uv_handle_t*)l->udp(), &llarp::udp_close_cb);
uv_close((uv_handle_t *)l->udp(), &llarp::udp_close_cb);
ret = 0;
}
}

@ -2,8 +2,8 @@
#include "bencode.hpp"
namespace llarp {
template<>
bool BEncode(const struct llarp_xi &xi, llarp_buffer_t *buff) {
template <>
bool BEncode(const struct llarp_xi &xi, llarp_buffer_t *buff) {
return bencodeDict(buff) &&
bencodeDict_Bytes(buff, "a", &xi.address, sizeof(xi.address)) &&
bencodeDict_Bytes(buff, "b", &xi.netmask, sizeof(xi.netmask)) &&
@ -11,7 +11,6 @@ namespace llarp {
}
} // namespace llarp
extern "C" {
bool llarp_xi_bencode(struct llarp_xi *xi, llarp_buffer_t *buff) {
return llarp::BEncode(*xi, buff);

@ -1,9 +1,9 @@
#include "link.hpp"
#include "net.hpp"
#include <llarp/time.h>
#include <cstring>
#include <arpa/inet.h>
#include <llarp/time.h>
#include <uv.h>
#include <cstring>
#include "net.hpp"
bool operator<(const sockaddr_in6 addr0, const sockaddr_in6 addr1) {
return memcmp(addr0.sin6_addr.s6_addr, addr1.sin6_addr.s6_addr,
@ -11,10 +11,7 @@ bool operator<(const sockaddr_in6 addr0, const sockaddr_in6 addr1) {
addr0.sin6_port < addr1.sin6_port;
}
namespace llarp
{
}
namespace llarp {}
extern "C" {
struct llarp_link *llarp_link_alloc() {
@ -30,21 +27,21 @@ struct llarp_udp_listener *llarp_link_udp_listener(struct llarp_link *l) {
return &l->listener;
}
bool llarp_link_configure_addr(struct llarp_link *link, const char *ifname, int af, uint16_t port) {
af = AF_INET6;
link->af = af;
if(llarp::net::GetIfAddr(ifname, link->af, (sockaddr*)&link->localaddr))
{
link->localaddr.sin6_family = af;
link->localaddr.sin6_port = htons(port);
link->listener.addr = &link->localaddr;
char buff[128] = {0};
uv_ip6_name(&link->localaddr, buff, sizeof(buff));
printf("link %s configured with address %s\n", ifname, buff);
return true;
}
return false;
bool llarp_link_configure_addr(struct llarp_link *link, const char *ifname,
int af, uint16_t port) {
af = AF_INET6;
link->af = af;
if (llarp::net::GetIfAddr(ifname, link->af, (sockaddr *)&link->localaddr)) {
link->localaddr.sin6_family = af;
link->localaddr.sin6_port = htons(port);
link->listener.addr = &link->localaddr;
char buff[128] = {0};
uv_ip6_name(&link->localaddr, buff, sizeof(buff));
printf("link %s configured with address %s\n", ifname, buff);
return true;
}
return false;
}
void llarp_link_stop(struct llarp_link *link) {
llarp_ev_close_udp_listener(&link->listener);

@ -2,18 +2,23 @@
#define LLARP_LINK_HANDLERS_HPP
#include <llarp/msg_handler.h>
namespace llarp
{
namespace frame
{
bool process_intro(struct llarp_frame_handler * h, struct llarp_link_session * s, llarp_buffer_t msg);
bool process_relay_commit(struct llarp_frame_handler * h, struct llarp_link_session * s, llarp_buffer_t msg);
bool process_relay_down(struct llarp_frame_handler * h, struct llarp_link_session * s, llarp_buffer_t msg);
bool process_relay_up(struct llarp_frame_handler * h, struct llarp_link_session * s, llarp_buffer_t msg);
bool process_relay_accept(struct llarp_frame_handler * h, struct llarp_link_session * s, llarp_buffer_t msg);
bool process_relay_status(struct llarp_frame_handler * h, struct llarp_link_session * s, llarp_buffer_t msg);
bool process_relay_exit(struct llarp_frame_handler * h, struct llarp_link_session * s, llarp_buffer_t msg);
}
}
namespace llarp {
namespace frame {
bool process_intro(struct llarp_frame_handler* h, struct llarp_link_session* s,
llarp_buffer_t msg);
bool process_relay_commit(struct llarp_frame_handler* h,
struct llarp_link_session* s, llarp_buffer_t msg);
bool process_relay_down(struct llarp_frame_handler* h,
struct llarp_link_session* s, llarp_buffer_t msg);
bool process_relay_up(struct llarp_frame_handler* h,
struct llarp_link_session* s, llarp_buffer_t msg);
bool process_relay_accept(struct llarp_frame_handler* h,
struct llarp_link_session* s, llarp_buffer_t msg);
bool process_relay_status(struct llarp_frame_handler* h,
struct llarp_link_session* s, llarp_buffer_t msg);
bool process_relay_exit(struct llarp_frame_handler* h,
struct llarp_link_session* s, llarp_buffer_t msg);
} // namespace frame
} // namespace llarp
#endif

@ -1,12 +1,10 @@
#include "link_handlers.hpp"
namespace llarp
{
namespace frame
{
bool process_intro(struct llarp_frame_handler * h, struct llarp_link_session * s, llarp_buffer_t msg)
{
return false;
}
}
namespace llarp {
namespace frame {
bool process_intro(struct llarp_frame_handler* h, struct llarp_link_session* s,
llarp_buffer_t msg) {
return false;
}
} // namespace frame
} // namespace llarp

@ -1,12 +1,10 @@
#include "link_handlers.hpp"
namespace llarp
{
namespace frame
{
bool process_relay_down(struct llarp_frame_handler * h, struct llarp_link_session * s, llarp_buffer_t msg)
{
return false;
}
}
namespace llarp {
namespace frame {
bool process_relay_down(struct llarp_frame_handler* h,
struct llarp_link_session* s, llarp_buffer_t msg) {
return false;
}
} // namespace frame
} // namespace llarp

@ -1,12 +1,10 @@
#include "link_handlers.hpp"
namespace llarp
{
namespace frame
{
bool process_relay_up(struct llarp_frame_handler * h, struct llarp_link_session * s, llarp_buffer_t msg)
{
return false;
}
}
namespace llarp {
namespace frame {
bool process_relay_up(struct llarp_frame_handler* h,
struct llarp_link_session* s, llarp_buffer_t msg) {
return false;
}
} // namespace frame
} // namespace llarp

@ -1,53 +1,46 @@
#include <llarp/msg_handler.h>
#include "router.hpp"
#include "link_handlers.hpp"
#include "router.hpp"
namespace llarp
{
struct llarp_frame_handler introduce_handler = {
namespace llarp {
struct llarp_frame_handler introduce_handler = {
.paths = nullptr,
.parent = nullptr,
.process = &llarp::frame::process_intro
};
.process = &llarp::frame::process_intro};
struct llarp_frame_handler lrdm_handler = {
struct llarp_frame_handler lrdm_handler = {
.paths = nullptr,
.parent = nullptr,
.process = &llarp::frame::process_relay_down
};
.process = &llarp::frame::process_relay_down};
struct llarp_frame_handler lrum_handler = {
struct llarp_frame_handler lrum_handler = {
.paths = nullptr,
.parent = nullptr,
.process = &llarp::frame::process_relay_up
};
.process = &llarp::frame::process_relay_up};
static struct llarp_frame_handler * find_frame_handler(struct llarp_router * r, const char ch)
{
struct llarp_frame_handler * handler = nullptr;
switch(ch)
{
static struct llarp_frame_handler* find_frame_handler(struct llarp_router* r,
const char ch) {
struct llarp_frame_handler* handler = nullptr;
switch (ch) {
case 'i':
handler = &introduce_handler;
}
if(handler)
{
handler->paths = r->paths;
handler->parent = &r->muxer;
}
return handler;
}
static struct llarp_msg_handler * find_msg_handler(struct llarp_router * r, const char ch)
{
return nullptr;
if (handler) {
handler->paths = r->paths;
handler->parent = &r->muxer;
}
return handler;
}
static struct llarp_msg_handler* find_msg_handler(struct llarp_router* r,
const char ch) {
return nullptr;
}
} // namespace llarp
extern "C" {
void llarp_msg_muxer_init(struct llarp_msg_muxer * muxer)
{
muxer->link_handler_for = &llarp::find_frame_handler;
muxer->routing_handler_for = &llarp::find_msg_handler;
}
void llarp_msg_muxer_init(struct llarp_msg_muxer* muxer) {
muxer->link_handler_for = &llarp::find_frame_handler;
muxer->routing_handler_for = &llarp::find_msg_handler;
}
}

@ -1,36 +1,30 @@
#include "net.hpp"
#include "str.hpp"
#include <ifaddrs.h>
#include <arpa/inet.h>
#include <ifaddrs.h>
namespace llarp {
namespace net {
bool GetIfAddr(const std::string& ifname, int af, sockaddr* addr) {
ifaddrs* ifa = nullptr;
bool found = false;
socklen_t sl = sizeof(sockaddr_in6);
if (af == AF_INET) sl = sizeof(sockaddr_in);
namespace llarp
{
namespace net
{
bool GetIfAddr(const std::string & ifname, int af, sockaddr * addr)
{
ifaddrs * ifa = nullptr;
bool found = false;
socklen_t sl = sizeof(sockaddr_in6);
if(af == AF_INET)
sl = sizeof(sockaddr_in);
if(getifaddrs(&ifa) == -1)
return false;
ifaddrs * i = ifa;
while(i)
{
if(llarp::StrEq(i->ifa_name, ifname.c_str()) && i->ifa_addr && i->ifa_addr->sa_family == af)
{
memcpy(addr, i->ifa_addr, sl);
found = true;
break;
}
i = i->ifa_next;
}
if(ifa) freeifaddrs(ifa);
return found;
if (getifaddrs(&ifa) == -1) return false;
ifaddrs* i = ifa;
while (i) {
if (llarp::StrEq(i->ifa_name, ifname.c_str()) && i->ifa_addr &&
i->ifa_addr->sa_family == af) {
memcpy(addr, i->ifa_addr, sl);
found = true;
break;
}
i = i->ifa_next;
}
if (ifa) freeifaddrs(ifa);
return found;
}
} // namespace net
} // namespace llarp

@ -1,14 +1,12 @@
#ifndef LLARP_NET_HPP
#define LLARP_NET_HPP
#include <string>
#include <sys/socket.h>
#include <string>
namespace llarp
{
namespace net
{
bool GetIfAddr(const std::string & ifname, int af, sockaddr * addr);
}
namespace llarp {
namespace net {
bool GetIfAddr(const std::string& ifname, int af, sockaddr* addr);
}
} // namespace llarp
#endif

@ -1,7 +1,7 @@
#include "router.hpp"
#include <llarp/ibfq.h>
#include <llarp/link.h>
#include <llarp/router.h>
#include <llarp/ibfq.h>
#include "router.hpp"
#include "link.hpp"
#include "str.hpp"
@ -10,19 +10,14 @@ void router_iter_config(llarp_config_iterator *iter, const char *section,
const char *key, const char *val);
} // namespace llarp
llarp_router::llarp_router()
{
llarp_msg_muxer_init(&muxer);
}
llarp_router::llarp_router() { llarp_msg_muxer_init(&muxer); }
llarp_router::~llarp_router() {}
llarp_router::~llarp_router()
{
}
void llarp_router::AddLink(struct llarp_link *link) {
llarp::router_links *head = &links;
while (head->next && head->link) head = head->next;
if (head->link)
head->next = new llarp::router_links{link, nullptr};
else
@ -30,14 +25,14 @@ void llarp_router::AddLink(struct llarp_link *link) {
}
void llarp_router::ForEachLink(std::function<void(llarp_link *)> visitor) {
llarp::router_links *cur = &links;
do {
if (cur->link) visitor(cur->link);
cur = cur->next;
} while (cur);
}
llarp::router_links *cur = &links;
do {
if (cur->link) visitor(cur->link);
cur = cur->next;
} while (cur);
}
void llarp_router::Close() { ForEachLink(llarp_link_stop); }
void llarp_router::Close() { ForEachLink(llarp_link_stop); }
extern "C" {

@ -1,43 +1,40 @@
#ifndef LLARP_ROUTER_HPP
#define LLARP_ROUTER_HPP
#include <llarp/router.h>
#include <llarp/link.h>
#include <llarp/router.h>
#include <functional>
#include "mem.hpp"
namespace llarp
{
struct router_links
{
llarp_link * link = nullptr;
router_links * next = nullptr;
};
} // namespace llarp
namespace llarp {
struct router_links {
llarp_link *link = nullptr;
router_links *next = nullptr;
};
struct llarp_router {
struct llarp_threadpool *tp;
llarp::router_links links;
llarp_crypto crypto;
llarp_msg_muxer muxer;
llarp_path_context * paths;
} // namespace llarp
static void *operator new(size_t sz) {
return llarp_g_mem.alloc(sz, llarp::alignment<llarp_router>());
}
struct llarp_router {
struct llarp_threadpool *tp;
llarp::router_links links;
llarp_crypto crypto;
llarp_msg_muxer muxer;
llarp_path_context *paths;
static void operator delete(void *ptr) { llarp_g_mem.free(ptr); }
static void *operator new(size_t sz) {
return llarp_g_mem.alloc(sz, llarp::alignment<llarp_router>());
}
llarp_router();
~llarp_router();
static void operator delete(void *ptr) { llarp_g_mem.free(ptr); }
void AddLink(struct llarp_link *link);
llarp_router();
~llarp_router();
void ForEachLink(std::function<void(llarp_link *)> visitor);
void AddLink(struct llarp_link *link);
void Close();
};
void ForEachLink(std::function<void(llarp_link *)> visitor);
void Close();
};
#endif

@ -17,8 +17,6 @@ bool BEncode(const llarp_rc &a, llarp_buffer_t *buff) {
}
} // namespace llarp
extern "C" {
bool llarp_rc_bencode(struct llarp_rc *rc, llarp_buffer_t *buff) {
return llarp::BEncode(*rc, buff);

Loading…
Cancel
Save