more

daemon.ini

@@ -1,14 +1,14 @@
 [router]
 threads=8
-contact-file=router-contact.signed
+contact-file=rc.signed
 
 [netdb]
 dir=./tmp-nodes
 
 [iwp-connect]
-named-node0=remote-rc.signed
+self=rc.signed
 #named-node1=/path/to/routercontact1
 
 [iwp-links]
-tun0=1090
+lo=1090
 #lo=eth

include/llarp/ev.h

@@ -26,7 +26,6 @@ llarp_ev_loop_stop(struct llarp_ev_loop *ev);
 
 struct llarp_udp_io
 {
-  struct sockaddr addr;
   void *user;
   void *impl;
   struct llarp_ev_loop *parent;
@@ -35,7 +34,8 @@ struct llarp_udp_io
 };
 
 int
-llarp_ev_add_udp(struct llarp_ev_loop *ev, struct llarp_udp_io *udp);
+llarp_ev_add_udp(struct llarp_ev_loop *ev, struct llarp_udp_io *udp,
+                 const struct sockaddr *src);
 
 int
 llarp_ev_udp_sendto(struct llarp_udp_io *udp, const struct sockaddr *to,

include/llarp/link.h

@@ -91,7 +91,6 @@ llarp_link_initialized(struct llarp_link *link);
 
 struct llarp_link_session
 {
-  struct sockaddr addr;
   void *impl;
   /** send an entire message, splits up into smaller pieces and does encryption
    */

llarp/crypto_async.cpp

@@ -47,7 +47,6 @@ namespace iwp
     llarp_crypto *crypto = intro->iwp->crypto;
     byte_t tmp[64];
     // S = TKE(a.k, b.k, n)
-    printf("dh\n");
     crypto->transport_dh_client(sharedkey, intro->remote_pubkey,
                                 intro->secretkey, intro->nonce);
     llarp_buffer_t buf;
@@ -57,18 +56,14 @@ namespace iwp
     // e_k = HS(b.k + n)
     memcpy(tmp, intro->remote_pubkey, 32);
     memcpy(tmp + 32, intro->nonce, 32);
-    printf("shorthash\n");
     crypto->shorthash(e_k, buf);
-    printf("copy\n");
     // e = SE(a.k, e_k, n[0:24])
     memcpy(intro->buf + 32, llarp_seckey_topublic(intro->secretkey), 32);
     buf.base = intro->buf + 32;
     buf.sz   = 32;
-    printf("chacha\n");
     crypto->xchacha20(buf, e_k, n);
     // h = MDS( n + e + w0, S)
     buf.sz = intro->sz - 32;
-    printf("hmac\n");
     crypto->hmac(intro->buf, buf, sharedkey);
     // inform result
     llarp_logic_queue_job(intro->iwp->logic, {intro, &inform_gen_intro});

llarp/ev.cpp

@@ -36,10 +36,11 @@ llarp_ev_loop_run(struct llarp_ev_loop *ev)
 }
 
 int
-llarp_ev_add_udp(struct llarp_ev_loop *ev, struct llarp_udp_io *udp)
+llarp_ev_add_udp(struct llarp_ev_loop *ev, struct llarp_udp_io *udp,
+                 const struct sockaddr *src)
 {
   udp->parent = ev;
-  if(ev->udp_listen(udp))
+  if(ev->udp_listen(udp, src))
     return 0;
   return -1;
 }

llarp/ev.hpp

@@ -31,7 +31,7 @@ struct llarp_ev_loop
   stop() = 0;
 
   virtual bool
-  udp_listen(llarp_udp_io* l) = 0;
+  udp_listen(llarp_udp_io* l, const sockaddr* src) = 0;
   virtual bool
   udp_close(llarp_udp_io* l) = 0;
   virtual bool

llarp/ev_epoll.hpp

@@ -6,6 +6,7 @@
 #include <unistd.h>
 #include <cstdio>
 #include "ev.hpp"
+#include "net.hpp"
 
 namespace llarp
 {
@@ -129,12 +130,32 @@ struct llarp_epoll_loop : public llarp_ev_loop
     }
     int fd = socket(addr->sa_family, SOCK_DGRAM, 0);
     if(fd == -1)
+    {
+      perror("socket()");
       return -1;
+    }
+
+    if(addr->sa_family == AF_INET6)
+    {
+      // enable dual stack explicitly
+      int dual = 1;
+      if(setsockopt(fd, IPPROTO_IPV6, IPV6_V6ONLY, &dual, sizeof(dual)) == -1)
+      {
+        // failed
+        perror("setsockopt()");
+        close(fd);
+        return -1;
+      }
+    }
+    llarp::Addr a(*addr);
+    printf("binding to %s\n", a.to_string().c_str());
     if(bind(fd, addr, slen) == -1)
     {
+      perror("bind()");
       close(fd);
       return -1;
     }
+
     return fd;
   }
 
