ns2gns

2 files changed, 354 insertions, 3 deletions

diff --git a/src/gns/Makefile.am b/src/gns/Makefile.am
index 45bacda3c..21c144d5a 100644
--- a/src/gns/Makefile.am
+++ b/src/gns/Makefile.am
@@ -293,6 +293,7 @@ gnunet_dns2gns_LDADD = \
   $(top_builddir)/src/gns/libgnunetgns.la \
   $(top_builddir)/src/util/libgnunetutil.la \
   $(top_builddir)/src/namestore/libgnunetnamestore.la \
+  $(top_builddir)/src/dns/libgnunetdnsparser.la \
   $(GN_LIBINTL)
 
 gnunet_gns_proxy_SOURCES = \
diff --git a/src/gns/gnunet-dns2gns.c b/src/gns/gnunet-dns2gns.c
index a33020f16..cb7abe6ec 100644
--- a/src/gns/gnunet-dns2gns.c
+++ b/src/gns/gnunet-dns2gns.c
@@ -24,21 +24,78 @@
  */
 #include "platform.h"
 #include <gnunet_util_lib.h>
-#include <gnunet_namestore_service.h>
+#include <gnunet_dnsparser_lib.h>
+#include <gnunet_gns_service.h>
+
+/**
+ * Timeout for DNS requests.
+ */
+#define TIMEOUT GNUNET_TIME_UNIT_MINUTES
 
 /**
  * Data kept per request.
  */
 struct Request
 {
+  /**
+   * Socket to use for sending the reply.
+   */
+  struct GNUNET_NETWORK_Handle *lsock;
+
+  /**
+   * Destination address to use.
+   */
+  const void *addr;
+
+  /**
+   * Initially, this is the DNS request, it will then be
+   * converted to the DNS response.
+   */
+  struct GNUNET_DNSPARSER_Packet *packet;
+  
+  /**
+   * Our GNS request handle.
+   */
+  struct GNUNET_GNS_LookupRequest *lookup;
+
+  /**
+   * Task run on timeout or shutdown to clean up without
+   * response.
+   */
+  GNUNET_SCHEDULER_TaskIdentifier timeout_task;
+
+  /**
+   * Number of bytes in 'addr'.
+   */ 
+  size_t addr_len;
 
 };
 
 
 /**
- * Listen socket.
+ * Handle to GNS resolver.
+ */
+struct GNUNET_GNS_Handle *gns;
+
+/**
+ * Listen socket for IPv4.
+ */
+static struct GNUNET_NETWORK_Handle *listen_socket4;
+
+/**
+ * Listen socket for IPv6.
+ */
+static struct GNUNET_NETWORK_Handle *listen_socket6;
+
+/**
+ * Task for IPv4 socket.
+ */
+static GNUNET_SCHEDULER_TaskIdentifier t4;
+
+/**
+ * Task for IPv6 socket.
  */
