-doxygen and style fixes

[oweals/gnunet.git] / src / util / resolver_api.c

diff --git a/src/util/resolver_api.c b/src/util/resolver_api.c
index ef48faf59f3c434ced735838906cf740e6f9629f..46ac52586c752c1bb8baff3f9728d04779a52578 100644 (file)
--- a/src/util/resolver_api.c
+++ b/src/util/resolver_api.c
@@ -1,10 +1,10 @@
 /*
      This file is part of GNUnet.
 /*
      This file is part of GNUnet.

-     (C) 2009, 2011 Christian Grothoff (and other contributing authors)
+     (C) 2009-2013 Christian Grothoff (and other contributing authors)

 
      GNUnet is free software; you can redistribute it and/or modify
      it under the terms of the GNU General Public License as published
 
      GNUnet is free software; you can redistribute it and/or modify
      it under the terms of the GNU General Public License as published

-     by the Free Software Foundation; either version 2, or (at your
+     by the Free Software Foundation; either version 3, or (at your

      option) any later version.
 
      GNUnet is distributed in the hope that it will be useful, but
      option) any later version.
 
      GNUnet is distributed in the hope that it will be useful, but


@@ -24,15 +24,15 @@
  * @author Christian Grothoff
  */
 #include "platform.h"
  * @author Christian Grothoff
  */
 #include "platform.h"

-#include "gnunet_getopt_lib.h"
-#include "gnunet_os_lib.h"
-#include "gnunet_client_lib.h"
-#include "gnunet_container_lib.h"
+#include "gnunet_util_lib.h"

 #include "gnunet_protocols.h"
 #include "gnunet_resolver_service.h"
 #include "gnunet_protocols.h"
 #include "gnunet_resolver_service.h"

-#include "gnunet_server_lib.h"

 #include "resolver.h"
 
 #include "resolver.h"
 

+#define LOG(kind,...) GNUNET_log_from (kind, "resolver-api", __VA_ARGS__)
+
+#define LOG_STRERROR(kind,syscall) GNUNET_log_from_strerror (kind, "resolver-api", syscall)
+

 /**
  * Maximum supported length for a hostname
  */
 /**
  * Maximum supported length for a hostname
  */


@@ -52,7 +52,7 @@ static const char *loopback[] = {
 /**
  * Configuration.
  */
 /**
  * Configuration.
  */

-static const struct GNUNET_CONFIGURATION_Handle *cfg;
+static const struct GNUNET_CONFIGURATION_Handle *resolver_cfg;

 
 /**
  * Our connection to the resolver service, created on-demand, but then
 
 /**
  * Our connection to the resolver service, created on-demand, but then


@@ -135,7 +135,7 @@ struct GNUNET_RESOLVER_RequestHandle
   /**
    * Desired address family.
    */
   /**
    * Desired address family.
    */

-  int domain;
+  int af;

 
   /**
    * Has this request been transmitted to the service?
 
   /**
    * Has this request been transmitted to the service?


@@ -172,7 +172,7 @@ struct GNUNET_RESOLVER_RequestHandle
  * (or equivalent).
  */
 static void
  * (or equivalent).
  */
 static void

-check_config (const struct GNUNET_CONFIGURATION_Handle *cfg)
+check_config ()

 {
   char *hostname;
   unsigned int i;
 {
   char *hostname;
   unsigned int i;


@@ -191,32 +191,30 @@ check_config (const struct GNUNET_CONFIGURATION_Handle *cfg)
   v6.sin6_len = sizeof (v6);
 #endif
   if (GNUNET_OK !=
   v6.sin6_len = sizeof (v6);
 #endif
   if (GNUNET_OK !=

-      GNUNET_CONFIGURATION_get_value_string (cfg,
-                                             "resolver", "HOSTNAME", &hostname))
+      GNUNET_CONFIGURATION_get_value_string (resolver_cfg, "resolver",
+                                             "HOSTNAME", &hostname))

   {
   {

-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                _("Must specify `%s' for `%s' in configuration!\n"),
-                "HOSTNAME", "resolver");
+    LOG (GNUNET_ERROR_TYPE_ERROR,
+         _("Must specify `%s' for `%s' in configuration!\n"), "HOSTNAME",
+         "resolver");

     GNUNET_assert (0);
   }
     GNUNET_assert (0);
   }

-  if ((1 != inet_pton (AF_INET,
-                       hostname,
-                       &v4)) || (1 != inet_pton (AF_INET6, hostname, &v6)))
+  if ((1 != inet_pton (AF_INET, hostname, &v4)) ||
+      (1 != inet_pton (AF_INET6, hostname, &v6)))

   {
     GNUNET_free (hostname);
     return;
   }
   i = 0;
   {
     GNUNET_free (hostname);
     return;
   }
   i = 0;

-  while (loopback[i] != NULL)
+  while (NULL != loopback[i])

     if (0 == strcasecmp (loopback[i++], hostname))
     {
       GNUNET_free (hostname);
       return;
     }
     if (0 == strcasecmp (loopback[i++], hostname))
     {
       GNUNET_free (hostname);
       return;
     }

-  GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-              _
-              ("Must specify `%s' or numeric IP address for `%s' of `%s' in configuration!\n"),
-              "localhost", "HOSTNAME", "resolver");
+  LOG (GNUNET_ERROR_TYPE_ERROR,
+       _("Must specify `%s' or numeric IP address for `%s' of `%s' in configuration!\n"),
+       "localhost", "HOSTNAME", "resolver");

   GNUNET_free (hostname);
   GNUNET_assert (0);
 }
   GNUNET_free (hostname);
   GNUNET_assert (0);
 }


