Merge remote-tracking branch 'cathugger/master'

include/llarp/ip.hpp

@@ -153,9 +153,13 @@ namespace llarp
         Header()->daddr = htonl(ip);
       }
 
-      // update ip packet checksum
+      // update ip packet checksum (after packet gets out of network)
       void
-      UpdateChecksum();
+      UpdateChecksumsOnDst();
+
+      // update ip packet checksum (before packet gets inserted into network)
+      void
+      UpdateChecksumsOnSrc();
     };
 
   }  // namespace net

include/llarp/path.hpp

@@ -410,8 +410,8 @@ namespace llarp
       GetByUpstream(const RouterID& id, const PathID_t& path);
 
       IHopHandler*
-      GetPathForTransfer(const PathID_t & topath);
-      
+      GetPathForTransfer(const PathID_t& topath);
+
       IHopHandler*
       GetByDownstream(const RouterID& id, const PathID_t& path);
 

include/llarp/service/IntroSet.hpp

@@ -69,7 +69,10 @@ namespace llarp
         version = other.version;
         topic   = other.topic;
         if(W)
+        {
           delete W;
+          W = nullptr;
+        }
         if(other.W)
           W = new llarp::PoW(*other.W);
         Z = other.Z;

include/llarp/time.hpp

@@ -8,5 +8,4 @@ namespace llarp
   typedef std::chrono::system_clock Clock_t;
 }
 
-
 #endif

llarp/ev.hpp

@@ -7,7 +7,6 @@
 #endif
 #include <unistd.h>
 #include <llarp/buffer.h>
-#include <list>
 #include <llarp/codel.hpp>
 #include <vector>
 
@@ -192,8 +191,8 @@ struct llarp_ev_loop
 
   virtual ~llarp_ev_loop(){};
 
-  std::list< llarp_udp_io* > udp_listeners;
-  std::list< llarp_tun_io* > tun_listeners;
+  std::vector< llarp_udp_io* > udp_listeners;
+  std::vector< llarp_tun_io* > tun_listeners;
 
   void
   tick_listeners()

llarp/ev_epoll.hpp

@@ -320,7 +320,8 @@ struct llarp_epoll_loop : public llarp_ev_loop
       close_ev(listener);
       l->impl = nullptr;
       delete listener;
-      udp_listeners.remove(l);
+      std::remove_if(udp_listeners.begin(), udp_listeners.end(),
+                     [l](llarp_udp_io* i) -> bool { return i == l; });
     }
     return ret;
   }

llarp/ev_kqueue.hpp

@@ -361,7 +361,15 @@ struct llarp_kqueue_loop : public llarp_ev_loop
       ret     = close_ev(listener);
       l->impl = nullptr;
       delete listener;
-      udp_listeners.remove(l);
+      // std::remove_if
+      auto itr = udp_listeners.begin();
+      while(itr != udp_listeners.end())
+      {
+        if((*itr) == l)
+          itr = udp_listeners.remove(itr);
+        else
+          ++itr;
+      }
     }
     return ret;
   }

llarp/ev_win32.hpp

@@ -410,7 +410,15 @@ struct llarp_win32_loop : public llarp_ev_loop
       ret     = close_ev(listener);
       l->impl = nullptr;
       delete listener;
-      udp_listeners.remove(l);
+      // std::remove_if
+      auto itr = udp_listeners.begin();
+      while(itr != udp_listeners.end())
+      {
+        if((*itr) == l)
+          itr = udp_listeners.remove(itr);
+        else
+          ++itr;
+      }
     }
     return ret;
   }

llarp/handlers/tun.cpp

@@ -307,6 +307,13 @@ namespace llarp
                          inet_ntoa({htonl(pkt.dst())}));
           return true;
         }
+
+        // prepare packet for insertion into network
+        pkt.UpdateChecksumsOnSrc();
+        // clear addresses
+        pkt.src(0);
+        pkt.dst(0);
+
         if(!SendToOrQueue(itr->second, pkt.Buffer(), service::eProtocolTraffic))
         {
           llarp::LogWarn(Name(), " did not flush packets");
@@ -329,7 +336,7 @@ namespace llarp
                memcpy(pkt.buf, buf.base, pkt.sz);
                pkt.src(themIP);
                pkt.dst(usIP);
-               pkt.UpdateChecksum();
+               pkt.UpdateChecksumsOnDst();
                return true;
              }))
 

llarp/ip.cpp

@@ -16,11 +16,7 @@ namespace llarp
     bool
     IPv4Packet::Load(llarp_buffer_t pkt)
     {
-#ifndef MIN
-#define MIN(a, b) (a < b ? a : b)
-      sz = MIN(pkt.sz, sizeof(buf));
-#undef MIN
-#endif
+      sz = std::min(pkt.sz, sizeof(buf));
       memcpy(buf, pkt.base, sz);
       return true;
     }
@@ -31,6 +27,17 @@ namespace llarp
       return llarp::InitBuffer(buf, sz);
     }
 