-static struct GNUNET_NETWORK_Handle *listen_socket;
+static GNUNET_SCHEDULER_TaskIdentifier t6;
 
 
 /**
@@ -51,6 +108,236 @@ static void
 do_shutdown (void *cls,
              const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
+  if (GNUNET_SCHEDULER_NO_TASK != t4)
+    GNUNET_SCHEDULER_cancel (t4);
+  if (GNUNET_SCHEDULER_NO_TASK != t6)
+    GNUNET_SCHEDULER_cancel (t6);
+  if (NULL != listen_socket4)
+  {
+    GNUNET_NETWORK_socket_close (listen_socket4);
+    listen_socket4 = NULL;
+  }
+  if (NULL != listen_socket6)
+  {
+    GNUNET_NETWORK_socket_close (listen_socket6);
+    listen_socket6 = NULL;
+  }
+  GNUNET_GNS_disconnect (gns);
+  gns = NULL;
+}
+
+
+/**
+ * Send the response for the given request and clean up.
+ *
+ * @param request context for the request.
+ */
+static void
+send_response (struct Request *request)
+{
+  char *buf;
+  size_t size;
+  
+  if (GNUNET_SYSERR ==
+      GNUNET_DNSPARSER_pack (request->packet,
+                             UINT16_MAX /* is this not too much? */,
+                             &buf,
+                             &size))
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                  _("Failed to pack DNS response into UDP packet!\n"));
+    }
+  else
+    {
+      if (size !=
+          GNUNET_NETWORK_socket_sendto (request->lsock,
+                                        buf, size,
+                                        request->addr,
+                                        request->addr_len))
+        GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "sendto");
+      GNUNET_free (buf);
+    }
+  GNUNET_SCHEDULER_cancel (request->timeout_task);
+  GNUNET_DNSPARSER_free_packet (request->packet);
+  GNUNET_free (request);
+}
+
+
+/**
+ * Task run on timeout.  Cleans up request.
+ *
+ * @param cls 'struct Request' of the request to clean up
+ * @param tc scheduler context
+ */
+static void
+do_timeout (void *cls,
+            const struct GNUNET_SCHEDULER_TaskContext *tc)
+{
+  struct Request *request = cls;
+
+  GNUNET_DNSPARSER_free_packet (request->packet);
+  GNUNET_GNS_cancel_lookup_request (request->lookup);
+  GNUNET_free (request);
+}
+
+
+/**
+ * Iterator called on obtained result for a GNS
+ * lookup
+ *
+ * @param cls closure
+ * @param name "name" of the original lookup
+ * @param rd_count number of records
+ * @param rd the records in reply
+ */
+static void
+result_processor (void *cls,
+                  uint32_t rd_count,
+                  const struct GNUNET_NAMESTORE_RecordData *rd)
+{
+  struct Request *request = cls;
+
+  // FIXME: is 'processor' called only once or
+  // possibly more than once?
+  request->lookup = NULL;
+  GNUNET_break (0);
+  // FIXME: convert 'rd' to response here...
+  send_response (request);
+}
+
+
+/**
+ * Handle DNS request.
+ *
+ * @param lsock socket to use for sending the reply
+ * @param addr address to use for sending the reply
+ * @param addr_len number of bytes in addr
+ * @param udp_msg DNS request payload
+ * @param udp_msg_size number of bytes in udp_msg 
+ */
+static void
+handle_request (struct GNUNET_NETWORK_Handle *lsock,
+                const void *addr,
+                size_t addr_len,
+                const char *udp_msg,
+                size_t udp_msg_size)
+{
+  struct Request *request;
+  struct GNUNET_DNSPARSER_Packet *packet;
+
+  packet = GNUNET_DNSPARSER_parse (udp_msg, udp_msg_size);
+  if (NULL == packet)
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                  _("Received malformed DNS request from %s\n"),
+                  GNUNET_a2s (addr, addr_len));
+      return;
+    }
+  request = GNUNET_malloc (sizeof (struct Request) + addr_len);
+  request->lsock = lsock;
+  request->packet = packet;
+  request->addr = &request[1];
+  request->addr_len = addr_len;
+  memcpy (&request[1], addr, addr_len);
+  request->timeout_task = GNUNET_SCHEDULER_add_delayed (TIMEOUT,
+                                                        &do_timeout,
+                                                        request);
+  // FIXME: extract name and type from 'request->packet'
+  const char *name = "foo";
+  enum GNUNET_GNS_RecordType type = GNUNET_GNS_RECORD_A;
+  request->lookup = GNUNET_GNS_lookup (gns,
+                                       name,
+                                       type,
+                                       GNUNET_NO,
+                                       NULL,
+                                       &result_processor,
+                                       request);
+}
+
+
+/**
+ * Task to read IPv4 DNS packets.
+ *
+ * @param cls the 'listen_socket4'
+ * @param tc scheduler context
+ */ 
+static void
+read_dns4 (void *cls,
+           const struct GNUNET_SCHEDULER_TaskContext *tc)
+{
+  struct sockaddr_in v4;
+  socklen_t addrlen;
+  ssize_t size;
+
+  GNUNET_assert (listen_socket4 == cls);
+  t4 = GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL,
+                                      listen_socket4,
+                                      &read_dns4,
+                                      listen_socket4);
+  if (0 == (GNUNET_SCHEDULER_REASON_READ_READY & tc->reason))
+    return; /* shutdown? */
+  size = GNUNET_NETWORK_socket_recvfrom_amount (listen_socket4);
+  if (0 > size)
+    {
+      GNUNET_break (0);
+      return; /* read error!? */
+    }
+  {
+    char buf[size];
+    
+    addrlen = sizeof (v4);
+    GNUNET_break (size == 
+                  GNUNET_NETWORK_socket_recvfrom (listen_socket4,
+                                                  buf,
+                                                  size,
+                                                  (struct sockaddr *) &v4,
+                                                  &addrlen));
+    handle_request (listen_socket4, &v4, addrlen,
+                    buf, size);
+  }
+}
+
+
+/**
+ * Task to read IPv6 DNS packets.
+ *
+ * @param cls the 'listen_socket6'
+ * @param tc scheduler context
+ */ 
+static void
+read_dns6 (void *cls,
+           const struct GNUNET_SCHEDULER_TaskContext *tc)
+{
+  struct sockaddr_in6 v6;
+  socklen_t addrlen;
+  ssize_t size;
+
+  GNUNET_assert (listen_socket6 == cls);
+  t6 = GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL,
+                                      listen_socket6,
+                                      &read_dns6,
+                                      listen_socket6);
+  if (0 == (GNUNET_SCHEDULER_REASON_READ_READY & tc->reason))
+    return; /* shutdown? */
+  size = GNUNET_NETWORK_socket_recvfrom_amount (listen_socket6);
+  if (0 > size)
+    {
+      GNUNET_break (0);
+      return; /* read error!? */
+    }
+  {
+    char buf[size];
+    
+    addrlen = sizeof (v6);
+    GNUNET_break (size == 
+                  GNUNET_NETWORK_socket_recvfrom (listen_socket6,
+                                                  buf,
+                                                  size,
+                                                  (struct sockaddr *) &v6,
+                                                  &addrlen));
+    handle_request (listen_socket6, &v6, addrlen,
+                    buf, size);
+  }
 }
 
 