@@ -145,9 +166,9 @@ struct llarp_epoll_loop : public llarp_ev_loop
   }
 
   bool
-  udp_listen(llarp_udp_io* l)
+  udp_listen(llarp_udp_io* l, const sockaddr* src)
   {
-    int fd = udp_bind(&l->addr);
+    int fd = udp_bind(src);
     if(fd == -1)
       return false;
     llarp::udp_listener* listener = new llarp::udp_listener(fd, l);

llarp/iwp_link.cpp

@@ -657,6 +657,7 @@ namespace iwp
     llarp_msg_muxer *muxer;
     llarp_async_iwp *iwp;
     llarp_udp_io udp;
+    llarp::Addr addr;
     char keyfile[255];
     uint32_t timeout_job_id;
 
@@ -697,11 +698,10 @@ namespace iwp
     put_session(const llarp::Addr &src, session *impl)
     {
       llarp_link_session s = {};
-      src.CopyInto(s.addr);
-      s.impl    = impl;
-      s.sendto  = &session::sendto;
-      s.timeout = &session::is_timedout;
-      s.close   = &session::close;
+      s.impl               = impl;
+      s.sendto             = &session::sendto;
+      s.timeout            = &session::is_timedout;
+      s.close              = &session::close;
       {
         lock_t lock(m_sessions_Mutex);
         m_sessions[src] = s;
@@ -731,6 +731,19 @@ namespace iwp
       return s;
     }
 
+    void
+    clear_sessions()
+    {
+      lock_t lock(m_sessions_Mutex);
+      auto itr = m_sessions.begin();
+      while(itr != m_sessions.end())
+      {
+        session *s = static_cast< session * >(itr->second.impl);
+        delete s;
+        itr = m_sessions.erase(itr);
+      }
+    }
+
     void
     cleanup_dead()
     {
@@ -751,6 +764,7 @@ namespace iwp
           auto itr = m_sessions.find(addr);
           if(itr != m_sessions.end())
           {
+            printf("remove session for %s\n", addr.to_string().c_str());
             session *s = static_cast< session * >(itr->second.impl);
             m_sessions.erase(addr);
             delete s;
@@ -859,12 +873,11 @@ namespace iwp
   link_get_addr(struct llarp_link *l, struct llarp_ai *addr)
   {
     server *link = static_cast< server * >(l->impl);
-    llarp::Addr linkaddr(link->udp.addr);
-    addr->rank = 1;
+    addr->rank   = 1;
     strncpy(addr->dialect, link_name(), sizeof(addr->dialect));
     memcpy(addr->enc_key, link->pubkey(), 32);
-    memcpy(addr->ip.s6_addr, linkaddr.addr.s6_addr, 16);
-    addr->port = linkaddr.port;
+    memcpy(addr->ip.s6_addr, link->addr.addr6(), 16);
+    addr->port = link->addr.port();
   }
 
   bool
@@ -880,26 +893,47 @@ namespace iwp
     }
 
     // bind
-
-    link->udp.addr.sa_family = af;
-    if(!llarp_getifaddr(ifname, af, &link->udp.addr))
+    sockaddr_in ip4addr;
+    sockaddr_in6 ip6addr;
+    sockaddr *addr = nullptr;
+    switch(af)
+    {
+      case AF_INET:
+        addr             = (sockaddr *)&ip4addr;
+        ip4addr.sin_port = htons(port);
+        break;
+      case AF_INET6:
+        addr              = (sockaddr *)&ip6addr;
+        ip6addr.sin6_port = htons(port);
+        break;
+        // TODO: AF_PACKET
+      default:
+        return false;
+    }
+    if(!llarp_getifaddr(ifname, af, addr))
+    {
+      printf("failed to get address for %s\n", ifname);
       return false;
+    }
     switch(af)
     {
       case AF_INET:
-        ((sockaddr_in *)&link->udp.addr)->sin_port = htons(port);
+        ip4addr.sin_port = htons(port);
         break;
       case AF_INET6:
-        ((sockaddr_in6 *)(&link->udp.addr))->sin6_port = htons(port);
+        ip6addr.sin6_port = htons(port);
         break;
         // TODO: AF_PACKET
       default:
         return false;
     }
+
+    link->addr = *addr;
+    printf("bind to %s at %s\n", ifname, link->addr.to_string().c_str());
     link->netloop      = netloop;
     link->udp.recvfrom = &server::handle_recvfrom;
     link->udp.user     = link;
-    return llarp_ev_add_udp(link->netloop, &link->udp) != -1;
+    return llarp_ev_add_udp(link->netloop, &link->udp, link->addr) != -1;
   }
 
   bool
@@ -952,7 +986,6 @@ namespace iwp
       s->establish_job = job;
       s->introduce(job->ai.enc_key);
     }
-    printf("introduced\n");
     return true;
   }
 