@@ -225,15 +223,15 @@ check_config (const struct GNUNET_CONFIGURATION_Handle *cfg)
 /**
  * Create the connection to the resolver service.
  *
 /**
  * Create the connection to the resolver service.
  *

- * @param c configuration to use
+ * @param cfg configuration to use

  */
 void
  */
 void

-GNUNET_RESOLVER_connect (const struct GNUNET_CONFIGURATION_Handle *c)
+GNUNET_RESOLVER_connect (const struct GNUNET_CONFIGURATION_Handle *cfg)

 {
 {

-  GNUNET_assert (NULL != c);
-  check_config (c);
+  GNUNET_assert (NULL != cfg);

   backoff = GNUNET_TIME_UNIT_MILLISECONDS;
   backoff = GNUNET_TIME_UNIT_MILLISECONDS;

-  cfg = c;
+  resolver_cfg = cfg;
+  check_config ();

 }
 
 
 }
 
 


@@ -247,18 +245,16 @@ GNUNET_RESOLVER_disconnect ()
   GNUNET_assert (NULL == req_tail);
   if (NULL != client)
   {
   GNUNET_assert (NULL == req_tail);
   if (NULL != client)
   {

-#if DEBUG_RESOLVER
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Disconnecting from DNS service\n");
-#endif
-    GNUNET_CLIENT_disconnect (client, GNUNET_NO);
+    LOG (GNUNET_ERROR_TYPE_DEBUG, "Disconnecting from DNS service\n");
+    GNUNET_CLIENT_disconnect (client);

     client = NULL;
   }
     client = NULL;
   }

-  if (r_task != GNUNET_SCHEDULER_NO_TASK)
+  if (GNUNET_SCHEDULER_NO_TASK != r_task)

   {
     GNUNET_SCHEDULER_cancel (r_task);
     r_task = GNUNET_SCHEDULER_NO_TASK;
   }
   {
     GNUNET_SCHEDULER_cancel (r_task);
     r_task = GNUNET_SCHEDULER_NO_TASK;
   }

-  if (s_task != GNUNET_SCHEDULER_NO_TASK)
+  if (GNUNET_SCHEDULER_NO_TASK != s_task)

   {
     GNUNET_SCHEDULER_cancel (s_task);
     s_task = GNUNET_SCHEDULER_NO_TASK;
   {
     GNUNET_SCHEDULER_cancel (s_task);
     s_task = GNUNET_SCHEDULER_NO_TASK;


@@ -269,67 +265,59 @@ GNUNET_RESOLVER_disconnect ()
 /**
  * Convert IP address to string without DNS resolution.
  *
 /**
  * Convert IP address to string without DNS resolution.
  *

- * @param sa the address 
- * @param salen number of bytes in sa
+ * @param af address family
+ * @param ip the address
+ * @param ip_len number of bytes in ip

  * @return address as a string, NULL on error
  */
 static char *
  * @return address as a string, NULL on error
  */
 static char *

-no_resolve (const struct sockaddr *sa, socklen_t salen)
+no_resolve (int af,
+           const void *ip, socklen_t ip_len)

 {
 {

-  char *ret;
-  char inet4[INET_ADDRSTRLEN];
-  char inet6[INET6_ADDRSTRLEN];
+  char buf[INET6_ADDRSTRLEN];

 
 

-  if (salen < sizeof (struct sockaddr))
-    return NULL;
-  switch (sa->sa_family)
+  switch (af)

   {
   case AF_INET:
   {
   case AF_INET:

-    if (salen != sizeof (struct sockaddr_in))
+    if (ip_len != sizeof (struct in_addr))

       return NULL;
     if (NULL ==
       return NULL;
     if (NULL ==

-        inet_ntop (AF_INET,
-                   &((struct sockaddr_in *) sa)->sin_addr,
-                   inet4, INET_ADDRSTRLEN))
+        inet_ntop (AF_INET, ip, buf, sizeof (buf)))

     {
     {

-      GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "inet_ntop");
+      LOG_STRERROR (GNUNET_ERROR_TYPE_WARNING, "inet_ntop");

       return NULL;
     }
       return NULL;
     }

-    ret = GNUNET_strdup (inet4);

     break;
   case AF_INET6:
     break;
   case AF_INET6:

-    if (salen != sizeof (struct sockaddr_in6))
+    if (ip_len != sizeof (struct in6_addr))

       return NULL;
     if (NULL ==
       return NULL;
     if (NULL ==

-        inet_ntop (AF_INET6,
-                   &((struct sockaddr_in6 *) sa)->sin6_addr,
-                   inet6, INET6_ADDRSTRLEN))
+        inet_ntop (AF_INET6, ip, buf, sizeof (buf)))

     {
     {

-      GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "inet_ntop");
+      LOG_STRERROR (GNUNET_ERROR_TYPE_WARNING, "inet_ntop");

       return NULL;
     }
       return NULL;
     }

-    ret = GNUNET_strdup (inet6);

     break;
   default:
     break;
   default:

-    ret = NULL;
-    break;
+    GNUNET_break (0);
+    return NULL;

   }
   }

-  return ret;
+  return GNUNET_strdup (buf);

 }
 
 
 /**
  * Adjust exponential back-off and reconnect to the service.
  */
 }
 
 
 /**
  * Adjust exponential back-off and reconnect to the service.
  */

