diff --git a/CMakeLists.txt b/CMakeLists.txt
index 29dd76988..f30b992de 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -6,6 +6,7 @@ project(${PROJECT_NAME} C CXX ASM)
 
 option(USE_LIBABYSS "enable libabyss" )
 option(USE_AVX2 "enable avx2 code" )
+option(USE_NETNS "enable networking namespace support" )
 
 # Require C++17
 set(CMAKE_CXX_STANDARD 17)
@@ -35,6 +36,9 @@ set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -Wl,--allow-multiple-defin
 endif(USING_CLANG)
 endif()
 
+
+
+
 if(WIN32)
 add_compile_options($<$<COMPILE_LANGUAGE:C>:-Wno-bad-function-cast>)
 add_compile_options(-Wno-cast-function-type)
@@ -51,13 +55,18 @@ find_package(Threads REQUIRED)
 
 if(STATIC_LINK)
   add_compile_options(-static)
-  set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -static-libstdc++ -static-libgcc -static" )
+  if(USING_CLANG)
+    set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -static")
+  else()
+    set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -static-libstdc++ -static-libgcc -static" )
+  endif()
 endif()
 
-# This is now configurable in ini
-#if(DNS_PORT)
-#  add_definitions(-DDNS_PORT=${DNS_PORT})
-#endif()
+if(USE_NETNS)
+  add_definitions(-DNETNS=1)
+else()
+  add_definitions(-DNETNS=0)
+endif()
 
 if(SHADOW)
   set(WITH_STATIC OFF)
@@ -148,12 +157,16 @@ endif()
 
 # FS_LIB should resolve to nothing on all other platforms
 # it is only required on win32 -rick
-set(LIBS Threads::Threads ${MALLOC_LIB} ${FS_LIB})
+set(LIBS ${LIBS} ${MALLOC_LIB} ${FS_LIB})
 
 if(ANDROID)
   set(LIBS ${LIBS} log)
 endif()
 
+if(NOT USING_CLANG)
+  set(LIBS ${LIBS} Threads::Threads)
+endif()
+
 set(LIB lokinet)
 set(SHARED_LIB ${LIB})
 set(STATIC_LIB ${LIB}-static)
diff --git a/Makefile b/Makefile
index eb82d9a9c..ae965cdb8 100644
--- a/Makefile
+++ b/Makefile
@@ -49,11 +49,13 @@ JSONRPC ?= OFF
 AVX2 ?= ON
 RPI ?= OFF
 STATIC_LINK ?= OFF
+NETNS ?= OFF
+CLANG ?= OFF
 CMAKE_GEN ?= Unix Makefiles
 
 BUILD_ROOT = $(REPO)/build
 
-CONFIG_CMD = $(shell /bin/echo -n "cd '$(BUILD_ROOT)' && " ; /bin/echo -n "cmake -G'$(CMAKE_GEN)' -DSTATIC_LINK=$(STATIC_LINK) -DUSE_AVX2=$(AVX2) -DUSE_LIBABYSS=$(JSONRPC) -DRPI=$(RPI) '$(REPO)'")
+CONFIG_CMD = $(shell /bin/echo -n "cd '$(BUILD_ROOT)' && " ; /bin/echo -n "cmake -G'$(CMAKE_GEN)' -DUSING_CLANG=$(CLANG) -DSTATIC_LINK=$(STATIC_LINK) -DUSE_NETNS=$(NETNS) -DUSE_AVX2=$(AVX2) -DUSE_LIBABYSS=$(JSONRPC) -DRPI=$(RPI) '$(REPO)'")
 
 SCAN_BUILD ?= scan-build
 ANALYZE_CONFIG_CMD = $(shell /bin/echo -n "cd '$(BUILD_ROOT)' && " ; /bin/echo -n "$(SCAN_BUILD) cmake -DUSE_LIBABYSS=$(JSONRPC) '$(REPO)'")