@@ -960,7 +993,7 @@ namespace iwp
   link_mark_session_active(struct llarp_link *link,
                            struct llarp_link_session *s)
   {
-    // TODO: implement
+    static_cast< session * >(s->impl)->frame.alive();
   }
 
   void
@@ -968,6 +1001,7 @@ namespace iwp
   {
     server *link = static_cast< server * >(l->impl);
     llarp_ev_close_udp(&link->udp);
+    link->clear_sessions();
     delete link;
   }
 }

llarp/net.cpp

@@ -3,6 +3,7 @@
 
 #include <arpa/inet.h>
 #include <ifaddrs.h>
+#include <net/if.h>
 #include <cstdio>
 
 bool
@@ -61,8 +62,14 @@ llarp_getifaddr(const char* ifname, int af, struct sockaddr* addr)
       if(llarp::StrEq(i->ifa_name, ifname) && i->ifa_addr->sa_family == af)
       {
         memcpy(addr, i->ifa_addr, sl);
-        addr->sa_family = af;
-        found           = true;
+        if(af == AF_INET6)
+        {
+          // set scope id
+          sockaddr_in6* ip6addr  = (sockaddr_in6*)addr;
+          ip6addr->sin6_scope_id = if_nametoindex(ifname);
+          ip6addr->sin6_flowinfo = 0;
+        }
+        found = true;
         break;
       }
     }

llarp/net.hpp

@@ -3,6 +3,7 @@
 #include <llarp/address_info.h>
 #include <llarp/net.h>
 #include <string>
+#include "mem.hpp"
 
 bool
 operator==(const sockaddr& a, const sockaddr& b);