-static void reconnect ();
+static void
+reconnect ();

 
 
 /**
  * Process pending requests to the resolver.
 
 
 /**
  * Process pending requests to the resolver.

- *
- * @param h handle to the resolver

  */
  */

-static void process_requests ();
+static void
+process_requests ();

 
 
 /**
 
 
 /**


@@ -343,33 +331,32 @@ handle_response (void *cls, const struct GNUNET_MessageHeader *msg)
 {
   struct GNUNET_RESOLVER_RequestHandle *rh = cls;
   uint16_t size;
 {
   struct GNUNET_RESOLVER_RequestHandle *rh = cls;
   uint16_t size;

-  const char *hostname;
-  const struct sockaddr *sa;
-  socklen_t salen;

 
 

-#if DEBUG_RESOLVER
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Receiving response from DNS service\n");
-#endif
-  if (msg == NULL)
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Receiving response from DNS service\n");
+  if (NULL == msg)

   {
   {

+    char buf[INET6_ADDRSTRLEN];
+

     if (NULL != rh->name_callback)
     if (NULL != rh->name_callback)

-      GNUNET_log (GNUNET_ERROR_TYPE_INFO,
-                  _("Timeout trying to resolve IP address `%s'.\n"),
-                  GNUNET_a2s ((const void *) &rh[1], rh->data_len));
+      LOG (GNUNET_ERROR_TYPE_INFO,
+           _("Timeout trying to resolve IP address `%s'.\n"),
+           inet_ntop (rh->af, (const void *) &rh[1], buf, sizeof(buf)));

     else
     else

-      GNUNET_log (GNUNET_ERROR_TYPE_INFO,
-                  _("Timeout trying to resolve hostname `%s'.\n"),
-                  (const char *) &rh[1]);
+      LOG (GNUNET_ERROR_TYPE_INFO,
+           _("Timeout trying to resolve hostname `%s'.\n"),
+           (const char *) &rh[1]);

     /* check if request was canceled */
     /* check if request was canceled */