diff --git a/include/llarp/handlers/exit.hpp b/include/llarp/handlers/exit.hpp
index 16f18f344..14f78f381 100644
--- a/include/llarp/handlers/exit.hpp
+++ b/include/llarp/handlers/exit.hpp
@@ -20,7 +20,7 @@ namespace llarp
       bool
       SetOption(const std::string& k, const std::string& v);
 
-      virtual std::string
+      std::string
       Name() const;
 
       bool
diff --git a/include/llarp/path.hpp b/include/llarp/path.hpp
index 295db807b..1d6938574 100644
--- a/include/llarp/path.hpp
+++ b/include/llarp/path.hpp
@@ -175,7 +175,8 @@ namespace llarp
 
       // send routing message when end of path
       bool
-      SendRoutingMessage(const llarp::routing::IMessage* msg, llarp_router* r);
+      SendRoutingMessage(const llarp::routing::IMessage* msg,
+                         llarp_router* r) override;
 
       // handle routing message when end of path
       bool
@@ -184,48 +185,50 @@ namespace llarp
 
       bool
       HandleDataDiscardMessage(const llarp::routing::DataDiscardMessage* msg,
-                               llarp_router* r);
+                               llarp_router* r) override;
 
       bool
       HandlePathConfirmMessage(const llarp::routing::PathConfirmMessage* msg,
-                               llarp_router* r);
+                               llarp_router* r) override;
       bool
       HandlePathTransferMessage(const llarp::routing::PathTransferMessage* msg,
-                                llarp_router* r);
+                                llarp_router* r) override;
       bool
       HandlePathLatencyMessage(const llarp::routing::PathLatencyMessage* msg,
-                               llarp_router* r);
+                               llarp_router* r) override;
 
       bool
       HandleObtainExitMessage(const llarp::routing::ObtainExitMessage* msg,
-                              llarp_router* r);
+                              llarp_router* r) override;
 
       bool
       HandleUpdateExitVerifyMessage(
-          const llarp::routing::UpdateExitVerifyMessage* msg, llarp_router* r);
+          const llarp::routing::UpdateExitVerifyMessage* msg,
+          llarp_router* r) override;
 
       bool
       HandleTransferTrafficMessage(
-          const llarp::routing::TransferTrafficMessage* msg, llarp_router* r);
+          const llarp::routing::TransferTrafficMessage* msg,
+          llarp_router* r) override;
 
       bool
       HandleUpdateExitMessage(const llarp::routing::UpdateExitMessage* msg,
-                              llarp_router* r);
+                              llarp_router* r) override;
 
       bool
       HandleGrantExitMessage(const llarp::routing::GrantExitMessage* msg,
-                             llarp_router* r);
+                             llarp_router* r) override;
       bool
       HandleRejectExitMessage(const llarp::routing::RejectExitMessage* msg,
-                              llarp_router* r);
+                              llarp_router* r) override;
 
       bool
       HandleCloseExitMessage(const llarp::routing::CloseExitMessage* msg,
-                             llarp_router* r);
+                             llarp_router* r) override;
 
       bool
-      HandleHiddenServiceFrame(__attribute__((unused))
-                               const llarp::service::ProtocolFrame* frame)
+      HandleHiddenServiceFrame(__attribute__((
+          unused)) const llarp::service::ProtocolFrame* frame) override
       {
         /// TODO: implement me
         llarp::LogWarn("Got hidden service data on transit hop");
@@ -236,15 +239,18 @@ namespace llarp
       HandleGotIntroMessage(const llarp::dht::GotIntroMessage* msg);
 
       bool
-      HandleDHTMessage(const llarp::dht::IMessage* msg, llarp_router* r);
+      HandleDHTMessage(const llarp::dht::IMessage* msg,
+                       llarp_router* r) override;
 
       // handle data in upstream direction
       bool
-      HandleUpstream(llarp_buffer_t X, const TunnelNonce& Y, llarp_router* r);
+      HandleUpstream(llarp_buffer_t X, const TunnelNonce& Y,
+                     llarp_router* r) override;
 
       // handle data in downstream direction
       bool
-      HandleDownstream(llarp_buffer_t X, const TunnelNonce& Y, llarp_router* r);
+      HandleDownstream(llarp_buffer_t X, const TunnelNonce& Y,
+                       llarp_router* r) override;
     };
 
     /// configuration for a single hop when building a path