+    static uint32_t
+    ipchksum_pseudoIPv4(uint32_t src_ip_n, uint32_t dst_ip_n, uint8_t proto,
+                        uint16_t innerlen)
+    {
+#define IPCS(x) ((uint32_t)(x & 0xFFFF) + (uint32_t)(x >> 16))
+      uint32_t sum = IPCS(src_ip_n) + IPCS(dst_ip_n) + (uint32_t)proto
+          + (uint32_t)htons(innerlen);
+#undef IPCS
+      return sum;
+    }
+
     static uint16_t
     ipchksum(const byte_t *buf, size_t sz, uint32_t sum = 0)
     {
@@ -49,47 +56,166 @@ namespace llarp
       return ~sum;
     }
 
+    static uint16_t
+    deltachksum(uint16_t old_sum, uint32_t old_src_ip_n, uint32_t old_dst_ip_n,
+                uint32_t new_src_ip_n, uint32_t new_dst_ip_n)
+    {
+      uint32_t old_src_ip_h = htonl(old_src_ip_n);
+      uint32_t old_dst_ip_h = htonl(old_dst_ip_n);
+      uint32_t new_src_ip_h = htonl(new_src_ip_n);
+      uint32_t new_dst_ip_h = htonl(new_dst_ip_n);
+
+#define ADDIPCS(x) ((uint32_t)(x & 0xFFFF) + (uint32_t)(x >> 16))
+#define SUBIPCS(x) ((uint32_t)((~x) & 0xFFFF) + (uint32_t)((~x) >> 16))
+
+      uint32_t sum = ntohs(old_sum) + ADDIPCS(old_src_ip_h)
+          + ADDIPCS(old_dst_ip_h) + SUBIPCS(new_src_ip_h)
+          + SUBIPCS(new_dst_ip_h);
+
+#undef ADDIPCS
+#undef SUBIPCS
+
+      while(sum >> 16)
+        sum = (sum & 0xffff) + (sum >> 16);
+
+      return htons(sum);
+    }
+
+    static std::map<
+        byte_t, std::function< void(const ip_header *, byte_t *, size_t) > >
+        protoDstCheckSummer = {
+            // {RFC3022} says that IPv4 hdr isn't included in ICMP checksum calc
+            // and that we don't need to modify it
+            {// TCP
+             6,
+             [](const ip_header *hdr, byte_t *pkt, size_t sz) {
+               auto hlen       = size_t(hdr->ihl * 4);
+               uint16_t *check = (uint16_t *)(pkt + hlen + 16);
+               *check = deltachksum(*check, 0, 0, hdr->saddr, hdr->daddr);
+             }},
+            {// UDP
+             17,
+             [](const ip_header *hdr, byte_t *pkt, size_t sz) {
+               uint16_t *check = (uint16_t *)(pkt + hlen + 16);
+               if(*check != 0xFFff)
+               {
+                 if(*check == 0x0000)
+                   return;  // don't change zero
+
+                 *check = deltachksum(*check, 0, 0, hdr->saddr, hdr->daddr);
+                 if(*check == 0x0000)
+                   *check = 0xFFff;
+               }
+               else
+               {
+                 // such checksum can mean 2 things: 0x0000 or 0xFFff
+                 // we can only know by looking at data :<
+                 auto hlen = size_t(hdr->ihl * 4);
+                 if(hlen > sz)
+                   return;  // malformed, bail out
+
+                 auto cs = ipchksum(pkt + hlen, sz - hlen,
+                                    ipchksum_pseudoIPv4(0, 0, 17, sz - hlen));
+
+                 auto mod_cs = deltachksum(cs, 0, 0, hdr->saddr, hdr->daddr);
+
+                 if(cs != 0x0000 && cs != 0xFFff)
+                 {
+                   // packet was bad - sabotage new checksum
+                   mod_cs += cs - *check;
+                 }
+                 // 0x0000 is reserved for no checksum
+                 if(mod_cs == 0x0000)
+                   mod_cs = 0xFFff;
+                 // put it in
+                 *check = mod_cs;
+               }
+             }},
+
+    };
+    void
+    IPv4Packet::UpdateChecksumsOnDst()
+    {
+      auto hdr = Header();
+
+      // IPv4 checksum
+      hdr->check = deltachksum(hdr->check, 0, 0, hdr->saddr, hdr->daddr);
+
+      // L4 checksum
+      auto proto = hdr->protocol;
+      auto itr   = protoDstCheckSummer.find(proto);
+      if(itr != protoDstCheckSummer.end())
+      {
+        itr->second(hdr, buf, sz);
+      }
+    }
+
     static std::map<
         byte_t, std::function< void(const ip_header *, byte_t *, size_t) > >