-    if (rh->was_transmitted != GNUNET_SYSERR)
+    if (GNUNET_SYSERR != rh->was_transmitted)

     {
       if (NULL != rh->name_callback)
       {
         /* no reverse lookup was successful, return ip as string */
         if (rh->received_response == GNUNET_NO)
     {
       if (NULL != rh->name_callback)
       {
         /* no reverse lookup was successful, return ip as string */
         if (rh->received_response == GNUNET_NO)

-          rh->name_callback (rh->cls,
-                             no_resolve ((const struct sockaddr *) &rh[1],
-                                         rh->data_len));
+        {
+          rh->name_callback (rh->cls, no_resolve (rh->af, &rh[1], rh->data_len));
+          rh->name_callback (rh->cls, NULL);
+        }

         /* at least one reverse lookup was successful */
         else
           rh->name_callback (rh->cls, NULL);
         /* at least one reverse lookup was successful */
         else
           rh->name_callback (rh->cls, NULL);


@@ -379,7 +366,7 @@ handle_response (void *cls, const struct GNUNET_MessageHeader *msg)
     }
     GNUNET_CONTAINER_DLL_remove (req_head, req_tail, rh);
     GNUNET_free (rh);
     }
     GNUNET_CONTAINER_DLL_remove (req_head, req_tail, rh);
     GNUNET_free (rh);

-    GNUNET_CLIENT_disconnect (client, GNUNET_NO);
+    GNUNET_CLIENT_disconnect (client);

     client = NULL;
     reconnect ();
     return;
     client = NULL;
     reconnect ();
     return;


@@ -387,7 +374,7 @@ handle_response (void *cls, const struct GNUNET_MessageHeader *msg)
   if (GNUNET_MESSAGE_TYPE_RESOLVER_RESPONSE != ntohs (msg->type))
   {
     GNUNET_break (0);
   if (GNUNET_MESSAGE_TYPE_RESOLVER_RESPONSE != ntohs (msg->type))
   {
     GNUNET_break (0);

-    GNUNET_CLIENT_disconnect (client, GNUNET_NO);
+    GNUNET_CLIENT_disconnect (client);

     client = NULL;
     reconnect ();
     return;
     client = NULL;
     reconnect ();
     return;


@@ -412,6 +399,8 @@ handle_response (void *cls, const struct GNUNET_MessageHeader *msg)
   /* return reverse lookup results to caller */
   if (NULL != rh->name_callback)
   {
   /* return reverse lookup results to caller */
   if (NULL != rh->name_callback)
   {

+    const char *hostname;
+

     hostname = (const char *) &msg[1];
     if (hostname[size - sizeof (struct GNUNET_MessageHeader) - 1] != '\0')
     {
     hostname = (const char *) &msg[1];
     if (hostname[size - sizeof (struct GNUNET_MessageHeader) - 1] != '\0')
     {


@@ -420,62 +409,74 @@ handle_response (void *cls, const struct GNUNET_MessageHeader *msg)
         rh->name_callback (rh->cls, NULL);
       GNUNET_CONTAINER_DLL_remove (req_head, req_tail, rh);
       GNUNET_free (rh);
         rh->name_callback (rh->cls, NULL);
       GNUNET_CONTAINER_DLL_remove (req_head, req_tail, rh);
       GNUNET_free (rh);

-      GNUNET_CLIENT_disconnect (client, GNUNET_NO);
+      GNUNET_CLIENT_disconnect (client);

       client = NULL;
       reconnect ();
       return;
     }
       client = NULL;
       reconnect ();
       return;
     }

-#if DEBUG_RESOLVER
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                _("Resolver returns `%s' for IP `%s'.\n"),
-                hostname, GNUNET_a2s ((const void *) &rh[1], rh->data_len));
-#endif
+    LOG (GNUNET_ERROR_TYPE_DEBUG, "Resolver returns `%s' for IP `%s'.\n",
+         hostname, GNUNET_a2s ((const void *) &rh[1], rh->data_len));

     if (rh->was_transmitted != GNUNET_SYSERR)
       rh->name_callback (rh->cls, hostname);
     rh->received_response = GNUNET_YES;
     if (rh->was_transmitted != GNUNET_SYSERR)
       rh->name_callback (rh->cls, hostname);
     rh->received_response = GNUNET_YES;

-    GNUNET_CLIENT_receive (client,
-                           &handle_response,
-                           rh,
+    GNUNET_CLIENT_receive (client, &handle_response, rh,

                            GNUNET_TIME_absolute_get_remaining (rh->timeout));
   }
   /* return lookup results to caller */
   if (NULL != rh->addr_callback)
   {
                            GNUNET_TIME_absolute_get_remaining (rh->timeout));
   }
   /* return lookup results to caller */
   if (NULL != rh->addr_callback)
   {

-    sa = (const struct sockaddr *) &msg[1];
-    salen = size - sizeof (struct GNUNET_MessageHeader);
-    if (salen < sizeof (struct sockaddr))
+    struct sockaddr_in v4;
+    struct sockaddr_in6 v6;
+    const struct sockaddr *sa;
+    socklen_t salen;
+    const void *ip;
+    size_t ip_len;
+
+    ip = &msg[1];
+    ip_len = size - sizeof (struct GNUNET_MessageHeader);
+    if (ip_len == sizeof (struct in_addr))
+    {
+      memset (&v4, 0, sizeof (v4));
+      v4.sin_family = AF_INET;
+      v4.sin_addr = *(struct in_addr*) ip;
+#if HAVE_SOCKADDR_IN_SIN_LEN
+      v4.sin_len = sizeof (v4);
+#endif
+      salen = sizeof (v4);
+      sa = (const struct sockaddr *) &v4;
+    }
+    else if (ip_len == sizeof (struct in6_addr))
+    {
+      memset (&v6, 0, sizeof (v6));
+      v6.sin6_family = AF_INET6;
+      v6.sin6_addr = *(struct in6_addr*) ip;
+#if HAVE_SOCKADDR_IN_SIN_LEN
+      v6.sin6_len = sizeof (v6);
+#endif
+      salen = sizeof (v6);
+      sa = (const struct sockaddr *) &v6;
+    }
+    else

     {
       GNUNET_break (0);
       if (rh->was_transmitted != GNUNET_SYSERR)
         rh->addr_callback (rh->cls, NULL, 0);
       GNUNET_CONTAINER_DLL_remove (req_head, req_tail, rh);
       GNUNET_free (rh);
     {
       GNUNET_break (0);
       if (rh->was_transmitted != GNUNET_SYSERR)
         rh->addr_callback (rh->cls, NULL, 0);
       GNUNET_CONTAINER_DLL_remove (req_head, req_tail, rh);
       GNUNET_free (rh);

-      GNUNET_CLIENT_disconnect (client, GNUNET_NO);
+      GNUNET_CLIENT_disconnect (client);

       client = NULL;
       reconnect ();
       return;
     }
       client = NULL;
       reconnect ();
       return;
     }

-#if DEBUG_RESOLVER
-    {
-      char *ips = no_resolve (sa, salen);
-
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Resolver returns `%s' for `%s'.\n",
-                  ips, (const char *) &rh[1]);
-      GNUNET_free (ips);
-    }
-#endif

     rh->addr_callback (rh->cls, sa, salen);
     rh->addr_callback (rh->cls, sa, salen);

-    GNUNET_CLIENT_receive (client,
-                           &handle_response,
-                           rh,
+    GNUNET_CLIENT_receive (client, &handle_response, rh,

                            GNUNET_TIME_absolute_get_remaining (rh->timeout));
   }
 }
 
 
 /**
                            GNUNET_TIME_absolute_get_remaining (rh->timeout));
   }
 }
 
 
 /**

- * We've been asked to lookup the address for a hostname and were 
+ * We've been asked to lookup the address for a hostname and were

  * given a valid numeric string.  Perform the callbacks for the
  * numeric addresses.
  *
  * given a valid numeric string.  Perform the callbacks for the
  * numeric addresses.
  *


@@ -501,11 +502,11 @@ numeric_resolution (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
   v6.sin6_len = sizeof (v6);
 #endif
   hostname = (const char *) &rh[1];
   v6.sin6_len = sizeof (v6);
 #endif
   hostname = (const char *) &rh[1];

-  if (((rh->domain == AF_UNSPEC) || (rh->domain == AF_INET)) &&
+  if (((rh->af == AF_UNSPEC) || (rh->af == AF_INET)) &&

       (1 == inet_pton (AF_INET, hostname, &v4.sin_addr)))
   {
     rh->addr_callback (rh->cls, (const struct sockaddr *) &v4, sizeof (v4));
       (1 == inet_pton (AF_INET, hostname, &v4.sin_addr)))
   {
     rh->addr_callback (rh->cls, (const struct sockaddr *) &v4, sizeof (v4));

-    if ((rh->domain == AF_UNSPEC) &&
+    if ((rh->af == AF_UNSPEC) &&

         (1 == inet_pton (AF_INET6, hostname, &v6.sin6_addr)))
     {
       /* this can happen on some systems IF "hostname" is "localhost" */
         (1 == inet_pton (AF_INET6, hostname, &v6.sin6_addr)))
     {
       /* this can happen on some systems IF "hostname" is "localhost" */


@@ -515,7 +516,7 @@ numeric_resolution (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
     GNUNET_free (rh);
     return;
   }
     GNUNET_free (rh);
     return;
   }

-  if (((rh->domain == AF_UNSPEC) || (rh->domain == AF_INET6)) &&
+  if (((rh->af == AF_UNSPEC) || (rh->af == AF_INET6)) &&

       (1 == inet_pton (AF_INET6, hostname, &v6.sin6_addr)))
   {
     rh->addr_callback (rh->cls, (const struct sockaddr *) &v6, sizeof (v6));
       (1 == inet_pton (AF_INET6, hostname, &v6.sin6_addr)))
   {
     rh->addr_callback (rh->cls, (const struct sockaddr *) &v6, sizeof (v6));


@@ -530,7 +531,7 @@ numeric_resolution (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 
 
 /**
 
 
 /**

- * We've been asked to lookup the address for a hostname and were 
+ * We've been asked to lookup the address for a hostname and were

  * given a variant of "loopback".  Perform the callbacks for the
  * respective loopback numeric addresses.
  *
  * given a variant of "loopback".  Perform the callbacks for the
  * respective loopback numeric addresses.
  *


@@ -556,7 +557,7 @@ loopback_resolution (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
   v6.sin6_len = sizeof (v6);
 #endif
   v6.sin6_addr = in6addr_loopback;
   v6.sin6_len = sizeof (v6);
 #endif
   v6.sin6_addr = in6addr_loopback;

-  switch (rh->domain)
+  switch (rh->af)

   {
   case AF_INET:
     rh->addr_callback (rh->cls, (const struct sockaddr *) &v4, sizeof (v4));
   {
   case AF_INET:
     rh->addr_callback (rh->cls, (const struct sockaddr *) &v4, sizeof (v4));


@@ -581,23 +582,23 @@ loopback_resolution (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
  * Task executed on system shutdown.
  */
 static void
  * Task executed on system shutdown.
  */
 static void

-shutdown_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+shutdown_task (void *cls,
+              const struct GNUNET_SCHEDULER_TaskContext *tc)

 {
   s_task = GNUNET_SCHEDULER_NO_TASK;
   GNUNET_RESOLVER_disconnect ();
 {
   s_task = GNUNET_SCHEDULER_NO_TASK;
   GNUNET_RESOLVER_disconnect ();

+  backoff = GNUNET_TIME_UNIT_MILLISECONDS;

 }
 
 
 /**
  * Process pending requests to the resolver.
 }
 
 
 /**
  * Process pending requests to the resolver.

- *
- * @param h handle to the resolver

  */
 static void
 process_requests ()
 {
   struct GNUNET_RESOLVER_GetMessage *msg;
  */
 static void
 process_requests ()
 {
   struct GNUNET_RESOLVER_GetMessage *msg;

-  char buf[GNUNET_SERVER_MAX_MESSAGE_SIZE - 1];
+  char buf[GNUNET_SERVER_MAX_MESSAGE_SIZE - 1] GNUNET_ALIGN;

   struct GNUNET_RESOLVER_RequestHandle *rh;
 
   if (NULL == client)
   struct GNUNET_RESOLVER_RequestHandle *rh;
 
   if (NULL == client)


@@ -610,8 +611,9 @@ process_requests ()
   {
     /* nothing to do, release socket really soon if there is nothing
      * else happening... */
   {
     /* nothing to do, release socket really soon if there is nothing
      * else happening... */

-    s_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_MILLISECONDS,
-                                           &shutdown_task, NULL);
+    s_task =
+        GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_MILLISECONDS,
+                                      &shutdown_task, NULL);

     return;
   }
   if (GNUNET_YES == rh->was_transmitted)
     return;
   }
   if (GNUNET_YES == rh->was_transmitted)


@@ -621,21 +623,19 @@ process_requests ()
       htons (sizeof (struct GNUNET_RESOLVER_GetMessage) + rh->data_len);
   msg->header.type = htons (GNUNET_MESSAGE_TYPE_RESOLVER_REQUEST);
   msg->direction = htonl (rh->direction);
       htons (sizeof (struct GNUNET_RESOLVER_GetMessage) + rh->data_len);
   msg->header.type = htons (GNUNET_MESSAGE_TYPE_RESOLVER_REQUEST);
   msg->direction = htonl (rh->direction);

-  msg->domain = htonl (rh->domain);
+  msg->af = htonl (rh->af);

   memcpy (&msg[1], &rh[1], rh->data_len);
   memcpy (&msg[1], &rh[1], rh->data_len);

-#if DEBUG_RESOLVER
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Transmitting DNS resolution request to DNS service\n");
-#endif
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Transmitting DNS resolution request to DNS service\n");

   if (GNUNET_OK !=
   if (GNUNET_OK !=

-      GNUNET_CLIENT_transmit_and_get_response (client,
-                                               &msg->header,
+      GNUNET_CLIENT_transmit_and_get_response (client, &msg->header,

                                                GNUNET_TIME_absolute_get_remaining
                                                (rh->timeout), GNUNET_YES,
                                                &handle_response, rh))
   {
                                                GNUNET_TIME_absolute_get_remaining
                                                (rh->timeout), GNUNET_YES,
                                                &handle_response, rh))
   {

-    GNUNET_CLIENT_disconnect (client, GNUNET_NO);
+    GNUNET_CLIENT_disconnect (client);

     client = NULL;
     client = NULL;

+    GNUNET_break (0);

     reconnect ();
     return;
   }
     reconnect ();
     return;
   }


@@ -657,14 +657,13 @@ reconnect_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
     return;                     /* no work pending */
   if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN))
     return;
     return;                     /* no work pending */
   if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN))
     return;

-#if DEBUG_RESOLVER
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Trying to connect to DNS service\n");
-#endif
-  client = GNUNET_CLIENT_connect ("resolver", cfg);
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Trying to connect to DNS service\n");
+  client = GNUNET_CLIENT_connect ("resolver", resolver_cfg);

   if (NULL == client)
   {
   if (NULL == client)
   {

-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                "Failed to connect, will try again later\n");
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+        "Failed to connect, will try again later\n");

     reconnect ();
     return;
   }
     reconnect ();
     return;
   }