@@ -372,85 +378,88 @@ namespace llarp
       }
 
       bool
-      ExpiresSoon(llarp_time_t now, llarp_time_t dlt = 5000) const
+      ExpiresSoon(llarp_time_t now, llarp_time_t dlt = 5000) const override
       {
         return now >= (ExpireTime() - dlt);
       }
 
       bool
-      Expired(llarp_time_t now) const;
+      Expired(llarp_time_t now) const override;
 
       void
       Tick(llarp_time_t now, llarp_router* r);
 
       bool
-      SendRoutingMessage(const llarp::routing::IMessage* msg, llarp_router* r);
+      SendRoutingMessage(const llarp::routing::IMessage* msg,
+                         llarp_router* r) override;
 
       bool
       HandleObtainExitMessage(const llarp::routing::ObtainExitMessage* msg,
-                              llarp_router* r);
+                              llarp_router* r) override;
 
       bool
       HandleUpdateExitVerifyMessage(
-          const llarp::routing::UpdateExitVerifyMessage* msg, llarp_router* r);
+          const llarp::routing::UpdateExitVerifyMessage* msg,
+          llarp_router* r) override;
 
       bool
       HandleTransferTrafficMessage(
-          const llarp::routing::TransferTrafficMessage* msg, llarp_router* r);
+          const llarp::routing::TransferTrafficMessage* msg,
+          llarp_router* r) override;
 
       bool
       HandleUpdateExitMessage(const llarp::routing::UpdateExitMessage* msg,
-                              llarp_router* r);
+                              llarp_router* r) override;
 
       bool
       HandleCloseExitMessage(const llarp::routing::CloseExitMessage* msg,
-                             llarp_router* r);
-      bool
-      HandleRejectExitMessagge(const llarp::routing::RejectExitMessage* msg,
-                               llarp_router* r);
-
+                             llarp_router* r) override;
       bool
       HandleGrantExitMessage(const llarp::routing::GrantExitMessage* msg,
-                             llarp_router* r);
+                             llarp_router* r) override;
       bool
       HandleRejectExitMessage(const llarp::routing::RejectExitMessage* msg,
-                              llarp_router* r);
+                              llarp_router* r) override;
 
       bool
       HandleDataDiscardMessage(const llarp::routing::DataDiscardMessage* msg,
-                               llarp_router* r);
+                               llarp_router* r) override;
 
       bool
       HandlePathConfirmMessage(const llarp::routing::PathConfirmMessage* msg,
-                               llarp_router* r);
+                               llarp_router* r) override;
 
       bool
       HandlePathLatencyMessage(const llarp::routing::PathLatencyMessage* msg,
-                               llarp_router* r);
+                               llarp_router* r) override;
 
       bool
       HandlePathTransferMessage(const llarp::routing::PathTransferMessage* msg,
-                                llarp_router* r);
+                                llarp_router* r) override;
 
       bool
-      HandleHiddenServiceFrame(const llarp::service::ProtocolFrame* frame);
+      HandleHiddenServiceFrame(
+          const llarp::service::ProtocolFrame* frame) override;
 
       bool
       HandleGotIntroMessage(const llarp::dht::GotIntroMessage* msg);
 
       bool
-      HandleDHTMessage(const llarp::dht::IMessage* msg, llarp_router* r);
+      HandleDHTMessage(const llarp::dht::IMessage* msg,
+                       llarp_router* r) override;
 
       bool
       HandleRoutingMessage(llarp_buffer_t buf, llarp_router* r);
 
       // handle data in upstream direction
       bool
-      HandleUpstream(llarp_buffer_t X, const TunnelNonce& Y, llarp_router* r);
+      HandleUpstream(llarp_buffer_t X, const TunnelNonce& Y,
+                     llarp_router* r) override;
 
       // handle data in downstream direction
       bool