-        protoCheckSummer = {
-            /// ICMP
-            {1,
-             [](const ip_header *hdr, byte_t *buf, size_t sz) {
-               auto len        = hdr->ihl * 4;
-               uint16_t *check = (uint16_t *)buf + len + 2;
-               *check          = 0;
-               *check          = ipchksum(buf, sz);
+        protoSrcCheckSummer = {
+            {// TCP
+             6,
+             [](const ip_header *hdr, byte_t *pkt, size_t sz) {
+               auto hlen = size_t(hdr->ihl * 4);
+
+               uint16_t *check = (uint16_t *)(pkt + hlen + 16);
+               *check = deltachksum(*check, hdr->saddr, hdr->daddr, 0, 0);
+             }},
+            {// UDP
+             17,
+             [](const ip_header *hdr, byte_t *pkt, size_t sz) {
+               uint16_t *check = (uint16_t *)(pkt + hlen + 16);
+               if(*check != 0xFFff)
+               {
+                 if(*check == 0x0000)
+                   return;  // don't change zero
+
+                 *check = deltachksum(*check, hdr->saddr, hdr->daddr, 0, 0);
+                 if(*check == 0x0000)
+                   *check = 0xFFff;
+               }
+               else
+               {
+                 // such checksum can mean 2 things: 0x0000 or 0xFFff
+                 // we can only know by looking at data :<
+                 auto hlen = size_t(hdr->ihl * 4);
+                 if(hlen > sz)
+                   return;  // malformed, bail out
+
+                 auto cs = ipchksum(pkt + hlen, sz - hlen,
+                                    ipchksum_pseudoIPv4(hdr->saddr, hdr->daddr,
+                                                        17, sz - hlen));
+
+                 auto mod_cs = deltachksum(cs, hdr->saddr, hdr->daddr, 0, 0);
+
+                 if(cs != 0x0000 && cs != 0xFFff)
+                 {
+                   // packet was bad - sabotage new checksum
+                   mod_cs += cs - *check;
+                 }
+                 // 0x0000 is reserved for no checksum
+                 if(mod_cs == 0x0000)
+                   mod_cs = 0xFFff;
+                 // put it in
+                 *check = mod_cs;
+               }
              }},
-            /// TCP
-            {6, [](const ip_header *hdr, byte_t *pkt, size_t sz) {
-               byte_t pktbuf[1500];
-               auto len        = hdr->ihl * 4;
-               size_t pktsz    = sz - len;
-               uint16_t *check = (uint16_t *)(pkt + len + 16);
-               *check          = 0;
-               memcpy(pktbuf, &hdr->saddr, 4);
-               memcpy(pktbuf + 4, &hdr->daddr, 4);
-               pktbuf[8] = 0;
-               pktbuf[9] = 6;
-               // TODO: endian (?)
-               pktbuf[10] = (pktsz & 0xff00) >> 8;
-               pktbuf[11] = pktsz & 0x00ff;
-               memcpy(pktbuf + 12, pkt + len, pktsz);
-               *check = ipchksum(pktbuf, 12 + pktsz);
-             }}};
+    };
     void
-    IPv4Packet::UpdateChecksum()
+    IPv4Packet::UpdateChecksumsOnSrc()
     {
-      auto hdr   = Header();
-      hdr->check = 0;
-      auto len   = hdr->ihl * 4;
-      hdr->check = ipchksum(buf, len);
+      auto hdr = Header();
+
+      // L4
       auto proto = hdr->protocol;
-      auto itr   = protoCheckSummer.find(proto);
-      if(itr != protoCheckSummer.end())
+      auto itr   = protoSrcCheckSummer.find(proto);
+      if(itr != protoSrcCheckSummer.end())
       {
         itr->second(hdr, buf, sz);
       }
+
+      // IPv4
+      hdr->check = deltachksum(hdr->check, hdr->saddr, hdr->daddr, 0, 0);
     }
   }  // namespace net
 }  // namespace llarp

llarp/path.cpp

@@ -204,8 +204,8 @@ namespace llarp
       return m_Router;
     }
 
-    IHopHandler *
-    PathContext::GetPathForTransfer(const PathID_t & id)
+    IHopHandler*
+    PathContext::GetPathForTransfer(const PathID_t& id)
     {
       RouterID us(OurRouterID());
       auto& map = m_TransitPaths;
@@ -220,7 +220,7 @@ namespace llarp
       }
       return nullptr;
     }
-    
+
     void
     PathContext::PutTransitHop(TransitHop* hop)
     {

llarp/pathbuilder.cpp

@@ -3,7 +3,6 @@
 
 #include <llarp/pathbuilder.hpp>
 #include <functional>
-
 #include "buffer.hpp"
 #include "router.hpp"
 
@@ -173,20 +172,16 @@ namespace llarp
     Builder::SelectHop(llarp_nodedb* db, const RouterContact& prev,
                        RouterContact& cur, size_t hop)
     {
-      if(hop == 0)
-      {
-        if(router->NumberOfConnectedRouters())
-          return router->GetRandomConnectedRouter(cur);
-        else
-          return llarp_nodedb_select_random_hop(db, prev, cur, 0);
-      }
+      if(hop == 0 && router->NumberOfConnectedRouters())
+        return router->GetRandomConnectedRouter(cur);
+
       size_t tries = 5;
       do
       {
         --tries;
         llarp_nodedb_select_random_hop(db, prev, cur, hop);
       } while(router->routerProfiling.IsBad(cur.pubkey) && tries > 0);
-      return tries > 0;
+      return !router->routerProfiling.IsBad(cur.pubkey);
     }
 
     const byte_t*