@@ -704,14 +703,12 @@ reconnect ()
       break;
     }
   }
       break;
     }
   }

-#if DEBUG_RESOLVER
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Will try to connect to DNS service in %llu ms\n",
-              (unsigned long long) backoff.rel_value);
-#endif
-  GNUNET_assert (NULL != cfg);
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Will try to connect to DNS service in %s\n",
+       GNUNET_STRINGS_relative_time_to_string (backoff, GNUNET_YES));
+  GNUNET_assert (NULL != resolver_cfg);

   r_task = GNUNET_SCHEDULER_add_delayed (backoff, &reconnect_task, NULL);
   r_task = GNUNET_SCHEDULER_add_delayed (backoff, &reconnect_task, NULL);

-  backoff = GNUNET_TIME_relative_multiply (backoff, 2);
+  backoff = GNUNET_TIME_STD_BACKOFF (backoff);

 }
 
 
 }
 
 


@@ -719,15 +716,14 @@ reconnect ()
  * Convert a string to one or more IP addresses.
  *
  * @param hostname the hostname to resolve
  * Convert a string to one or more IP addresses.
  *
  * @param hostname the hostname to resolve

- * @param domain AF_INET or AF_INET6; use AF_UNSPEC for "any"
+ * @param af AF_INET or AF_INET6; use AF_UNSPEC for "any"

  * @param callback function to call with addresses
  * @param callback_cls closure for callback
  * @param timeout how long to try resolving
  * @return handle that can be used to cancel the request, NULL on error
  */
 struct GNUNET_RESOLVER_RequestHandle *
  * @param callback function to call with addresses
  * @param callback_cls closure for callback
  * @param timeout how long to try resolving
  * @return handle that can be used to cancel the request, NULL on error
  */
 struct GNUNET_RESOLVER_RequestHandle *