@@ -17,11 +18,7 @@ namespace llarp
 {
   struct Addr
   {
-    int af        = AF_INET;
-    in6_addr addr = {};
-    uint16_t port = 0;
-
-    sockaddr _addr = {0, {0}};
+    sockaddr_in6 _addr;
 
     ~Addr(){};
 
@@ -29,45 +26,64 @@ namespace llarp
 
     Addr(const Addr& other)
     {
-      af   = other.af;
-      port = other.port;
-      memcpy(addr.s6_addr, other.addr.s6_addr, sizeof(addr.s6_addr));
-      CopyInto(_addr);
+      memcpy(&_addr, &other._addr, sizeof(sockaddr_in6));
+    }
+
+    in6_addr*
+    addr6()
+    {
+      return (in6_addr*)&_addr.sin6_addr.s6_addr;
+    }
+
+    in_addr*
+    addr4()
+    {
+      return (in_addr*)&_addr.sin6_addr.s6_addr[12];
+    }
+
+    const in6_addr*
+    addr6() const
+    {
+      return (const in6_addr*)&_addr.sin6_addr.s6_addr;
+    }
+
+    const in_addr*
+    addr4() const
+    {
+      return (const in_addr*)&_addr.sin6_addr.s6_addr[12];
     }
 
     Addr(const llarp_ai& other)
     {
-      af = AF_INET6;
-      memcpy(addr.s6_addr, other.ip.s6_addr, 16);
-      port = other.port;
-      CopyInto(_addr);
+      memcpy(addr6(), other.ip.s6_addr, 16);
+      _addr.sin6_port = htons(other.port);
     }
 
     Addr(const sockaddr& other)
     {
-      uint8_t* addrptr = addr.s6_addr;
+      llarp::Zero(&_addr, sizeof(sockaddr_in6));
+      _addr.sin6_family = other.sa_family;
+      uint8_t* addrptr  = _addr.sin6_addr.s6_addr;
+      uint16_t* port    = &_addr.sin6_port;
       switch(other.sa_family)
       {
         case AF_INET:
           // SIIT
-          af = AF_INET;
           memcpy(12 + addrptr, &((const sockaddr_in*)(&other))->sin_addr,
                  sizeof(in_addr));
           addrptr[11] = 0xff;
           addrptr[10] = 0xff;
-          port        = ntohs(((sockaddr_in*)(&other))->sin_port);
+          *port       = ((sockaddr_in*)(&other))->sin_port;
           break;
         case AF_INET6:
-          af = AF_INET6;
-          memcpy(addrptr, &((const sockaddr_in6*)(&other))->sin6_addr,
-                 sizeof(addr.s6_addr));
-          port = ntohs(((sockaddr_in6*)(&other))->sin6_port);
+          memcpy(addrptr, &((const sockaddr_in6*)(&other))->sin6_addr.s6_addr,
+                 16);
+          *port = ((sockaddr_in6*)(&other))->sin6_port;
           break;
           // TODO : sockaddr_ll
         default:
           break;
       }
-      CopyInto(_addr);
     }
 
     std::string
@@ -77,64 +93,77 @@ namespace llarp
       char tmp[128];
       socklen_t sz;
       const void* ptr = nullptr;
-      if(af == AF_INET)
-      {
-        sz  = sizeof(sockaddr_in);
-        ptr = &addr.s6_addr[12];
-      }
-      if(af == AF_INET6)
+      if(af() == AF_INET6)
       {
         str += "[";
         sz  = sizeof(sockaddr_in6);
-        ptr = &addr.s6_addr[0];
+        ptr = addr6();
+      }
+      else
+      {
+        sz  = sizeof(sockaddr_in);
+        ptr = addr4();
       }
-      if(inet_ntop(af, ptr, tmp, sz))
+      if(inet_ntop(af(), ptr, tmp, sz))
       {
         str += tmp;
-        if(af == AF_INET6)
+        if(af() == AF_INET6)
           str += "]";
       }
 
-      return str + ":" + std::to_string(port);
+      return str + ":" + std::to_string(port());
     }
 
     operator const sockaddr*() const
     {
-      return &_addr;
+      return (const sockaddr*)&_addr;
     }
 
     void
-    CopyInto(sockaddr& other) const
+    CopyInto(sockaddr* other) const
     {
       void *dst, *src;
       in_port_t* ptr;
       size_t slen;
-      switch(af)
+      switch(af())
       {
         case AF_INET:
-          dst  = (void*)&((const sockaddr_in*)&other)->sin_addr;
-          src  = (void*)&addr.s6_addr[12];
-          ptr  = &((sockaddr_in*)&other)->sin_port;
+          dst  = (void*)&((sockaddr_in*)other)->sin_addr.s_addr;
+          src  = (void*)&_addr.sin6_addr.s6_addr[12];
+          ptr  = &((sockaddr_in*)other)->sin_port;
           slen = sizeof(in_addr);
           break;
         case AF_INET6:
-          dst  = (void*)&((const sockaddr_in6*)&other)->sin6_addr;
-          src  = (void*)&addr.s6_addr[0];
-          ptr  = &((sockaddr_in6*)&other)->sin6_port;
+          dst  = (void*)((sockaddr_in6*)other)->sin6_addr.s6_addr;
+          src  = (void*)_addr.sin6_addr.s6_addr;
+          ptr  = &((sockaddr_in6*)other)->sin6_port;
           slen = sizeof(in6_addr);
           break;
         default:
           return;
       }
       memcpy(ptr, src, slen);
-      *ptr            = htons(port);
-      other.sa_family = af;
+      *ptr             = htons(port());
+      other->sa_family = af();
+    }
+
+    int
+    af() const
+    {
+      return _addr.sin6_family;
+    }
+
+    uint16_t
+    port() const
+    {
+      return ntohs(_addr.sin6_port);
     }
 
     bool
     operator<(const Addr& other) const
     {
-      return af < other.af && addr < other.addr && port < other.port;
+      return af() < other.af() && *addr6() < *other.addr6()
+          && port() < other.port();
     }
   };
 }

llarp/router.cpp

@@ -53,6 +53,7 @@ llarp_router::try_connect(fs::path rcfile)
     }
     else
     {
+      printf("failed to open %s\n", rcfile.c_str());
       return;
     }
   }
@@ -409,7 +410,7 @@ namespace llarp
     }
     else
     {
-      af    = AF_INET;
+      af    = AF_INET6;
       proto = std::atoi(val);
     }