more meat

Makefile

@@ -1,11 +1,14 @@
 
-all: clean compile
+all: remove-build clean compile
+
+remove-build:
+	rm -f build.ninja
 
 clean: build.ninja
 	ninja clean
 
 build.ninja:
-	cmake -GNinja
+	cmake -GNinja -DCMAKE_BUILD_TYPE=Debug
 
 compile: build.ninja
 	ninja

daemon/main.c

@@ -114,7 +114,7 @@ int main(int argc, char *argv[]) {
         // ensure worker thread pool
         if (!llarp.worker) llarp.worker = llarp_init_threadpool(2);
         
-        llarp.router = llarp_init_router(llarp.worker);
+        llarp.router = llarp_init_router(llarp.worker, llarp.mainloop);
 
         if (llarp_configure_router(llarp.router, llarp.config)) {
           

include/llarp/dtls.h

@@ -12,7 +12,7 @@ struct llarp_dtls_args {
   char cert_file[255];
 };
 
-bool dtls_link_init(struct llarp_link* link, struct llarp_dtls_args args,
+void dtls_link_init(struct llarp_link* link, struct llarp_dtls_args args,
                     struct llarp_msg_muxer* muxer);
 
 

include/llarp/ev.h

@@ -23,6 +23,7 @@ struct llarp_udp_io {
   struct sockaddr_in6 *addr;
   void *user;
   void *impl;
+  struct llarp_ev_loop * parent;
   void (*recvfrom)(struct llarp_udp_io *, const struct sockaddr *, void *,
                    ssize_t);
 };

include/llarp/iwp.h

@@ -10,11 +10,13 @@ extern "C" {
 #endif
 
 struct iwp_configure_args {
+  struct llarp_alloc * mem;
+  struct llarp_ev_loop * ev;
   struct llarp_crypto* crypto;
   const char * keyfile;
 };
 
-bool iwp_link_init(struct llarp_link* link, struct iwp_configure_args args,
+void iwp_link_init(struct llarp_link* link, struct iwp_configure_args args,
                    struct llarp_msg_muxer* muxer);
 
 #ifdef __cplusplus

include/llarp/link.h

@@ -62,7 +62,7 @@ struct llarp_link_ev_listener {
 
 struct llarp_link {
   void *impl;
-  const char *(*name)(struct llarp_link *);
+  const char *(*name)(void);
   /*
   int (*register_listener)(struct llarp_link *, struct llarp_link_ev_listener);
   void (*deregister_listener)(struct llarp_link *, int);
@@ -73,6 +73,9 @@ struct llarp_link {
   void (*iter_sessions)(struct llarp_link *, struct llarp_link_session_iter*);
   void (*try_establish)(struct llarp_link *, struct llarp_link_establish_job,
                         struct llarp_link_session_listener);
+  
+  struct llarp_link_session * (*acquire_session_for_addr)(struct llarp_link *, const struct sockaddr *);
+  void (*mark_session_active)(struct llarp_link *, struct llarp_link_session *);
   void (*free_impl)(struct llarp_link *);
 };
 
@@ -86,12 +89,17 @@ struct llarp_link_session {
   /** send an entire message, splits up into smaller pieces and does encryption
    */
   ssize_t (*sendto)(struct llarp_link_session *, llarp_buffer_t);
+  /** receive raw data from link layer */
+  bool (*recv)(struct llarp_link_session *, const uint8_t *, size_t);
+  
   /** return true if this session is timed out */
   bool (*timeout)(struct llarp_link_session *);
   /** explicit close session */
   void (*close)(struct llarp_link_session *);
 };
 
+bool llarp_link_session_initialized(struct llarp_link_session * s);
+
 #ifdef __cplusplus
 }
 #endif

include/llarp/router.h

@@ -13,7 +13,7 @@ extern "C" {
 
 struct llarp_router;
 
-struct llarp_router *llarp_init_router(struct llarp_threadpool *worker);
+struct llarp_router *llarp_init_router(struct llarp_threadpool *worker, struct llarp_ev_loop * netloop);
 void llarp_free_router(struct llarp_router **router);
 
 bool llarp_configure_router(struct llarp_router *router,

llarp/dtls_link.c

@@ -14,9 +14,8 @@ static struct dtls_link * dtls_link_alloc(struct llarp_msg_muxer * muxer, char *
 }
 
 
-static const char * dtls_link_name(struct llarp_link * l)
+static const char * dtls_link_name()
 {
-  (void) l;
   return "dtls";
 }
 
@@ -94,7 +93,7 @@ static void dtls_link_free(struct llarp_link *l)
 
 
 
-bool dtls_link_init(struct llarp_link * link, struct llarp_dtls_args args, struct llarp_msg_muxer * muxer)
+void dtls_link_init(struct llarp_link * link, struct llarp_dtls_args args, struct llarp_msg_muxer * muxer)
 {
   link->impl = dtls_link_alloc(muxer, args.key_file, args.cert_file);
   link->name = dtls_link_name;
@@ -107,5 +106,4 @@ bool dtls_link_init(struct llarp_link * link, struct llarp_dtls_args args, struc
   link->iter_sessions = dtls_link_iter_sessions;
   link->try_establish = dtls_link_try_establish;
   link->free_impl = dtls_link_free;
-  return llarp_link_initialized(link);
 }

llarp/ev.cpp

@@ -4,7 +4,7 @@
 #ifdef __linux__
 #include "ev_epoll.hpp"
 #endif
-#ifdef __freebsd__
+#ifdef __FreeBSD__
 #include "ev_kqueue.hpp"
 #endif
 
@@ -13,7 +13,7 @@ void llarp_ev_loop_alloc(struct llarp_ev_loop **ev) {
 #ifdef __linux__
   *ev = new llarp_epoll_loop;
 #endif
-#ifdef __freebsd__
+#ifdef __FreeBSD__
   *ev = new llarp_kqueue_loop;
 #endif
 }
@@ -25,15 +25,16 @@ void llarp_ev_loop_free(struct llarp_ev_loop **ev) {
 
 int llarp_ev_loop_run(struct llarp_ev_loop *ev) { return ev->run(); }
 
-int llarp_ev_add_udp_listener(struct llarp_ev_loop *ev,
-                              struct llarp_udp_listener *listener) {
-  int ret = -1;
-  return ret;
+int llarp_ev_add_udp(struct llarp_ev_loop *ev,
+                              struct llarp_udp_io * udp) {
+  udp->parent = ev;
+  if(ev->udp_listen(udp)) return 0;
+  return -1;
 }
 
-int llarp_ev_close_udp_listener(struct llarp_udp_listener *listener) {
-  int ret = -1;
-  return ret;
+int llarp_ev_close_udp_close(struct llarp_udp_io * udp) {
+  if(udp->parent->udp_close(udp)) return 0;
+  return -1;
 }
 
 void llarp_ev_loop_stop(struct llarp_ev_loop *loop) { loop->stop(); }

llarp/ev.hpp

@@ -6,7 +6,6 @@
 
 namespace llarp {
 struct ev_io {
-  char buff[2048];
   int fd;
   ev_io(int f) : fd(f){};
   virtual int read(void* buf, size_t sz) = 0;
@@ -21,6 +20,8 @@ struct llarp_ev_loop {
   virtual void stop() = 0;
 
   virtual bool udp_listen(llarp_udp_io* l) = 0;
+  virtual bool udp_close(llarp_udp_io* l) = 0;
+  virtual bool close_ev(llarp::ev_io * ev) = 0;
 
   virtual ~llarp_ev_loop(){};
 };

llarp/ev_epoll.hpp

@@ -56,14 +56,15 @@ struct llarp_epoll_loop : public llarp_ev_loop {
     int result;
     char readbuf[2048];
     do {
-      result = epoll_wait(epollfd, events, 1024, 0);
+      result = epoll_wait(epollfd, events, 1024, -1);
       if (result > 0) {
         int idx = 0;
         while (idx < result) {
           llarp::ev_io* ev = static_cast<llarp::ev_io*>(events[idx].data.ptr);
           if (events[idx].events & EPOLLIN) {
             if (ev->read(readbuf, sizeof(readbuf)) == -1) {
-              epoll_ctl(epollfd, EPOLL_CTL_DEL, ev->fd, nullptr);
+              close_ev(ev);
+              delete ev;
             }
           }
           ++idx;
@@ -94,6 +95,11 @@ struct llarp_epoll_loop : public llarp_ev_loop {
     return fd;
   }
 
+  bool close_ev(llarp::ev_io * ev)
+  {
+    return epoll_ctl(epollfd, EPOLL_CTL_DEL, ev->fd, nullptr) != -1;
+  }
+
   bool udp_listen(llarp_udp_io* l) {
     int fd = udp_bind((sockaddr*)l->addr);
     if (fd == -1) return false;
@@ -105,9 +111,18 @@ struct llarp_epoll_loop : public llarp_ev_loop {
       delete listener;
       return false;
     }
+    l->impl = listener;
     return true;
   }
 
+  bool udp_close(llarp_udp_io* l)
+  {
+    auto listener = static_cast<llarp::udp_listener*>(l->impl);
+    if(!listener) return false;
+    return close_ev(listener);
+  }
+  
+
   void stop() {
     if (epollfd != -1) ::close(epollfd);
 

llarp/iwp_link.c

@@ -1,10 +1,40 @@
 #include <llarp/iwp.h>
+#include <llarp/ev.h>
 
+struct iwp_link
+{
+  struct llarp_alloc * alloc;
+  struct llarp_ev_loop *netloop;
+  const char * keyfile;
+  struct llarp_udp_io udp;
+};
 
 
-bool iwp_link_init(struct llarp_link * link, struct iwp_configure_args args,
-                   struct llarp_msg_muxer * muxer)
+static const char * iwp_link_name()
+{
+  return "IWP";
+}
+
+static bool iwp_link_configure(struct llarp_link * l, const char * ifname, int af, uint16_t port)
 {
+  struct iwp_link * link = l->impl;
+  link->udp.user = link;
+  return llarp_ev_add_udp(link->netloop, &link->udp) == 0;
+}
 
-  return llarp_link_initialized(link);
+static struct iwp_link * iwp_link_alloc(struct iwp_configure_args * args)
+{
+  struct iwp_link * l = args->mem->alloc(sizeof(struct iwp_link), 16);
+  l->alloc = args->mem;
+  l->netloop = args->ev;
+  l->keyfile = args->keyfile;
+  return l;
+}
+
+void iwp_link_init(struct llarp_link * link, struct iwp_configure_args args,
+                   struct llarp_msg_muxer * muxer)
+{
+  link->impl = iwp_link_alloc(&args);
+  link->name = iwp_link_name;
+  link->configure = iwp_link_configure;
 }

llarp/link.c

@@ -2,6 +2,11 @@
 
 bool llarp_link_initialized(struct llarp_link * link)
 {
-  return link && link->impl && link->name && link->configure && link->start_link && link->stop_link && link->iter_sessions && link->try_establish && link->free_impl;
+  return link && link->impl && link->name && link->configure && link->start_link && link->stop_link && link->iter_sessions && link->try_establish && link->acquire_session_for_addr && link->mark_session_active && link->free_impl;
+}
+  
+bool llarp_link_session_initialized(struct llarp_link_session * s)
+{
+  return s && s->impl && s->remote_rc && s->sendto && s->recv && s->timeout && s->close;
 }
   

llarp/router.cpp

@@ -42,8 +42,9 @@ void llarp_router::Close() {
 }
 extern "C" {
 
-struct llarp_router *llarp_init_router(struct llarp_threadpool *tp) {
+  struct llarp_router *llarp_init_router(struct llarp_threadpool *tp, struct llarp_ev_loop * netloop) {
   llarp_router *router = new llarp_router;
+  router->netloop = netloop;
   router->tp = tp;
   llarp_crypto_libsodium_init(&router->crypto);
   return router;
@@ -61,7 +62,7 @@ bool llarp_configure_router(struct llarp_router *router,
 void llarp_run_router(struct llarp_router *router, struct llarp_logic *logic) {
   router->ForEachLink([logic](llarp_link *link) {
     int result = link->start_link(link, logic);
-    if (result == -1) printf("link %s failed to start\n", link->name(link));
+    if (result == -1) printf("link %s failed to start\n", link->name());
   });
 }
 
@@ -85,10 +86,16 @@ void router_iter_config(llarp_config_iterator *iter, const char *section,
                         const char *key, const char *val) {
   llarp_router *self = static_cast<llarp_router *>(iter->user);
   if (StrEq(section, "links")) {
+    iwp_configure_args args = {
+      .mem = &llarp_g_mem,
+      .ev = self->netloop,
+      .crypto = &self->crypto,
+      .keyfile=self->transport_keyfile
+    };
     if (StrEq(val, "eth")) {
       struct llarp_link *link = llarp::Alloc<llarp_link>();
-      iwp_configure_args args = {.crypto = &self->crypto, .keyfile=self->transport_keyfile};
-      if(iwp_link_init(link, args, &self->muxer))
+      iwp_link_init(link, args, &self->muxer);
+      if(llarp_link_initialized(link))
       {
         if (link->configure(link, key, AF_PACKET, LLARP_ETH_PROTO))
         {
@@ -102,8 +109,8 @@ void router_iter_config(llarp_config_iterator *iter, const char *section,
     } else {
       struct llarp_link *link = llarp::Alloc<llarp_link>();
       uint16_t port = std::atoi(val);
-      iwp_configure_args args = {.crypto = &self->crypto, .keyfile=self->transport_keyfile};
-      if(iwp_link_init(link, args, &self->muxer))
+      iwp_link_init(link, args, &self->muxer);
+      if(llarp_link_initialized(link))
       {
         if (link->configure(link, key, AF_INET6, port))
         {

llarp/router.hpp

@@ -17,6 +17,7 @@ struct router_links {
 struct llarp_router {
   bool ready;
   const char * transport_keyfile = "transport.key";
+  struct llarp_ev_loop * netloop;
   struct llarp_threadpool *tp;
   llarp::router_links links;
   llarp_crypto crypto;