-GNUNET_RESOLVER_ip_get (const char *hostname,
-                        int domain,
+GNUNET_RESOLVER_ip_get (const char *hostname, int af,

                         struct GNUNET_TIME_Relative timeout,
                         GNUNET_RESOLVER_AddressCallback callback,
                         void *callback_cls)
                         struct GNUNET_TIME_Relative timeout,
                         GNUNET_RESOLVER_AddressCallback callback,
                         void *callback_cls)


@@ -746,7 +742,7 @@ GNUNET_RESOLVER_ip_get (const char *hostname,
     return NULL;
   }
   rh = GNUNET_malloc (sizeof (struct GNUNET_RESOLVER_RequestHandle) + slen);
     return NULL;
   }
   rh = GNUNET_malloc (sizeof (struct GNUNET_RESOLVER_RequestHandle) + slen);

-  rh->domain = domain;
+  rh->af = af;

   rh->addr_callback = callback;
   rh->cls = callback_cls;
   memcpy (&rh[1], hostname, slen);
   rh->addr_callback = callback;
   rh->cls = callback_cls;
   memcpy (&rh[1], hostname, slen);


@@ -754,21 +750,17 @@ GNUNET_RESOLVER_ip_get (const char *hostname,
   rh->timeout = GNUNET_TIME_relative_to_absolute (timeout);
   rh->direction = GNUNET_NO;
   /* first, check if this is a numeric address */
   rh->timeout = GNUNET_TIME_relative_to_absolute (timeout);
   rh->direction = GNUNET_NO;
   /* first, check if this is a numeric address */

-  if (((1 == inet_pton (AF_INET,
-                        hostname,
-                        &v4)) &&
-       ((domain == AF_INET) || (domain == AF_UNSPEC))) ||
-      ((1 == inet_pton (AF_INET6,
-                        hostname,
-                        &v6)) &&
-       ((domain == AF_INET6) || (domain == AF_UNSPEC))))
+  if (((1 == inet_pton (AF_INET, hostname, &v4)) &&
+       ((af == AF_INET) || (af == AF_UNSPEC))) ||
+      ((1 == inet_pton (AF_INET6, hostname, &v6)) &&
+       ((af == AF_INET6) || (af == AF_UNSPEC))))

   {
     rh->task = GNUNET_SCHEDULER_add_now (&numeric_resolution, rh);
     return rh;
   }
   /* then, check if this is a loopback address */
   i = 0;
   {
     rh->task = GNUNET_SCHEDULER_add_now (&numeric_resolution, rh);
     return rh;
   }
   /* then, check if this is a loopback address */
   i = 0;

-  while (loopback[i] != NULL)
+  while (NULL != loopback[i])

     if (0 == strcasecmp (loopback[i++], hostname))
     {
       rh->task = GNUNET_SCHEDULER_add_now (&loopback_resolution, rh);
     if (0 == strcasecmp (loopback[i++], hostname))
     {
       rh->task = GNUNET_SCHEDULER_add_now (&loopback_resolution, rh);


@@ -799,10 +791,8 @@ numeric_reverse (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
   struct GNUNET_RESOLVER_RequestHandle *rh = cls;
   char *result;
 
   struct GNUNET_RESOLVER_RequestHandle *rh = cls;
   char *result;
 

-  result = no_resolve ((const struct sockaddr *) &rh[1], rh->data_len);
-#if DEBUG_RESOLVER
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, _("Resolver returns `%s'.\n"), result);
-#endif
+  result = no_resolve (rh->af, &rh[1], rh->data_len);
+  LOG (GNUNET_ERROR_TYPE_DEBUG, "Resolver returns `%s'.\n", result);

   if (result != NULL)
   {
     rh->name_callback (rh->cls, result);
   if (result != NULL)
   {
     rh->name_callback (rh->cls, result);


@@ -826,22 +816,38 @@ numeric_reverse (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
  * @return handle that can be used to cancel the request
  */
 struct GNUNET_RESOLVER_RequestHandle *
  * @return handle that can be used to cancel the request
  */
 struct GNUNET_RESOLVER_RequestHandle *

-GNUNET_RESOLVER_hostname_get (const struct sockaddr *sa,
-                              socklen_t salen,
+GNUNET_RESOLVER_hostname_get (const struct sockaddr *sa, socklen_t salen,

                               int do_resolve,
                               struct GNUNET_TIME_Relative timeout,
                               GNUNET_RESOLVER_HostnameCallback callback,
                               void *cls)
 {
   struct GNUNET_RESOLVER_RequestHandle *rh;
                               int do_resolve,
                               struct GNUNET_TIME_Relative timeout,
                               GNUNET_RESOLVER_HostnameCallback callback,
                               void *cls)
 {
   struct GNUNET_RESOLVER_RequestHandle *rh;

+  size_t ip_len;
+  const void *ip;

 
 

-  check_config (cfg);
+  check_config ();
+  switch (sa->sa_family)
+  {
+  case AF_INET:
+    ip_len = sizeof (struct in_addr);
+    ip = &((const struct sockaddr_in*)sa)->sin_addr;
+    break;
+  case AF_INET6:
+    ip_len = sizeof (struct in6_addr);
+    ip = &((const struct sockaddr_in6*)sa)->sin6_addr;
+    break;
+  default:
+    GNUNET_break (0);
+    return NULL;
+  }

   rh = GNUNET_malloc (sizeof (struct GNUNET_RESOLVER_RequestHandle) + salen);
   rh->name_callback = callback;
   rh->cls = cls;
   rh = GNUNET_malloc (sizeof (struct GNUNET_RESOLVER_RequestHandle) + salen);
   rh->name_callback = callback;
   rh->cls = cls;

+  rh->af = sa->sa_family;

   rh->timeout = GNUNET_TIME_relative_to_absolute (timeout);
   rh->timeout = GNUNET_TIME_relative_to_absolute (timeout);

-  memcpy (&rh[1], sa, salen);
-  rh->data_len = salen;
+  memcpy (&rh[1], ip, ip_len);
+  rh->data_len = ip_len;

   rh->direction = GNUNET_YES;
   rh->received_response = GNUNET_NO;
   if (GNUNET_NO == do_resolve)
   rh->direction = GNUNET_YES;
   rh->received_response = GNUNET_NO;
   if (GNUNET_NO == do_resolve)


@@ -849,13 +855,6 @@ GNUNET_RESOLVER_hostname_get (const struct sockaddr *sa,
     rh->task = GNUNET_SCHEDULER_add_now (&numeric_reverse, rh);
     return rh;
   }
     rh->task = GNUNET_SCHEDULER_add_now (&numeric_reverse, rh);
     return rh;
   }

-  if (salen + sizeof (struct GNUNET_RESOLVER_GetMessage) >=
-      GNUNET_SERVER_MAX_MESSAGE_SIZE)
-  {
-    GNUNET_break (0);
-    GNUNET_free (rh);
-    return NULL;
-  }

   GNUNET_CONTAINER_DLL_insert_tail (req_head, req_tail, rh);
   rh->was_queued = GNUNET_YES;
   if (s_task != GNUNET_SCHEDULER_NO_TASK)
   GNUNET_CONTAINER_DLL_insert_tail (req_head, req_tail, rh);
   rh->was_queued = GNUNET_YES;
   if (s_task != GNUNET_SCHEDULER_NO_TASK)


@@ -869,7 +868,7 @@ GNUNET_RESOLVER_hostname_get (const struct sockaddr *sa,
 
 
 /**
 
 
 /**

- * Get local fully qualified domain name
+ * Get local fully qualified af name

  *
  * @return fqdn
  */
  *
  * @return fqdn
  */


@@ -881,19 +880,16 @@ GNUNET_RESOLVER_local_fqdn_get ()
 
   if (0 != gethostname (hostname, sizeof (hostname) - 1))
   {
 
   if (0 != gethostname (hostname, sizeof (hostname) - 1))
   {

-    GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR |
-                         GNUNET_ERROR_TYPE_BULK, "gethostname");
+    LOG_STRERROR (GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
+                  "gethostname");

     return NULL;
   }
     return NULL;
   }

-#if DEBUG_RESOLVER
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              _("Resolving our FQDN `%s'\n"), hostname);
-#endif
+  LOG (GNUNET_ERROR_TYPE_DEBUG, "Resolving our FQDN `%s'\n", hostname);

   host = gethostbyname (hostname);
   if (NULL == host)
   {
   host = gethostbyname (hostname);
   if (NULL == host)
   {

-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                _("Could not resolve our FQDN : %s\n"), hstrerror (h_errno));
+    LOG (GNUNET_ERROR_TYPE_ERROR, _("Could not resolve our FQDN : %s\n"),
+         hstrerror (h_errno));

     return NULL;
   }
   return GNUNET_strdup (host->h_name);
     return NULL;
   }
   return GNUNET_strdup (host->h_name);


@@ -903,14 +899,14 @@ GNUNET_RESOLVER_local_fqdn_get ()
 /**
  * Looking our own hostname.
  *
 /**
  * Looking our own hostname.
  *

- * @param domain AF_INET or AF_INET6; use AF_UNSPEC for "any"
+ * @param af AF_INET or AF_INET6; use AF_UNSPEC for "any"

  * @param callback function to call with addresses
  * @param cls closure for callback
  * @param timeout how long to try resolving
  * @return handle that can be used to cancel the request, NULL on error
  */
 struct GNUNET_RESOLVER_RequestHandle *
  * @param callback function to call with addresses
  * @param cls closure for callback
  * @param timeout how long to try resolving
  * @return handle that can be used to cancel the request, NULL on error
  */
 struct GNUNET_RESOLVER_RequestHandle *

-GNUNET_RESOLVER_hostname_resolve (int domain,
+GNUNET_RESOLVER_hostname_resolve (int af,

                                   struct GNUNET_TIME_Relative timeout,
                                   GNUNET_RESOLVER_AddressCallback callback,
                                   void *cls)
                                   struct GNUNET_TIME_Relative timeout,
                                   GNUNET_RESOLVER_AddressCallback callback,
                                   void *cls)


@@ -919,15 +915,14 @@ GNUNET_RESOLVER_hostname_resolve (int domain,
 
   if (0 != gethostname (hostname, sizeof (hostname) - 1))
   {
 
   if (0 != gethostname (hostname, sizeof (hostname) - 1))
   {

-    GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR |
-                         GNUNET_ERROR_TYPE_BULK, "gethostname");
+    LOG_STRERROR (GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
+                  "gethostname");

     return NULL;
   }
     return NULL;
   }

-#if DEBUG_RESOLVER
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              _("Resolving our hostname `%s'\n"), hostname);
-#endif
-  return GNUNET_RESOLVER_ip_get (hostname, domain, timeout, callback, cls);
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Resolving our hostname `%s'\n",
+       hostname);
+  return GNUNET_RESOLVER_ip_get (hostname, af, timeout, callback, cls);

 }
 
 
 }