-fix

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

diff --git a/src/util/resolver_api.c b/src/util/resolver_api.c
index f4e848abbbc89d7835cc500ea1c661b56f65c298..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,16 +24,14 @@
  * @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(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


@@ -137,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?


@@ -208,15 +206,14 @@ check_config ()
     return;
   }
   i = 0;
     return;
   }
   i = 0;

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

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

-       _
-       ("Must specify `%s' or numeric IP address for `%s' of `%s' in configuration!\n"),
+       _("Must specify `%s' or numeric IP address for `%s' of `%s' in configuration!\n"),

        "localhost", "HOSTNAME", "resolver");
   GNUNET_free (hostname);
   GNUNET_assert (0);
        "localhost", "HOSTNAME", "resolver");
   GNUNET_free (hostname);
   GNUNET_assert (0);


@@ -248,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

     LOG (GNUNET_ERROR_TYPE_DEBUG, "Disconnecting from DNS service\n");
     LOG (GNUNET_ERROR_TYPE_DEBUG, "Disconnecting from DNS service\n");

-#endif
-    GNUNET_CLIENT_disconnect (client, GNUNET_NO);
+    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;


@@ -270,52 +265,44 @@ 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_from_strerror (GNUNET_ERROR_TYPE_WARNING, "resolver-api",
-                                "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_from_strerror (GNUNET_ERROR_TYPE_WARNING, "resolver-api",
-                                "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);

 }
 
 
 }
 
 


@@ -344,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
-  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)
       LOG (GNUNET_ERROR_TYPE_INFO,
            _("Timeout trying to resolve IP address `%s'.\n"),
     if (NULL != rh->name_callback)
       LOG (GNUNET_ERROR_TYPE_INFO,
            _("Timeout trying to resolve IP address `%s'.\n"),

-           GNUNET_a2s ((const void *) &rh[1], rh->data_len));
+           inet_ntop (rh->af, (const void *) &rh[1], buf, sizeof(buf)));

     else
       LOG (GNUNET_ERROR_TYPE_INFO,
            _("Timeout trying to resolve hostname `%s'.\n"),
            (const char *) &rh[1]);
     /* check if request was canceled */
     else
       LOG (GNUNET_ERROR_TYPE_INFO,
            _("Timeout trying to resolve hostname `%s'.\n"),
            (const char *) &rh[1]);
     /* 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);


@@ -380,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;


@@ -388,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;


@@ -413,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')
     {


@@ -421,15 +409,13 @@ 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
-    LOG (GNUNET_ERROR_TYPE_DEBUG, _("Resolver returns `%s' for IP `%s'.\n"),
+    LOG (GNUNET_ERROR_TYPE_DEBUG, "Resolver returns `%s' for IP `%s'.\n",

          hostname, GNUNET_a2s ((const void *) &rh[1], rh->data_len));
          hostname, GNUNET_a2s ((const void *) &rh[1], rh->data_len));

-#endif

     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;


@@ -439,29 +425,49 @@ handle_response (void *cls, const struct GNUNET_MessageHeader *msg)
   /* return lookup results to caller */
   if (NULL != rh->addr_callback)
   {
   /* 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);
-
-      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);
     GNUNET_CLIENT_receive (client, &handle_response, rh,
                            GNUNET_TIME_absolute_get_remaining (rh->timeout));
     rh->addr_callback (rh->cls, sa, salen);
     GNUNET_CLIENT_receive (client, &handle_response, rh,
                            GNUNET_TIME_absolute_get_remaining (rh->timeout));


@@ -496,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" */


@@ -510,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));


@@ -551,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));


@@ -576,10 +582,12 @@ 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;

 }
 
 
 }
 
 


@@ -590,7 +598,7 @@ static void
 process_requests ()
 {
   struct GNUNET_RESOLVER_GetMessage *msg;
 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)