-      HandleDownstream(llarp_buffer_t X, const TunnelNonce& Y, llarp_router* r);
+      HandleDownstream(llarp_buffer_t X, const TunnelNonce& Y,
+                       llarp_router* r) override;
 
       bool
       IsReady() const;
diff --git a/include/llarp/service/endpoint.hpp b/include/llarp/service/endpoint.hpp
index c79c1aacd..7f50b0cc4 100644
--- a/include/llarp/service/endpoint.hpp
+++ b/include/llarp/service/endpoint.hpp
@@ -110,15 +110,16 @@ namespace llarp
       HasPathToService(const Address& remote) const;
 
       virtual huint32_t
-      ObtainIPForAddr(__attribute__((unused))
-                      const llarp::service::Address& remote)
+      ObtainIPForAddr(const byte_t * addr)
       {
+        (void) addr;
         return {0};
       }
 
       virtual bool
-      HasAddress(__attribute__((unused)) const Address& remote) const
+      HasAddress(const byte_t* addr) const
       {
+        (void)addr;
         return false;
       }
 
@@ -254,18 +255,18 @@ namespace llarp
         /// update the current selected intro to be a new best introduction
         /// return true if we have changed intros
         bool
-        ShiftIntroduction();
+        ShiftIntroduction() override;
 
         /// mark the current remote intro as bad
         bool
-        MarkCurrentIntroBad(llarp_time_t now);
+        MarkCurrentIntroBad(llarp_time_t now) override;
 
         /// return true if we are ready to send
         bool
         ReadyToSend() const;
 
         bool
-        ShouldBuildMore(llarp_time_t now) const;
+        ShouldBuildMore(llarp_time_t now) const override;
 
         /// tick internal state
         /// return true to mark as dead
@@ -280,21 +281,22 @@ namespace llarp
         CheckPathIsDead(path::Path* p, llarp_time_t dlt);
 
         void
-        AsyncGenIntro(llarp_buffer_t payload, ProtocolType t);
+        AsyncGenIntro(llarp_buffer_t payload, ProtocolType t) override;
 
         /// issues a lookup to find the current intro set of the remote service
         void
-        UpdateIntroSet(bool randomizePath);
+        UpdateIntroSet(bool randomizePath) override;
 
         bool
         BuildOneAlignedTo(const RouterID& remote);
 
         void
-        HandlePathBuilt(path::Path* path);
+        HandlePathBuilt(path::Path* path) override;
 
         bool
         SelectHop(llarp_nodedb* db, const RouterContact& prev,
-                  RouterContact& cur, size_t hop);
+                  RouterContact& cur, size_t hop,
+                  llarp::path::PathRole roles) override;
 
         bool
         HandleHiddenServiceFrame(path::Path* p, const ProtocolFrame* frame);
diff --git a/llarp/linux/netns.cpp b/llarp/linux/netns.cpp
index d90c70286..78e7146f2 100644
--- a/llarp/linux/netns.cpp
+++ b/llarp/linux/netns.cpp
@@ -1,4 +1,4 @@
-#if defined(RPI) || defined(ANDROID)
+#if defined(RPI) || defined(ANDROID) || NETNS == 0
 
 #else
 #include <asm/types.h>
diff --git a/llarp/queue_manager.cpp b/llarp/queue_manager.cpp
index 2bd593e8a..1636e4496 100644
--- a/llarp/queue_manager.cpp
+++ b/llarp/queue_manager.cpp
@@ -159,7 +159,7 @@ namespace llarp
       (void)m_pushPadding;
       (void)m_popPadding;
 