@@ -66,6 +353,69 @@ static void
 run (void *cls, char *const *args, const char *cfgfile,
      const struct GNUNET_CONFIGURATION_Handle *cfg)
 {
+  gns = GNUNET_GNS_connect (cfg);
+  if (NULL == gns)
+    return;
+  listen_socket4 = GNUNET_NETWORK_socket_create (PF_INET,
+                                                 SOCK_DGRAM, 
+                                                 IPPROTO_UDP);
+  if (NULL != listen_socket4)
+    {
+      struct sockaddr_in v4;
+
+      memset (&v4, 0, sizeof (v4));
+      v4.sin_family = AF_INET;
+#if HAVE_SOCKADDR_IN_SIN_LEN
+      v4.sin_len = sizeof (v4);
+#endif
+      v4.sin_port = htons (53);
+      if (GNUNET_OK !=
+          GNUNET_NETWORK_socket_bind (listen_socket4,
+                                      (struct sockaddr *) &v4,
+                                      sizeof (v4)))
+        {
+          GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "bind");
+          GNUNET_NETWORK_socket_close (listen_socket4);
+          listen_socket4 = NULL;
+        }
+    }
+  listen_socket6 = GNUNET_NETWORK_socket_create (PF_INET6,
+                                                SOCK_DGRAM, 
+                                                IPPROTO_UDP);
+  if (NULL != listen_socket6)
+    {
+      struct sockaddr_in6 v6;
+
+      memset (&v6, 0, sizeof (v6));
+      v6.sin6_family = AF_INET6;
+#if HAVE_SOCKADDR_IN_SIN_LEN
+      v6.sin6_len = sizeof (v6);
+#endif
+      v6.sin6_port = htons (53);
+      if (GNUNET_OK !=
+          GNUNET_NETWORK_socket_bind (listen_socket6,
+                                      (struct sockaddr *) &v6,
+                                      sizeof (v6)))
+        {
+          GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "bind");
+          GNUNET_NETWORK_socket_close (listen_socket6);
+          listen_socket6 = NULL;
+        }
+    }
+  if ( (NULL == listen_socket4) &&
+       (NULL == listen_socket6) )
+    return;
+  if (NULL != listen_socket4)
+    t4 = GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL,
+                                        listen_socket4,
+                                        &read_dns4,
+                                        listen_socket4);
+  if (NULL != listen_socket6)
+    t6 = GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL,
+                                        listen_socket6,
+                                        &read_dns6,
+                                        listen_socket6);
+
   GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_FOREVER_REL,
                                 &do_shutdown, NULL);
 }