@@ -615,20 +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

   LOG (GNUNET_ERROR_TYPE_DEBUG,
        "Transmitting DNS resolution request to DNS service\n");
   LOG (GNUNET_ERROR_TYPE_DEBUG,
        "Transmitting DNS resolution request to DNS service\n");

-#endif

   if (GNUNET_OK !=
       GNUNET_CLIENT_transmit_and_get_response (client, &msg->header,
                                                GNUNET_TIME_absolute_get_remaining
                                                (rh->timeout), GNUNET_YES,
                                                &handle_response, rh))
   {
   if (GNUNET_OK !=
       GNUNET_CLIENT_transmit_and_get_response (client, &msg->header,
                                                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;
   }


@@ -650,13 +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
-  LOG (GNUNET_ERROR_TYPE_DEBUG, "Trying to connect to DNS service\n");
-#endif
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Trying to connect to DNS service\n");

   client = GNUNET_CLIENT_connect ("resolver", resolver_cfg);
   if (NULL == client)
   {
   client = GNUNET_CLIENT_connect ("resolver", resolver_cfg);
   if (NULL == client)
   {

-    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;
   }


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

-#if DEBUG_RESOLVER

   LOG (GNUNET_ERROR_TYPE_DEBUG,
   LOG (GNUNET_ERROR_TYPE_DEBUG,

-       "Will try to connect to DNS service in %llu ms\n",
-       (unsigned long long) backoff.rel_value);
-#endif
+       "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);
   GNUNET_assert (NULL != resolver_cfg);
   r_task = GNUNET_SCHEDULER_add_delayed (backoff, &reconnect_task, NULL);

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

 }
 
 
 }
 
 


@@ -711,14 +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)


@@ -737,7 +742,7 @@ GNUNET_RESOLVER_ip_get (const char *hostname, int domain,
     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);


@@ -746,16 +751,16 @@ GNUNET_RESOLVER_ip_get (const char *hostname, int domain,
   rh->direction = GNUNET_NO;
   /* first, check if this is a numeric address */
   if (((1 == inet_pton (AF_INET, hostname, &v4)) &&
   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))) ||
+       ((af == AF_INET) || (af == AF_UNSPEC))) ||

       ((1 == inet_pton (AF_INET6, hostname, &v6)) &&
       ((1 == inet_pton (AF_INET6, hostname, &v6)) &&

-       ((domain == AF_INET6) || (domain == AF_UNSPEC))))
+       ((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);


@@ -786,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
-  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);


@@ -820,14 +823,31 @@ GNUNET_RESOLVER_hostname_get (const struct sockaddr *sa, socklen_t salen,
                               void *cls)
 {
   struct GNUNET_RESOLVER_RequestHandle *rh;
                               void *cls)
 {
   struct GNUNET_RESOLVER_RequestHandle *rh;

+  size_t ip_len;
+  const void *ip;

 
   check_config ();
 
   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)


@@ -835,13 +855,6 @@ GNUNET_RESOLVER_hostname_get (const struct sockaddr *sa, socklen_t salen,
     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)


@@ -855,7 +868,7 @@ GNUNET_RESOLVER_hostname_get (const struct sockaddr *sa, socklen_t salen,
 
 
 /**
 
 
 /**

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

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


@@ -867,13 +880,11 @@ GNUNET_RESOLVER_local_fqdn_get ()
 
   if (0 != gethostname (hostname, sizeof (hostname) - 1))
   {
 
   if (0 != gethostname (hostname, sizeof (hostname) - 1))
   {

-    GNUNET_log_from_strerror (GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
-                              "resolver-api", "gethostname");
+    LOG_STRERROR (GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
+                  "gethostname");

     return NULL;
   }
     return NULL;
   }

-#if DEBUG_RESOLVER
-  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)
   {


@@ -888,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)


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

-    GNUNET_log_from_strerror (GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
-                              "resolver-api", "gethostname");
+    LOG_STRERROR (GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
+                  "gethostname");

     return NULL;
   }
     return NULL;
   }

-#if DEBUG_RESOLVER
-  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);

 }
 
 
 }