continue llarpification (StackBuffer) and other refactor

daemon/dns.cpp

@@ -20,6 +20,10 @@ handle_signal(int sig)
   done = true;
 }
 
+// FIXME: make configurable
+#define SERVER "8.8.8.8"
+#define PORT 53
+
 int
 main(int argc, char *argv[])
 {
@@ -37,6 +41,14 @@ main(int argc, char *argv[])
     
     llarp_ev_loop_alloc(&netloop);
     
+    struct dnsd_context dnsd;
+    if (!llarp_dnsd_init(&dnsd, netloop, "*", 53, SERVER, PORT))
+    {
+      llarp::LogError("Couldnt init dns daemon");
+      return 0;
+    }
+    
+    /*
     // configure main netloop
     llarp_udp_io *udp = new llarp_udp_io;
 
@@ -59,9 +71,13 @@ main(int argc, char *argv[])
       llarp::LogError("failed to bind to ", addr);
       return false;
     }
-
+    */
+    
+    //struct dnsc_context *dns_clinet_context = new dnsc_context;
+    //llarp_dnsc_init(dns_clinet_context, netloop, SERVER, PORT);
+    
     // singlethreaded
-    if (0)
+    if (1)
     {
       llarp::LogInfo("singlethread start");
       worker = llarp_init_same_process_threadpool();
@@ -76,7 +92,7 @@ main(int argc, char *argv[])
       worker = llarp_init_threadpool(2, "llarp-worker");
       logic = llarp_init_logic();
       auto netio = netloop;
-      int num_nethreads   = 1;
+      int num_nethreads   = 2;
       std::vector< std::thread > netio_threads;
       while(num_nethreads--)
       {

include/llarp/dns.h

@@ -10,9 +10,64 @@
  * dns client/server
  */
 
+
+// fwd declr
+struct dns_query;
+struct dnsc_context;
+
+typedef bool (*intercept_query_hook)(struct dnsc_context *, const dns_query *);
+
+struct dnsc_context
+{
+  /// DNS server hostname to use
+  //char *server;
+  /// DNS server port to use
+  //uint port;
+  /// Target: DNS server hostname/port to use
+  // FIXME: ipv6 it
+  sockaddr *server;
+  // where to create the new sockets
+  struct llarp_ev_loop *netloop;
+  // FIXME: UDP socket pooling (or maybe at the libev level)
+};
+
+struct dnsd_context
+{
+  /// DNS daemon port to listen on
+  struct llarp_udp_io udp;
+  dnsc_context client;
+  /// custom data for intercept query hook
+  void *user;
+  /// hook function for intercepting dns requests
+  intercept_query_hook intercept;
+};
+
+/// initialize dns subsystem and bind socket
+/// returns true on bind success otherwise returns false
+bool
+llarp_dnsc_init(struct dnsc_context *dnsc, struct llarp_ev_loop *netloop,
+               const char *dnsc_hostname, uint16_t dnsc_port);
+
+bool
+llarp_dnsc_stop(struct dnsc_context *dnsc);
+
+bool
+llarp_dnsc_unbind(struct dns_client_request *request);
+
+bool
+llarp_dnsc_bind(struct llarp_ev_loop *netloop, struct dns_client_request *request);
+
+/// initialize dns subsystem and bind socket
+/// returns true on bind success otherwise returns false
+bool
+llarp_dnsd_init(struct dnsd_context *dns, struct llarp_ev_loop *netloop,
+                const char *dnsd_ifname, uint16_t dnsd_port,
+                const char *dnsc_hostname, uint16_t dnsc_port);
+
 #define DNC_BUF_SIZE 512
 
-struct dns_query {
+struct dns_query
+{
   uint16_t length;
   char * url;
   unsigned char request[DNC_BUF_SIZE];
@@ -21,27 +76,43 @@ struct dns_query {
 
 struct dns_client_request;
 
-typedef void(*resolve_dns_hook_func)(dns_client_request *request, struct sockaddr *);
+// should we pass by llarp::Addr
+// not as long as we're supporting raw
+typedef void(*resolve_dns_hook_func)(dns_client_request *request);
 
+// FIXME: separate generic from llarp
 struct dns_client_request
 {
   /// sock type
-  void *sock;
+  void *sock; // pts to udp...
   /// customizeable (used for outer request)
   void *user;
   /// storage
   dns_query query;
   /// hook
   resolve_dns_hook_func resolved;
+  /// result
+  bool found;
+  struct sockaddr result;
+  /// Source: UDP port to use
+  // FIXME: separate socket for now
+  struct llarp_udp_io udp;
 };
 
+bool
+llarp_dnsc_bind(struct llarp_ev_loop *netloop,
+                struct dns_client_request *request);
+
 struct sockaddr *resolveHost(const char *url);
-bool llarp_resolve_host(struct llarp_ev_loop *, const char *url,
+bool llarp_resolve_host(struct dnsc_context *dns, const char *url,
                         resolve_dns_hook_func resolved, void *user);
+void
+llarp_host_resolved(dns_client_request *request);
 
 void
 llarp_handle_recvfrom(struct llarp_udp_io *udp, const struct sockaddr *saddr,
                 const void *buf, ssize_t sz);
+
 void
 raw_handle_recvfrom(int *sockfd, const struct sockaddr *saddr,
            const void *buf, ssize_t sz);

llarp/dnsc.cpp

@@ -1,4 +1,6 @@
+// why dnsd? what do you need from that?
 #include "dnsd.hpp"
+#include "buffer.hpp"
 
 #include <sys/types.h>
 #include <sys/socket.h>
@@ -13,6 +15,7 @@
 #include "logger.hpp"
 #include <llarp/dns.h>
 #include "net.hpp" // for llarp::Addr
+#include "net.hpp" // for llarp::Addr
 
 // FIXME: make configurable
 #define SERVER "8.8.8.8"
@@ -204,33 +207,18 @@ llarp_handle_dnsclient_recvfrom(struct llarp_udp_io *udp, const struct sockaddr
     // we can't call back the hook
     return;
   }
+  llarp_dnsc_unbind(request);
 
-  /*
-  // it's corrupt by here...
-  dns_request *server_request = (dns_request *)request->user;
-  llarp::LogInfo("server request ", server_request);
-  //llarp::LogInfo("server request hook ", server_request->hook);
-  llarp::Addr testAddr(*server_request->from);
-  llarp::LogInfo("HERE => server request addr ", testAddr, " ", server_request->from);
-
-  llarp::Addr testAddr2(saddr);
-  llarp::LogInfo("HERE => client request addr ", testAddr2, " ", &saddr);
-  */
-
-  //unsigned char buffer[DNC_BUF_SIZE];
-  unsigned char *buffer = (unsigned char *)buf;
-
-  //memset(&buffer, 0, DNC_BUF_SIZE);
-  //ret = recvfrom(sockfd, buffer, BUF_SIZE, 0, (struct sockaddr*)&addr, &size);
   if (sz < 0) {
     llarp::LogWarn("Error Receiving DNS Client Response");
-    request->resolved(request, nullptr);
+    request->resolved(request);
     return;
   }
 
-  //hexdump("received packet", &buffer, ret);
+  unsigned char *castBuf = (unsigned char *)buf;
+  auto buffer = llarp::StackBuffer< decltype(castBuf) >(castBuf);
 
-  llarp_ev_close_udp(udp);
+  //hexdump("received packet", &buffer, ret);
 
   uint16_t QDCOUNT; //No. of items in Question Section
   uint16_t ANCOUNT; //No. of items in Answer Section
@@ -246,7 +234,7 @@ llarp_handle_dnsclient_recvfrom(struct llarp_udp_io *udp, const struct sockaddr
   int length;
 
   struct dns_query *dnsQuery = &request->query;
-
+  
   rcode = (buffer[3] & 0x0F);
 
   //tempBuf[0] = buffer[4];
@@ -280,17 +268,15 @@ llarp_handle_dnsclient_recvfrom(struct llarp_udp_io *udp, const struct sockaddr
   MSGID = (uint16_t) buffer[0] * 0x100 + buffer[1];
   //llarp::LogDebug("answer msg id: %u\n", MSGID);
 
-
-
   if (rcode == 2) {
     llarp::LogWarn("nameserver %s returned SERVFAIL:\n", SERVER);
     llarp::LogWarn("  the name server was unable to process this query due to a\n  problem with the name server.\n");
-    request->resolved(request, nullptr);
+    request->resolved(request);
     return;
   } else if (rcode == 3) {
     llarp::LogWarn("nameserver %s returned NXDOMAIN for %s:\n", SERVER, dnsQuery->url);
     llarp::LogWarn("  the domain name referenced in the query does not exist\n");
-    request->resolved(request, nullptr);
+    request->resolved(request);
     return;
   }
 
@@ -304,14 +290,19 @@ llarp_handle_dnsclient_recvfrom(struct llarp_udp_io *udp, const struct sockaddr
       if (buffer[i] == 0xC0 && buffer[i+3] == 0x01) {
         ip++; i += 12; /* ! += buf[i+1]; */
         llarp::LogDebug(" %u.%u.%u.%u\n", buffer[i], buffer[i+1], buffer[i+2], buffer[i+3]);
+        
+        /*
         struct sockaddr *g_addr = new sockaddr;
         g_addr->sa_family = AF_INET;
         g_addr->sa_len = sizeof(in_addr);
         struct in_addr *addr = &((struct sockaddr_in *)g_addr)->sin_addr;
+        */
+
         unsigned char * ip;
 
         //have ip point to s_addr
-        ip = (unsigned char *) &(addr->s_addr);
+        //ip = (unsigned char *) &(addr->s_addr);
+        ip = (unsigned char *) &request->result;
 
         ip[0]=buffer[i + 0];
         ip[1]=buffer[i + 1];
@@ -319,14 +310,16 @@ llarp_handle_dnsclient_recvfrom(struct llarp_udp_io *udp, const struct sockaddr
         ip[3]=buffer[i + 3];
 
         //return g_addr;
-        request->resolved(request, g_addr);
+        //request->result = g_addr;
+        request->found = true;
+        request->resolved(request);
         return;
       }
     }
 
     if (!ip) {
       llarp::LogWarn("  No IPv4 address found in the DNS response!\n");
-      request->resolved(request, nullptr);
+      request->resolved(request);
       return;
     }
   }
@@ -335,9 +328,7 @@ llarp_handle_dnsclient_recvfrom(struct llarp_udp_io *udp, const struct sockaddr
 void build_dns_query(struct dns_query *dnsQuery)
 {
   dnsQuery->length  = 12;
-  //dnsQuery->url     = sUrl;
   dnsQuery->reqType = 0x01;
-  // dnsQuery.request  = { 0xDB, 0x42, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
   dnsQuery->request[ 0] = 0xDB;
   dnsQuery->request[ 1] = 0x42;
   dnsQuery->request[ 2] = 0x01;
@@ -372,84 +363,86 @@ void build_dns_query(struct dns_query *dnsQuery)
   dnsQuery->request[dnsQuery->length++] = 0x01;
 }
 
-bool llarp_dns_resolve(dns_client_request *request)
+bool llarp_resolve_host(struct dnsc_context *dnsc, const char *url, resolve_dns_hook_func resolved, void *user)
 {
+  dns_client_request *request = new dns_client_request;
+  request->sock      = (void *)&request->udp;
+  request->user      = user;
+  // configure query
+  request->query.url = strdup(url);
+  request->resolved  = resolved;
+  request->found     = false;
+  
+  // request address holds through the packet recv
+  request->udp.user = request;
+  
+  // finish setting up our query
   struct dns_query *dnsQuery = &request->query;
   build_dns_query(dnsQuery);
-  struct sockaddr_in *addr = new sockaddr_in;
-  //socklen_t size;
-  //unsigned char tempBuf[3];
-
-  memset(addr, 0, sizeof(sockaddr_in));
-  addr->sin_family = AF_INET;
-  addr->sin_addr.s_addr = inet_addr(SERVER);
-  addr->sin_port = htons(PORT);
-  //size = sizeof(addr);
-
-  llarp_udp_io *udp = (llarp_udp_io *)request->sock;
-  //llarp::LogInfo("dns client set to use ");
-
-  //hexdump("sending packet", &dnsQuery.request, dnsQuery.length);
-  //ret = sendto(sockfd, dnsQuery.request, dnsQuery.length, 0, (struct sockaddr*)&addr, size);
-  llarp::LogInfo("sending request");
-  //llarp::LogInfo("client request dest ", addr);
-  ssize_t ret = llarp_ev_udp_sendto(udp, (sockaddr *)addr, dnsQuery->request, dnsQuery->length);
+  
+  // build a socket per request because we're multithreaded and will have many inflight
+  if (!llarp_dnsc_bind(dnsc->netloop, request))
+  {
+    llarp::LogWarn("Error binding");
+    return false;
+  }
+  
+  ssize_t ret = llarp_ev_udp_sendto(&request->udp, dnsc->server, dnsQuery->request, dnsQuery->length);
   if (ret < 0) {
     llarp::LogWarn("Error Sending Request");
     return false;
   }
-  /*
-  dns_request *test = (dns_request *) request->user;
-  llarp::LogInfo("server request from ", test->from);
-  llarp::Addr testAddr(*test->from);
-  llarp::LogInfo("server request addr ", testAddr);
-   */
-
-  //printf("Sent\n");
-  llarp::LogInfo("Request sent, awaiting response");
+  
   return true;
 }
 
-bool llarp_resolve_host(struct llarp_ev_loop *netloop, const char *url, resolve_dns_hook_func resolved, void *user)
+void
+llarp_host_resolved(dns_client_request *request)
 {
-  struct sockaddr_in *s_addr = new sockaddr_in;
-  s_addr->sin_family = AF_INET;
-  s_addr->sin_addr.s_addr = inet_addr("0.0.0.0");
-
-  llarp_udp_io *udp = new llarp_udp_io;
-  //llarp::LogInfo("creating udp socket ", udp);
-  udp->tick   = nullptr;
-  udp->user   = nullptr;
-  udp->impl   = nullptr;
-  //udp->parent = netloop; // add_udp will do this...
-  //llarp::LogDebug("dns client set to use ");
-  udp->recvfrom = &llarp_handle_dnsclient_recvfrom;
+  delete request;
+}
 
-  dns_client_request *request = new dns_client_request;
-  //llarp::LogInfo("creating dnsc request ", request);
-  request->sock      = (void *)udp;
-  //llarp::LogInfo("setting server request ", user);
-  //dns_request *server_request = (dns_request *)user;
-  //llarp::LogInfo("server request ", server_request);
-  //llarp::LogInfo("server request hook ", server_request->hook);
-  //llarp::Addr test(*server_request->from);
-  //llarp::LogInfo("server request addr ", test);
-  request->user      = user;
-  request->query.url = strdup(url);
-  request->resolved  = resolved;
-  
-  // request address holds through the packet recv
-  //llarp::LogInfo("setting udp user ", request);
-  udp->user = request;
-  //llarp::LogInfo("client request src  ", s_addr);
+bool
+llarp_dnsc_bind(struct llarp_ev_loop *netloop, struct dns_client_request *request)
+{
+  // just grab a random open port
+  struct sockaddr_in srcaddr;
+  srcaddr.sin_addr.s_addr = inet_addr("0.0.0.0");
+  srcaddr.sin_family = AF_INET;
 
-  llarp::LogInfo("listening for response on ", udp);
-  if(llarp_ev_add_udp(netloop, udp, (sockaddr *)s_addr) == -1)
-  {
-    llarp::LogError("failed to bind resolver to");
-    return false;
-  }
+  request->udp.user      = request;
+  request->udp.recvfrom  = &llarp_handle_dnsclient_recvfrom;
+  request->udp.tick      = nullptr;
+
+  // create new listener for this request
+  return llarp_ev_add_udp(netloop, &request->udp, (const sockaddr *)&srcaddr) != -1;
+}
+
+// FIXME: drop the bool
+bool
+llarp_dnsc_unbind(struct dns_client_request *request)
+{
+  llarp_ev_close_udp(&request->udp); // stop listening
+  return true;
+}
 
-  llarp_dns_resolve(request);
+bool
+llarp_dnsc_init(struct dnsc_context *dnsc, struct llarp_ev_loop *netloop,
+               const char *dnsc_hostname, uint16_t dnsc_port)
+{
+  sockaddr_in *trgaddr = new sockaddr_in;
+  trgaddr->sin_addr.s_addr = inet_addr(dnsc_hostname);
+  trgaddr->sin_port = htons(dnsc_port);
+  trgaddr->sin_family = AF_INET;
+  dnsc->server = (sockaddr *)trgaddr;
+  dnsc->netloop = netloop;
+  return true;
+}
+
+bool
+llarp_dnsc_stop(struct dnsc_context *dnsc)
+{
+  //llarp_ev_close_udp(&dnsc->udp); // stop listening
+  delete (sockaddr_in *)dnsc->server; // deallocation
   return true;
 }

llarp/dnsd.cpp

@@ -162,7 +162,7 @@ writesend_dnss_response(struct sockaddr *hostRes, const struct sockaddr *from, d
   request->hook(request->user, from, buf, out_bytes);
 }
 
-void phase2(dns_client_request *client_request, struct sockaddr *result)
+void handle_dnsc_result(dns_client_request *client_request)
 {
   //llarp::LogInfo("phase2 client ", client_request);
   //writesend_dnss_response(struct sockaddr *hostRes, const struct sockaddr *from, dns_request *request)
@@ -170,7 +170,8 @@ void phase2(dns_client_request *client_request, struct sockaddr *result)
   //llarp::Addr test(*server_request->from);
   //llarp::LogInfo("server request sock ", server_request->from, " is ", test);
   //llarp::LogInfo("phase2 server ", server_request);
-  writesend_dnss_response(result, server_request->from, server_request);
+  writesend_dnss_response(client_request->found ? &client_request->result : nullptr, server_request->from, server_request);
+  llarp_host_resolved(client_request);
 }
 
 void
@@ -216,6 +217,8 @@ handle_recvfrom(const char *buffer, ssize_t nbytes, const struct sockaddr *from,
   }
 
   sockaddr *hostRes = nullptr;
+  // FIXME: how can we tell the mode?
+  //struct llarp_udp_io *udp = static_cast<struct llarp_udp_io *>(request->user);
   if (0)
   {
     hostRes = resolveHost(m_qName.c_str());
@@ -230,11 +233,12 @@ handle_recvfrom(const char *buffer, ssize_t nbytes, const struct sockaddr *from,
     //llarp::Addr anIp;
     //llarp::LogInfo("Checking server request ", request);
     struct llarp_udp_io *udp = (struct llarp_udp_io *)request->user;
+    dnsd_context *dnsd = (dnsd_context *)udp->user;
     //llarp::LogInfo("Server request UDP  ", request->user);
     //llarp::LogInfo("server request hook ", request->hook);
     //llarp::LogInfo("UDP ", udp);
     //hostRes = llarp_resolveHost(udp->parent, m_qName.c_str());
-    llarp_resolve_host(udp->parent, m_qName.c_str(), &phase2, (void *)request);
+    llarp_resolve_host(&dnsd->client, m_qName.c_str(), &handle_dnsc_result, (void *)request);
   }
 }
 
@@ -267,3 +271,27 @@ raw_handle_recvfrom(int *sockfd, const struct sockaddr *saddr,
   llarp_dns_request->hook = &raw_sendto_dns_hook_func;
   handle_recvfrom((char *)buf, sz, saddr, llarp_dns_request);
 }
+
+bool
+llarp_dnsd_init(struct dnsd_context *dnsd, struct llarp_ev_loop *netloop,
+                const char *dnsd_ifname, uint16_t dnsd_port,
+                const char *dnsc_hostname, uint16_t dnsc_port)
+{
+  struct sockaddr_in bindaddr;
+  bindaddr.sin_addr.s_addr = inet_addr("0.0.0.0");
+  bindaddr.sin_family  = AF_INET;
+  bindaddr.sin_port   = htons(dnsd_port);
+  
+  dnsd->udp.user      = dnsd;
+  dnsd->udp.recvfrom  = &llarp_handle_recvfrom;
+  dnsd->udp.tick      = nullptr;
+  
+  // configure dns client
+  if (!llarp_dnsc_init(&dnsd->client, netloop, dnsc_hostname, dnsc_port))
+  {
+    llarp::LogError("Couldnt init dns client");
+    return false;
+  }
+
+  return llarp_ev_add_udp(netloop, &dnsd->udp, (const sockaddr *)&bindaddr) != -1;
+}