-      m_states = new std::atomic<std::uint32_t>[capacity];
+      m_states = new std::atomic< std::uint32_t >[capacity];
 
       for(size_t i = 0; i < capacity; ++i)
       {
@@ -435,7 +435,7 @@ namespace llarp
 
       for(;;)
       {
-        u_int32_t endCombinedIndex =
+        uint32_t endCombinedIndex =
             (endGeneration * static_cast< uint32_t >(m_capacity)) + endIndex;
 
         if(circularDifference(endCombinedIndex, loadedCombinedIndex,
@@ -448,9 +448,9 @@ namespace llarp
         assert(0 < circularDifference(endCombinedIndex, loadedCombinedIndex,
                                       m_maxCombinedIndex + 1));
 
-        u_int32_t currIdx =
+        uint32_t currIdx =
             static_cast< uint32_t >(loadedCombinedIndex % m_capacity);
-        u_int32_t currGen =
+        uint32_t currGen =
             static_cast< uint32_t >(loadedCombinedIndex / m_capacity);
 
         // Try to swap this cell from Full to Reading.
diff --git a/llarp/service/context.cpp b/llarp/service/context.cpp
index e0faf8e65..f7a48148a 100644
--- a/llarp/service/context.cpp
+++ b/llarp/service/context.cpp
@@ -105,9 +105,9 @@ namespace llarp
       auto itr = m_Endpoints.begin();
       while(itr != m_Endpoints.end())
       {
-        if(itr->second->HasAddress(addr))
+        if(itr->second->HasAddress(addr.data()))
         {
-          ip = itr->second->ObtainIPForAddr(addr);
+          ip = itr->second->ObtainIPForAddr(addr.data());
           return true;
         }
         ++itr;
@@ -115,7 +115,7 @@ namespace llarp
       itr = m_Endpoints.find("default");
       if(itr != m_Endpoints.end())
       {
-        ip = itr->second->ObtainIPForAddr(addr);
+        ip = itr->second->ObtainIPForAddr(addr.data());
         return true;
       }
       return false;
diff --git a/llarp/service/endpoint.cpp b/llarp/service/endpoint.cpp
index 53d8a0f67..073c4585c 100644
--- a/llarp/service/endpoint.cpp
+++ b/llarp/service/endpoint.cpp
@@ -1506,7 +1506,8 @@ namespace llarp
     bool
     Endpoint::OutboundContext::SelectHop(llarp_nodedb* db,
                                          const RouterContact& prev,
-                                         RouterContact& cur, size_t hop)
+                                         RouterContact& cur, size_t hop,
+                                         llarp::path::PathRole roles)
     {
       if(m_NextIntro.router.IsZero())
         return false;
@@ -1527,8 +1528,7 @@ namespace llarp
           return false;
         }
       }
-      return path::Builder::SelectHop(db, prev, cur, hop,
-                                      llarp::path::ePathRoleOutboundHS);
+      return path::Builder::SelectHop(db, prev, cur, hop, roles);
     }
 
     uint64_t
diff --git a/llarp/threadpool.cpp b/llarp/threadpool.cpp
index 2959dfffe..b59b5f281 100644
--- a/llarp/threadpool.cpp
+++ b/llarp/threadpool.cpp
@@ -66,7 +66,6 @@ llarp_threadpool_stop(struct llarp_threadpool *pool)
 void
 llarp_threadpool_wait(struct llarp_threadpool *pool)
 {
-  llarp::util::Mutex mtx;
   llarp::LogDebug("threadpool wait");
   if(pool->impl)
   {
diff --git a/vendor/libtuntap-master/tuntap-unix.c b/vendor/libtuntap-master/tuntap-unix.c
index 228411668..d1e185338 100644
--- a/vendor/libtuntap-master/tuntap-unix.c
+++ b/vendor/libtuntap-master/tuntap-unix.c
@@ -36,16 +36,17 @@
 
 #include <arpa/inet.h>
 #include <netinet/in.h>
-#if defined Linux
-#include <netinet/ether.h>
+#if defined(Linux)
 #include <linux/if_tun.h>
+#include <linux/if_ether.h>
 #else
+
 #include <net/if.h>
-#if defined DragonFly
+#if defined(DragonFly)
 #include <net/tun/if_tun.h>
-#elif defined ANDROID
+#elif defined(ANDROID)
 #include <linux/if_tun.h>
-#elif !defined Darwin
+#elif !defined(Darwin)
 #include <net/if_tun.h>
 #endif
 #include <netinet/if_ether.h>