allowing cancellation of resolver requests

diff --git a/src/include/gnunet_client_lib.h b/src/include/gnunet_client_lib.h
index c78df41c7c59a993420f9b661b18a3c76ced01d3..2ba9e135f4c83b633cc36cd65531ddab0baa651d 100644 (file)
--- a/src/include/gnunet_client_lib.h
+++ b/src/include/gnunet_client_lib.h
@@ -64,10 +64,15 @@ struct GNUNET_CLIENT_Connection *GNUNET_CLIENT_connect (struct
                                                         *cfg);
 
 /**
- * Destroy connection with the service.  This will
- * automatically cancel any pending "receive" request
- * (however, the handler will *NOT* be called, not
- * even with a NULL message).
+ * Destroy connection with the service.  This will automatically
+ * cancel any pending "receive" request (however, the handler will
+ * *NOT* be called, not even with a NULL message).  Any pending
+ * transmission request will also be cancelled UNLESS the callback for
+ * the transmission request has already been called, in which case the
+ * transmission is guaranteed to complete before the socket is fully
+ * destroyed.
+ *
+ * @param sock handle to the service connection
  */
 void GNUNET_CLIENT_disconnect (struct GNUNET_CLIENT_Connection *sock);
 

diff --git a/src/include/gnunet_resolver_service.h b/src/include/gnunet_resolver_service.h
index b7fb1532a1d5b46528726c75459d567d230bee24..f8b1e79c7043459054ee84d962817439f5047255 100644 (file)
--- a/src/include/gnunet_resolver_service.h
+++ b/src/include/gnunet_resolver_service.h
@@ -52,6 +52,13 @@ typedef void (*GNUNET_RESOLVER_AddressCallback) (void *cls,
                                                  socklen_t addrlen);
 
 
+/**
+ * Handle to a request given to the resolver.  Can be used to cancel
+ * the request prior to the timeout or successful execution.
+ */
+struct GNUNET_RESOLVER_RequestHandle;
+
+
 /**
  * Convert a string to one or more IP addresses.
  *
@@ -62,8 +69,9 @@ typedef void (*GNUNET_RESOLVER_AddressCallback) (void *cls,
  * @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
  */
-void
+struct GNUNET_RESOLVER_RequestHandle *
 GNUNET_RESOLVER_ip_get (struct GNUNET_SCHEDULER_Handle *sched,
                         const struct GNUNET_CONFIGURATION_Handle *cfg,
                         const char *hostname,
@@ -82,8 +90,9 @@ GNUNET_RESOLVER_ip_get (struct GNUNET_SCHEDULER_Handle *sched,
  * @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
  */
-void
+struct GNUNET_RESOLVER_RequestHandle *
 GNUNET_RESOLVER_hostname_resolve (struct GNUNET_SCHEDULER_Handle *sched,
                                   const struct GNUNET_CONFIGURATION_Handle *cfg,
                                   int domain,
@@ -104,7 +113,7 @@ typedef void (*GNUNET_RESOLVER_HostnameCallback) (void *cls,
 
 
 /**
- * Get an IP address as a string.
+ * Perform a reverse DNS lookup.
  *
  * @param sched scheduler to use
  * @param cfg configuration to use
@@ -114,15 +123,30 @@ typedef void (*GNUNET_RESOLVER_HostnameCallback) (void *cls,
  * @param timeout how long to try resolving
  * @param callback function to call with hostnames
  * @param cls closure for callback
+ * @return handle that can be used to cancel the request, NULL on error
  */
-void GNUNET_RESOLVER_hostname_get (struct GNUNET_SCHEDULER_Handle *sched,
-                                   const struct GNUNET_CONFIGURATION_Handle *cfg,
-                                   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 * 
+GNUNET_RESOLVER_hostname_get (struct GNUNET_SCHEDULER_Handle *sched,
+                             const struct GNUNET_CONFIGURATION_Handle *cfg,
+                             const struct sockaddr *sa,
+                             socklen_t salen,
+                             int do_resolve,
+                             struct GNUNET_TIME_Relative timeout,
+                             GNUNET_RESOLVER_HostnameCallback callback,
+                             void *cls);
+
+
+/**
+ * Cancel a request that is still pending with the resolver.
+ * Note that a client MUST NOT cancel a request that has
+ * been completed (i.e, the callback has been called to
+ * signal timeout or the final result).
+ *
+ * @param h handle of request to cancel
+ */
+void
+GNUNET_RESOLVER_request_cancel (struct GNUNET_RESOLVER_RequestHandle *h);
+
 
 #if 0                           /* keep Emacsens' auto-indent happy */
 {

diff --git a/src/util/client.c b/src/util/client.c
index 4135a15a1d411db5bd27d9e4eec9d6b3a9a015d8..8c429995cbbcf640904dcbb7ce04f01d1d3120f1 100644 (file)
--- a/src/util/client.c
+++ b/src/util/client.c
@@ -44,6 +44,67 @@
  */
 #define MAX_ATTEMPTS 10
 
+
+/**
+ * Handle for a transmission request.
+ */
+struct GNUNET_CLIENT_TransmitHandle 
+{
+  /**
+   * Connection state.
+   */
+  struct GNUNET_CLIENT_Connection *sock;
+
+  /**
+   * Function to call to get the data for transmission.
+   */
+  GNUNET_CONNECTION_TransmitReadyNotify notify;
+
+  /**
+   * Closure for notify.
+   */
+  void *notify_cls;
+
+  /**
+   * Handle to the transmission with the underlying
+   * connection.
+   */
+  struct GNUNET_CONNECTION_TransmitHandle *th;
+
+  /**
+   * Timeout.
+   */
+  struct GNUNET_TIME_Absolute timeout;
+
+  /**
+   * If we are re-trying and are delaying to do so,
+   * handle to the scheduled task managing the delay.
+   */
+  GNUNET_SCHEDULER_TaskIdentifier task;
+
+  /**
+   * Number of bytes requested.
+   */
+  size_t size;
+
+  /**
+   * Are we allowed to re-try to connect without telling
+   * the user (of this API) about the connection troubles?
+   */
+  int auto_retry;
+
+  /**
+   * Number of attempts left for transmitting the request.  We may
+   * fail the first time (say because the service is not yet up), in
+   * which case (if auto_retry is set) we wait a bit and re-try
+   * (timeout permitting).
+   */
+  unsigned int attempts_left;
+
+};
+
+
+
 /**
  * Struct to refer to a GNUnet TCP connection.
  * This is more than just a socket because if the server
@@ -83,6 +144,12 @@ struct GNUNET_CLIENT_Connection
    */
   void *receiver_handler_cls;
 
+  /**
+   * Handle for a pending transmission request, NULL if there is
+   * none pending.
+   */
+  struct GNUNET_CLIENT_TransmitHandle *th;
+
   /**
    * Handler for service test completion (NULL unless in service_test)
    */
@@ -209,6 +276,8 @@ finish_cleanup (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   struct GNUNET_CLIENT_Connection *sock = cls;
 
+  if (sock->th != NULL)
+    GNUNET_CLIENT_notify_transmit_ready_cancel (sock->th);    
   GNUNET_array_grow (sock->received_buf, sock->received_size, 0);
   GNUNET_free (sock->service_name);
   GNUNET_free (sock);
@@ -216,13 +285,22 @@ finish_cleanup (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 
 
 /**
- * Destroy connection with the service.
+ * Destroy connection with the service.  This will automatically
+ * cancel any pending "receive" request (however, the handler will
+ * *NOT* be called, not even with a NULL message).  Any pending
+ * transmission request will also be cancelled UNLESS the callback for
+ * the transmission request has already been called, in which case the
+ * transmission is guaranteed to complete before the socket is fully
+ * destroyed.
+ *
+ * @param sock handle to the service connection
  */
 void
 GNUNET_CLIENT_disconnect (struct GNUNET_CLIENT_Connection *sock)
 {
   GNUNET_assert (sock->sock != NULL);
   GNUNET_CONNECTION_destroy (sock->sock);
+  sock->sock = NULL;
   sock->receiver_handler = NULL;
   if (sock->in_receive == GNUNET_YES)
     sock->in_receive = GNUNET_SYSERR;
@@ -545,66 +623,6 @@ GNUNET_CLIENT_service_test (struct GNUNET_SCHEDULER_Handle *sched,
 }
 
 
-/**
- * Handle for a transmission request.
- */
-struct GNUNET_CLIENT_TransmitHandle 
-{
-  /**
-   * Connection state.
-   */
-  struct GNUNET_CLIENT_Connection *sock;
-
-  /**
-   * Function to call to get the data for transmission.
-   */
-  GNUNET_CONNECTION_TransmitReadyNotify notify;
-
-  /**
-   * Closure for notify.
-   */
-  void *notify_cls;
-
-  /**
-   * Handle to the transmission with the underlying
-   * connection.
-   */
-  struct GNUNET_CONNECTION_TransmitHandle *th;
-
-  /**
-   * Timeout.
-   */
-  struct GNUNET_TIME_Absolute timeout;
-
-  /**
-   * If we are re-trying and are delaying to do so,
-   * handle to the scheduled task managing the delay.
-   */
-  GNUNET_SCHEDULER_TaskIdentifier task;
-
-  /**
-   * Number of bytes requested.
-   */
-  size_t size;
-
-  /**
-   * Are we allowed to re-try to connect without telling
-   * the user (of this API) about the connection troubles?
-   */
-  int auto_retry;
-
-  /**
-   * Number of attempts left for transmitting the request.  We may
-   * fail the first time (say because the service is not yet up), in
-   * which case (if auto_retry is set) we wait a bit and re-try
-   * (timeout permitting).
-   */
-  unsigned int attempts_left;
-
-};
-
-
-
 /**
  * Connection notifies us about failure or success of
  * a transmission request.  Either pass it on to our
@@ -671,6 +689,7 @@ client_notify (void *cls,
   struct GNUNET_TIME_Relative delay;
   
   th->th = NULL;
+  th->sock->th = NULL;
   if (buf == NULL)
     {
       delay = GNUNET_TIME_absolute_get_remaining (th->timeout);
@@ -690,6 +709,7 @@ client_notify (void *cls,
       th->sock->sock = do_connect (th->sock->sched, 
                                   th->sock->service_name,
                                   th->sock->cfg);
+      GNUNET_assert (NULL != th->sock->sock);
       delay = GNUNET_TIME_relative_min (delay, GNUNET_TIME_UNIT_SECONDS);
       th->task = GNUNET_SCHEDULER_add_delayed (th->sock->sched,
                                               GNUNET_NO,
@@ -698,6 +718,7 @@ client_notify (void *cls,
                                               delay,
                                               &client_delayed_retry,
                                               th);
+      th->sock->th = th;
       return 0;
     }
   GNUNET_assert (size >= th->size);
@@ -738,6 +759,8 @@ GNUNET_CLIENT_notify_transmit_ready (struct GNUNET_CLIENT_Connection *sock,
 {
   struct GNUNET_CLIENT_TransmitHandle *th;
 
+  if (NULL != sock->th)
+    return NULL;
   th = GNUNET_malloc (sizeof (struct GNUNET_CLIENT_TransmitHandle));
   th->sock = sock;
   th->size = size;
@@ -753,9 +776,11 @@ GNUNET_CLIENT_notify_transmit_ready (struct GNUNET_CLIENT_Connection *sock,
                                                    th);
   if (NULL == th->th)
     {
+      GNUNET_break (0);
       GNUNET_free (th);
       return NULL;
     }
+  sock->th = th;
   return th;
 }
 
@@ -779,6 +804,7 @@ GNUNET_CLIENT_notify_transmit_ready_cancel (struct GNUNET_CLIENT_TransmitHandle
       GNUNET_break (NULL != th->th);
       GNUNET_CONNECTION_notify_transmit_ready_cancel (th->th);
     }
+  th->sock->th = NULL;
   GNUNET_free (th);
 }
 
@@ -886,6 +912,8 @@ GNUNET_CLIENT_transmit_and_get_response (struct GNUNET_CLIENT_Connection *sock,
   struct TARCtx *tc;
   uint16_t msize;
 
+  if (NULL != sock->th)
+    return GNUNET_SYSERR;
   msize = ntohs(hdr->size);
   tc = GNUNET_malloc(sizeof (struct TARCtx) + msize);
   tc->sock = sock;
@@ -901,6 +929,7 @@ GNUNET_CLIENT_transmit_and_get_response (struct GNUNET_CLIENT_Connection *sock,
                                                   &transmit_for_response,
                                                   tc))
     {
+      GNUNET_break (0);
       GNUNET_free (tc);
       return GNUNET_SYSERR;
     }

diff --git a/src/util/connection.c b/src/util/connection.c
index 2999831a3526a423d2183a4e5ade35409f3be8c6..6f2b5a3490267a00ed2ad563c88efd8f71f67741 100644 (file)
--- a/src/util/connection.c
+++ b/src/util/connection.c
@@ -771,8 +771,22 @@ try_connect_using_address (void *cls,
   if (h->sock != NULL)
     return; /* already connected */
   if (h->dns_active == GNUNET_SYSERR)
-    return; /* already destroyed */
+    {
+#if DEBUG_CONNECTION
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                 "Connection has already been destroyed.\n");
+#endif
+      return; /* already destroyed */
+    }
   /* try to connect */
+#if DEBUG_CONNECTION
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+             "Trying to connect using address `%s:%u/%s:%u'\n",
+             h->hostname,
+             h->port,
+             GNUNET_a2s (addr, addrlen),
+             h->port);
+#endif
   ap = GNUNET_malloc (sizeof (struct AddressProbe) + addrlen);
   ap->addr = (const struct sockaddr*) &ap[1];
   memcpy (&ap[1], addr, addrlen);

diff --git a/src/util/network.c b/src/util/network.c
index 30519fe382070b42761df25d292d44bb04fffc06..1136614e7b3b9c8f191e8c7ec77211cff93da77d 100644 (file)
--- a/src/util/network.c
+++ b/src/util/network.c
@@ -29,7 +29,7 @@
 #include "disk.h"\r
 #include "gnunet_container_lib.h"\r
 \r
-#define DEBUG_SOCK GNUNET_NO\r
+#define DEBUG_NETWORK GNUNET_YES\r
 \r
 #ifndef INVALID_SOCKET\r
 #define INVALID_SOCKET -1\r
@@ -857,7 +857,7 @@ GNUNET_NETWORK_socket_select (struct GNUNET_NETWORK_FDSet *rfds,
               if (errno == ENOTSOCK)\r
                 errno = EBADF;\r
 \r
-#if DEBUG_SOCK\r
+#if DEBUG_NETWORK\r
             GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "select");\r
 #endif\r
 \r
@@ -889,7 +889,7 @@ GNUNET_NETWORK_socket_select (struct GNUNET_NETWORK_FDSet *rfds,
 \r
                   retcode = -1;\r
                   SetErrnoFromWinError (GetLastError ());\r
-#if DEBUG_SOCK\r
+#if DEBUG_NETWORK\r
                   GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "PeekNamedPipe");\r
 #endif\r
                   goto select_loop_end;\r

diff --git a/src/util/resolver_api.c b/src/util/resolver_api.c
index 284a3cef635249698b95ab6c4d7ab3ec36620985..e1198a9a31bb5c68e966948378444dffe0203168 100644 (file)
--- a/src/util/resolver_api.c
+++ b/src/util/resolver_api.c
@@ -33,40 +33,81 @@
 
 
 /**
- * FIXME.
+ * Maximum supported length for a hostname
  */
-struct GetAddressContext
+#define MAX_HOSTNAME 1024
+
+
+/**
+ * Possible hostnames for "loopback".
+ */
+static const char *loopback[] = {
+  "localhost",
+  "ip6-localnet",
+  NULL
+};
+
+
+/**
+ * Handle to a request given to the resolver.  Can be used to cancel
+ * the request prior to the timeout or successful execution.  Also
+ * used to track our internal state for the request.
+ */
+struct GNUNET_RESOLVER_RequestHandle
 {
 
   /**
-   * FIXME.
+   * Callback if this is an name resolution request,
+   * otherwise NULL.
+   */
+  GNUNET_RESOLVER_AddressCallback addr_callback;
+
+  /**
+   * Callback if this is a reverse lookup request,
+   * otherwise NULL.
    */
-  GNUNET_RESOLVER_AddressCallback callback;
+  GNUNET_RESOLVER_HostnameCallback name_callback;
 
   /**
-   * Closure for "callback".
+   * Closure for the respective "callback".
    */
   void *cls;
 
   /**
-   * FIXME.
+   * Our connection to the resolver service.
    */
   struct GNUNET_CLIENT_Connection *client;
 
   /**
-   * FIXME.
+   * Our scheduler.
+   */
+  struct GNUNET_SCHEDULER_Handle *sched;
+
+  /**
+   * Name of the host that we are resolving.
+   */
+  const char *hostname;
+
+  /**
+   * When should this request time out?
    */
   struct GNUNET_TIME_Absolute timeout;
-};
 
+  /**
+   * Task handle for numeric lookups.
+   */
+  GNUNET_SCHEDULER_TaskIdentifier task;
+
+  /**
+   * Desired address family.
+   */ 
+  int domain;
 
-/**
- * Possible hostnames for "loopback".
- */
-static const char *loopback[] = {
-  "localhost",
-  "ip6-localnet",
-  NULL
+  /**
+   * Length of the "struct sockaddr" that follows this
+   * struct (only for reverse lookup).
+   */
+  socklen_t salen;
 };
 
 
@@ -79,9 +120,20 @@ check_config (const struct GNUNET_CONFIGURATION_Handle *cfg)
 {
   char *hostname;
   unsigned int i;
-  struct in_addr v4;
-  struct in6_addr v6;
+  struct sockaddr_in v4;
+  struct sockaddr_in6 v6;
 
+  memset (&v4, 0, sizeof(v4));
+  v4.sin_addr.s_addr = htonl (INADDR_LOOPBACK);  
+  v4.sin_family = AF_INET;
+#if HAVE_SOCKADDR_IN_SIN_LEN
+  v4.sin_len = sizeof(v4);
+#endif
+  memset (&v6, 0, sizeof(v6)); 
+  v6.sin6_family = AF_INET6;
+#if HAVE_SOCKADDR_IN_SIN_LEN
+  v6.sin6_len = sizeof(v6);
+#endif
   if (GNUNET_OK !=
       GNUNET_CONFIGURATION_get_value_string (cfg,
                                             "resolver",
@@ -94,10 +146,10 @@ check_config (const struct GNUNET_CONFIGURATION_Handle *cfg)
                  "resolver");
       GNUNET_assert (0);
     }
-  if ( (0 == inet_pton (AF_INET,
+  if ( (1 != inet_pton (AF_INET,
                        hostname,
                        &v4)) ||
-       (0 == inet_pton (AF_INET6,
+       (1 != inet_pton (AF_INET6,
                        hostname,
                        &v6)) )
     {
@@ -106,14 +158,15 @@ check_config (const struct GNUNET_CONFIGURATION_Handle *cfg)
     }
   i = 0;
   while (loopback[i] != NULL)
-    if (0 == strcmp (loopback[i++], hostname))
+    if (0 == strcasecmp (loopback[i++], hostname))
       {
        GNUNET_free (hostname); 
        return;
       }
   GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-             _("Must specify `%s' for `%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); 
@@ -163,15 +216,16 @@ no_resolve (const struct sockaddr *sa, socklen_t salen)
 
 
 /**
- * FIXME
+ * Process the reply from the resolver (which is presumably
+ * the numeric IP address for a name resolution request).
  *
- * @param cls FIXME
- * @param msg FIXME
+ * @param cls the "GNUNET_RESOLVER_RequestHandle" for which this is a reply
+ * @param msg reply from the resolver or NULL on error
  */
 static void
 handle_address_response (void *cls, const struct GNUNET_MessageHeader *msg)
 {
-  struct GetAddressContext *gac = cls;
+  struct GNUNET_RESOLVER_RequestHandle *rh = cls;
   uint16_t size;
   const struct sockaddr *sa;
   socklen_t salen;
@@ -181,17 +235,17 @@ handle_address_response (void *cls, const struct GNUNET_MessageHeader *msg)
     {
       GNUNET_log (GNUNET_ERROR_TYPE_INFO,
                   _("Timeout trying to resolve hostname.\n"));
-      gac->callback (gac->cls, NULL, 0);
-      GNUNET_CLIENT_disconnect (gac->client);
-      GNUNET_free (gac);
+      rh->addr_callback (rh->cls, NULL, 0);
+      GNUNET_CLIENT_disconnect (rh->client);
+      GNUNET_free (rh);
       return;
     }
   if (GNUNET_MESSAGE_TYPE_RESOLVER_RESPONSE != ntohs (msg->type))
     {
       GNUNET_break (0);
-      gac->callback (gac->cls, NULL, 0);
-      GNUNET_CLIENT_disconnect (gac->client);
-      GNUNET_free (gac);
+      rh->addr_callback (rh->cls, NULL, 0);
+      GNUNET_CLIENT_disconnect (rh->client);
+      GNUNET_free (rh);
       return;
     }
 
@@ -202,9 +256,9 @@ handle_address_response (void *cls, const struct GNUNET_MessageHeader *msg)
       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                   _("Received end message resolving hostname.\n"));
 #endif
-      gac->callback (gac->cls, NULL, 0);
-      GNUNET_CLIENT_disconnect (gac->client);
-      GNUNET_free (gac);
+      rh->addr_callback (rh->cls, NULL, 0);
+      GNUNET_CLIENT_disconnect (rh->client);
+      GNUNET_free (rh);
       return;
     }
   sa = (const struct sockaddr *) &msg[1];
@@ -212,56 +266,45 @@ handle_address_response (void *cls, const struct GNUNET_MessageHeader *msg)
   if (salen < sizeof (struct sockaddr))
     {
       GNUNET_break (0);
-      gac->callback (gac->cls, NULL, 0);
-      GNUNET_CLIENT_disconnect (gac->client);
-      GNUNET_free (gac);
+      rh->addr_callback (rh->cls, NULL, 0);
+      GNUNET_CLIENT_disconnect (rh->client);
+      GNUNET_free (rh);
       return;
     }
 #if DEBUG_RESOLVER
   {
     char *ips = no_resolve (sa, salen);
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, _("Resolver returns `%s'.\n"), ips);
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, 
+               "Resolver returns `%s'.\n", 
+               ips);
     GNUNET_free (ips);
   }
 #endif
-  gac->callback (gac->cls, sa, salen);
-  GNUNET_CLIENT_receive (gac->client,
+  rh->addr_callback (rh->cls, sa, salen);
+  GNUNET_CLIENT_receive (rh->client,
                          &handle_address_response,
-                         gac,
-                         GNUNET_TIME_absolute_get_remaining (gac->timeout));
+                         rh,
+                         GNUNET_TIME_absolute_get_remaining (rh->timeout));
 }
 
 
 /**
- * Convert a string to one or more IP addresses.
+ * 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.
  *
- * @param sched scheduler to use
- * @param cfg configuration to use
- * @param hostname the hostname to resolve
- * @param domain 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
+ * @param cls struct GNUNET_RESOLVER_RequestHandle for the request
+ * @param tc unused scheduler context
  */
-void
-GNUNET_RESOLVER_ip_get (struct GNUNET_SCHEDULER_Handle *sched,
-                        const struct GNUNET_CONFIGURATION_Handle *cfg,
-                        const char *hostname,
-                        int domain,
-                        struct GNUNET_TIME_Relative timeout,
-                        GNUNET_RESOLVER_AddressCallback callback, 
-                       void *callback_cls)
+static void
+numeric_resolution (void *cls,
+                   const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
-  struct GNUNET_CLIENT_Connection *client;
-  struct GNUNET_RESOLVER_GetMessage *msg;
-  struct GetAddressContext *actx;
-  size_t slen;
-  unsigned int i;
+  struct GNUNET_RESOLVER_RequestHandle *rh = cls;
   struct sockaddr_in v4;
   struct sockaddr_in6 v6;
 
   memset (&v4, 0, sizeof(v4));
-  v4.sin_addr.s_addr = htonl (INADDR_LOOPBACK);  
   v4.sin_family = AF_INET;
 #if HAVE_SOCKADDR_IN_SIN_LEN
   v4.sin_len = sizeof(v4);
@@ -271,97 +314,202 @@ GNUNET_RESOLVER_ip_get (struct GNUNET_SCHEDULER_Handle *sched,
 #if HAVE_SOCKADDR_IN_SIN_LEN
   v6.sin6_len = sizeof(v6);
 #endif
-  /* first, check if this is a numeric address */
-  if ( ( (domain == AF_UNSPEC) || (domain == AF_INET) ) && 
+
+  if ( ( (rh->domain == AF_UNSPEC) || (rh->domain == AF_INET) ) && 
        (1 == inet_pton (AF_INET,
-                       hostname,
+                       rh->hostname,
                        &v4.sin_addr)) )
     {
-      callback (callback_cls,
-               (const struct sockaddr*) &v4,
-               sizeof(v4));
-      if ( (domain == AF_UNSPEC) && 
+      rh->addr_callback (rh->cls,
+                          (const struct sockaddr*) &v4,
+                          sizeof(v4));
+      if ( (rh->domain == AF_UNSPEC) && 
           (1 == inet_pton (AF_INET6,
-                           hostname,
+                           rh->hostname,
                            &v6.sin6_addr)) )
        {
          /* this can happen on some systems IF "hostname" is "localhost" */
-         callback (callback_cls,
-                   (const struct sockaddr*) &v6,
-                   sizeof(v6));
+         rh->addr_callback (rh->cls,
+                              (const struct sockaddr*) &v6,
+                              sizeof(v6));
        }
-      callback (callback_cls, NULL, 0);      
+      rh->addr_callback (rh->cls, NULL, 0);      
+      GNUNET_free (rh);
       return;
     }
-  if ( ( (domain == AF_UNSPEC) || (domain == AF_INET6) ) && 
+  if ( ( (rh->domain == AF_UNSPEC) || (rh->domain == AF_INET6) ) && 
        (1 == inet_pton (AF_INET6,
-                       hostname,
+                       rh->hostname,
                        &v6.sin6_addr)) )
     {
-      callback (callback_cls,
-               (const struct sockaddr*) &v6,
-               sizeof(v6));
-      callback (callback_cls, NULL, 0);
+      rh->addr_callback (rh->cls,
+                          (const struct sockaddr*) &v6,
+                          sizeof(v6));
+      rh->addr_callback (rh->cls, NULL, 0);
+      GNUNET_free (rh);
       return;
     }
+  /* why are we here? this task should not have been scheduled! */
+  GNUNET_assert (0);
+  GNUNET_free (rh);
+}
+
+
+
+/**
+ * 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.
+ *
+ * @param cls struct GNUNET_RESOLVER_RequestHandle for the request
+ * @param tc unused scheduler context
+ */
+static void
+loopback_resolution (void *cls,
+                    const struct GNUNET_SCHEDULER_TaskContext *tc)
+{
+  struct GNUNET_RESOLVER_RequestHandle *rh = cls;
+  struct sockaddr_in v4;
+  struct sockaddr_in6 v6;
+
+  memset (&v4, 0, sizeof(v4));
+  v4.sin_addr.s_addr = htonl (INADDR_LOOPBACK);  
+  v4.sin_family = AF_INET;
+#if HAVE_SOCKADDR_IN_SIN_LEN
+  v4.sin_len = sizeof(v4);
+#endif
+  memset (&v6, 0, sizeof(v6)); 
+  v6.sin6_family = AF_INET6;
+#if HAVE_SOCKADDR_IN_SIN_LEN
+  v6.sin6_len = sizeof(v6);
+#endif
+  v6.sin6_addr = in6addr_loopback;
+  switch (rh->domain)
+    {
+    case AF_INET:
+      rh->addr_callback (rh->cls, 
+                          (const struct sockaddr*) &v4,
+                          sizeof(v4));
+      break;
+    case AF_INET6:
+      rh->addr_callback (rh->cls, 
+                          (const struct sockaddr*) &v6,
+                          sizeof(v6));
+      break;
+    case AF_UNSPEC:
+      rh->addr_callback (rh->cls, 
+                          (const struct sockaddr*) &v6,
+                          sizeof(v6));
+      rh->addr_callback (rh->cls, 
+                          (const struct sockaddr*) &v4,
+                          sizeof(v4));
+      break;
+    default:
+      GNUNET_break (0);
+      break;
+    }
+  rh->addr_callback (rh->cls, NULL, 0);
+  GNUNET_free (rh);
+}
+
+
+/**
+ * Convert a string to one or more IP addresses.
+ *
+ * @param sched scheduler to use
+ * @param cfg configuration to use
+ * @param hostname the hostname to resolve
+ * @param domain 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 *
+GNUNET_RESOLVER_ip_get (struct GNUNET_SCHEDULER_Handle *sched,
+                        const struct GNUNET_CONFIGURATION_Handle *cfg,
+                        const char *hostname,
+                        int domain,
+                        struct GNUNET_TIME_Relative timeout,
+                        GNUNET_RESOLVER_AddressCallback callback, 
+                       void *callback_cls)
+{
+  struct GNUNET_CLIENT_Connection *client;
+  struct GNUNET_RESOLVER_GetMessage *msg;
+  struct GNUNET_RESOLVER_RequestHandle *rh;
+  size_t slen;
+  unsigned int i;
+  struct in_addr v4;
+  struct in6_addr v6;
+  char buf[GNUNET_SERVER_MAX_MESSAGE_SIZE];
+
   check_config (cfg);
-  /* then, check if this is a loopback address */
-  i = 0;
-  while (loopback[i] != NULL)
-    if (0 == strcmp (loopback[i++], hostname))
-      {
-       v4.sin_addr.s_addr = htonl (INADDR_LOOPBACK);  
-       v6.sin6_addr = in6addr_loopback;
-       switch (domain)
-         {
-         case AF_INET:
-           callback (callback_cls, 
-                     (const struct sockaddr*) &v4,
-                     sizeof(v4));
-           break;
-         case AF_INET6:
-           callback (callback_cls, 
-                     (const struct sockaddr*) &v6,
-                     sizeof(v6));
-           break;
-         case AF_UNSPEC:
-           callback (callback_cls, 
-                     (const struct sockaddr*) &v6,
-                     sizeof(v6));
-           callback (callback_cls, 
-                     (const struct sockaddr*) &v4,
-                     sizeof(v4));
-           break;
-         }
-       callback (callback_cls, NULL, 0);
-       return;
-      }
   slen = strlen (hostname) + 1;
   if (slen + sizeof (struct GNUNET_RESOLVER_GetMessage) >
       GNUNET_SERVER_MAX_MESSAGE_SIZE)
     {
       GNUNET_break (0);
-      callback (callback_cls, NULL, 0);
-      return;
+      return NULL;
+    }
+  rh = GNUNET_malloc (sizeof(struct GNUNET_RESOLVER_RequestHandle) + slen);
+  rh->client = client;
+  rh->sched = sched;
+  rh->domain = domain;
+  rh->addr_callback = callback;
+  rh->cls = callback_cls;
+  memcpy (&rh[1], hostname, slen);
+  rh->hostname = (const char*) &rh[1];
+  rh->timeout = GNUNET_TIME_relative_to_absolute (timeout);
+
+  /* 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)) ) )
+    {
+      rh->task = GNUNET_SCHEDULER_add_delayed (sched,
+                                              GNUNET_NO,
+                                              GNUNET_SCHEDULER_PRIORITY_KEEP,
+                                              GNUNET_SCHEDULER_NO_TASK,
+                                              GNUNET_TIME_UNIT_ZERO,
+                                              &numeric_resolution,
+                                              rh);
+      return rh;
     }
+  /* then, check if this is a loopback address */
+  i = 0;
+  while (loopback[i] != NULL)
+    if (0 == strcasecmp (loopback[i++], hostname))
+      {
+       rh->task = GNUNET_SCHEDULER_add_delayed (sched,
+                                                GNUNET_NO,
+                                                GNUNET_SCHEDULER_PRIORITY_KEEP,
+                                                GNUNET_SCHEDULER_NO_TASK,
+                                                GNUNET_TIME_UNIT_ZERO,
+                                                &loopback_resolution,
+                                                rh);
+       return rh;
+      }
+
   client = GNUNET_CLIENT_connect (sched, "resolver", cfg);
   if (client == NULL)
     {
-      callback (callback_cls, NULL, 0);
-      return;
+      GNUNET_free (rh);
+      return NULL;    
     }
-  msg = GNUNET_malloc (sizeof (struct GNUNET_RESOLVER_GetMessage) + slen);
+  rh->client = client;
+
+  msg = (struct GNUNET_RESOLVER_GetMessage*) buf;
   msg->header.size =
     htons (sizeof (struct GNUNET_RESOLVER_GetMessage) + slen);
   msg->header.type = htons (GNUNET_MESSAGE_TYPE_RESOLVER_REQUEST);
   msg->direction = htonl (GNUNET_NO);
   msg->domain = htonl (domain);
   memcpy (&msg[1], hostname, slen);
-  actx = GNUNET_malloc (sizeof (struct GetAddressContext));
-  actx->callback = callback;
-  actx->cls = callback_cls;
-  actx->client = client;
-  actx->timeout = GNUNET_TIME_relative_to_absolute (timeout);
 
 #if DEBUG_RESOLVER
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
@@ -374,56 +522,27 @@ GNUNET_RESOLVER_ip_get (struct GNUNET_SCHEDULER_Handle *sched,
                                               timeout,
                                               GNUNET_YES,
                                               &handle_address_response,
-                                              actx))
+                                              rh))
     {
-      GNUNET_free (msg);
-      GNUNET_free (actx);
-      callback (callback_cls, NULL, 0);
+      GNUNET_free (rh);
       GNUNET_CLIENT_disconnect (client);
-      return;
+      return NULL;
     }
-  GNUNET_free (msg);      
+  return rh;
 }
 
 
 /**
- * FIXME.
- */
-struct GetHostnameContext
-{
-
-  /**
-   * FIXME.
-   */
-  GNUNET_RESOLVER_HostnameCallback callback;
-  
-  /**
-   * FIXME.
-   */
-  void *cls;
-  
-  /**
-   * FIXME.
-   */  
-  struct GNUNET_CLIENT_Connection *client;
-  
-  /**
-   * FIXME.
-   */ 
-  struct GNUNET_TIME_Absolute timeout;
-};
-
-
-/**
- * FIXME.
+ * Process response with a hostname for a reverse DNS lookup.
  *
- * @param cls FIXME
- * @param msg FIXME
+ * @param cls our "struct GNUNET_RESOLVER_RequestHandle" context
+ * @param msg message with the hostname, NULL on error
  */
 static void
-handle_hostname_response (void *cls, const struct GNUNET_MessageHeader *msg)
+handle_hostname_response (void *cls,
+                         const struct GNUNET_MessageHeader *msg)
 {
-  struct GetHostnameContext *ghc = cls;
+  struct GNUNET_RESOLVER_RequestHandle *rh = cls;
   uint16_t size;
   const char *hostname;
 
@@ -431,9 +550,9 @@ handle_hostname_response (void *cls, const struct GNUNET_MessageHeader *msg)
     {
       GNUNET_log (GNUNET_ERROR_TYPE_INFO,
                   _("Timeout trying to resolve IP address.\n"));
-      ghc->callback (ghc->cls, NULL);
-      GNUNET_CLIENT_disconnect (ghc->client);
-      GNUNET_free (ghc);
+      rh->name_callback (rh->cls, NULL);
+      GNUNET_CLIENT_disconnect (rh->client);
+      GNUNET_free (rh);
       return;
     }
   size = ntohs (msg->size);
@@ -443,32 +562,64 @@ handle_hostname_response (void *cls, const struct GNUNET_MessageHeader *msg)
       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                   _("Received end message resolving IP address.\n"));
 #endif
-      ghc->callback (ghc->cls, NULL);
-      GNUNET_CLIENT_disconnect (ghc->client);
-      GNUNET_free (ghc);
+      rh->name_callback (rh->cls, NULL);
+      GNUNET_CLIENT_disconnect (rh->client);
+      GNUNET_free (rh);
       return;
     }
   hostname = (const char *) &msg[1];
   if (hostname[size - sizeof (struct GNUNET_MessageHeader) - 1] != '\0')
     {
       GNUNET_break (0);
-      ghc->callback (ghc->cls, NULL);
-      GNUNET_CLIENT_disconnect (ghc->client);
-      GNUNET_free (ghc);
+      rh->name_callback (rh->cls, NULL);
+      GNUNET_CLIENT_disconnect (rh->client);
+      GNUNET_free (rh);
       return;
     }
 #if DEBUG_RESOLVER
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               _("Resolver returns `%s'.\n"), hostname);
 #endif
-  ghc->callback (ghc->cls, hostname);
-  GNUNET_CLIENT_receive (ghc->client,
+  rh->name_callback (rh->cls, hostname);
+  GNUNET_CLIENT_receive (rh->client,
                          &handle_hostname_response,
-                         ghc,
-                         GNUNET_TIME_absolute_get_remaining (ghc->timeout));
+                         rh,
+                         GNUNET_TIME_absolute_get_remaining (rh->timeout));
 }
 
 
+
+/**
+ * We've been asked to convert an address to a string without
+ * a reverse lookup.  Do it.
+ *
+ * @param cls struct GNUNET_RESOLVER_RequestHandle for the request
+ * @param tc unused scheduler context
+ */
+static void
+numeric_reverse (void *cls,
+                const struct GNUNET_SCHEDULER_TaskContext *tc)
+{
+  struct GNUNET_RESOLVER_RequestHandle *rh = cls;
+  char *result;
+
+  result = no_resolve ((const struct sockaddr*) &rh[1], 
+                      rh->salen);
+#if DEBUG_RESOLVER
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+             _("Resolver returns `%s'.\n"), result);
+#endif
+  if (result != NULL)
+    {
+      rh->name_callback (rh->cls, result);
+      GNUNET_free (result);
+    }
+  rh->name_callback (rh->cls, NULL);
+  GNUNET_free (rh);
+}
+
+
+
 /**
  * Get an IP address as a string.
  *
@@ -480,8 +631,9 @@ handle_hostname_response (void *cls, const struct GNUNET_MessageHeader *msg)
  * @param timeout how long to try resolving
  * @param callback function to call with hostnames
  * @param cls closure for callback
+ * @return handle that can be used to cancel the request
  */
-void
+struct GNUNET_RESOLVER_RequestHandle *
 GNUNET_RESOLVER_hostname_get (struct GNUNET_SCHEDULER_Handle *sched,
                               const struct GNUNET_CONFIGURATION_Handle *cfg,
                               const struct sockaddr *sa,
@@ -491,41 +643,47 @@ GNUNET_RESOLVER_hostname_get (struct GNUNET_SCHEDULER_Handle *sched,
                               GNUNET_RESOLVER_HostnameCallback callback,
                               void *cls)
 {
-  char *result;
   struct GNUNET_CLIENT_Connection *client;
   struct GNUNET_RESOLVER_GetMessage *msg;
-  struct GetHostnameContext *hctx;
+  struct GNUNET_RESOLVER_RequestHandle *rh;
+  char buf[GNUNET_SERVER_MAX_MESSAGE_SIZE];
 
   check_config (cfg);
+  rh = GNUNET_malloc (sizeof (struct GNUNET_RESOLVER_RequestHandle) + salen);
+  rh->name_callback = callback;
+  rh->cls = cls;
+  rh->timeout = GNUNET_TIME_relative_to_absolute (timeout);
+  rh->sched = sched;
+  rh->salen = salen;
+  memcpy (&rh[1], sa, salen);
+
   if (GNUNET_NO == do_resolve)
     {
-      result = no_resolve (sa, salen);
-#if DEBUG_RESOLVER
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  _("Resolver returns `%s'.\n"), result);
-#endif
-      callback (cls, result);
-      if (result != NULL)
-        {
-          GNUNET_free (result);
-          callback (cls, NULL);
-        }
-      return;
+      rh->task = GNUNET_SCHEDULER_add_delayed (sched,
+                                              GNUNET_NO,
+                                              GNUNET_SCHEDULER_PRIORITY_KEEP,
+                                              GNUNET_SCHEDULER_NO_TASK,
+                                              GNUNET_TIME_UNIT_ZERO,
+                                              &numeric_reverse,
+                                              rh);      
+      return rh;
     }
   if (salen + sizeof (struct GNUNET_RESOLVER_GetMessage) >
       GNUNET_SERVER_MAX_MESSAGE_SIZE)
     {
       GNUNET_break (0);
-      callback (cls, NULL);
-      return;
+      GNUNET_free (rh);
+      return NULL;
     }
   client = GNUNET_CLIENT_connect (sched, "resolver", cfg);
   if (client == NULL)
     {
-      callback (cls, NULL);
-      return;
+      GNUNET_free (rh);
+      return NULL;
     }
-  msg = GNUNET_malloc (sizeof (struct GNUNET_RESOLVER_GetMessage) + salen);
+  rh->client = client;
+
+  msg = (struct GNUNET_RESOLVER_GetMessage*) buf;
   msg->header.size =
     htons (sizeof (struct GNUNET_RESOLVER_GetMessage) + salen);
   msg->header.type = htons (GNUNET_MESSAGE_TYPE_RESOLVER_REQUEST);
@@ -536,36 +694,24 @@ GNUNET_RESOLVER_hostname_get (struct GNUNET_SCHEDULER_Handle *sched,
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               _("Resolver requests DNS resolution of IP address.\n"));
 #endif
-  hctx = GNUNET_malloc (sizeof (struct GetHostnameContext));
-  hctx->callback = callback;
-  hctx->cls = cls;
-  hctx->client = client;
-  hctx->timeout = GNUNET_TIME_relative_to_absolute (timeout);
   if (GNUNET_OK !=
       GNUNET_CLIENT_transmit_and_get_response (client,
                                               &msg->header,
                                               timeout,
                                               GNUNET_YES,
                                               &handle_hostname_response,
-                                              hctx))
+                                              rh))
     {
-      GNUNET_free (msg);
-      callback (cls, NULL);
       GNUNET_CLIENT_disconnect (client);
-      GNUNET_free (hctx);
-      return;
+      GNUNET_free (rh);
+      return NULL;
     }
-  GNUNET_free (msg);
+  return rh;
 }
 
-/**
- * Maximum supported length of hostname
- */
-#define MAX_HOSTNAME 1024
-
 
 /**
- * Resolve our hostname to an IP address.
+ * Perform a reverse DNS lookup.
  *
  * @param sched scheduler to use
  * @param cfg configuration to use
@@ -573,8 +719,9 @@ GNUNET_RESOLVER_hostname_get (struct GNUNET_SCHEDULER_Handle *sched,
  * @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
  */
-void
+struct GNUNET_RESOLVER_RequestHandle *
 GNUNET_RESOLVER_hostname_resolve (struct GNUNET_SCHEDULER_Handle *sched,
                                   const struct GNUNET_CONFIGURATION_Handle *cfg,
                                   int domain,
@@ -589,18 +736,36 @@ GNUNET_RESOLVER_hostname_resolve (struct GNUNET_SCHEDULER_Handle *sched,
     {
       GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR |
                            GNUNET_ERROR_TYPE_BULK, "gethostname");
-      callback (cls, NULL, 0);
-      return;
+      return NULL;
     }
 #if DEBUG_RESOLVER
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               _("Resolving our hostname `%s'\n"), hostname);
 #endif
-  GNUNET_RESOLVER_ip_get (sched,
-                          cfg, hostname, domain, timeout, callback, cls);
+  return GNUNET_RESOLVER_ip_get (sched,
+                                cfg, hostname, domain, timeout, callback, cls);
 }
 
 
+/**
+ * Cancel a request that is still pending with the resolver.
+ * Note that a client MUST NOT cancel a request that has
+ * been completed (i.e, the callback has been called to
+ * signal timeout or the final result).
+ *
+ * @param h handle of request to cancel
+ */
+void
+GNUNET_RESOLVER_request_cancel (struct GNUNET_RESOLVER_RequestHandle *h)
+{
+  if (h->client != NULL)
+    GNUNET_CLIENT_disconnect (h->client);
+  if (h->task != GNUNET_SCHEDULER_NO_TASK)
+    GNUNET_SCHEDULER_cancel (h->sched,
+                            h->task);
+  GNUNET_free (h);
+}
+
 
 
 /* end of resolver_api.c */

diff --git a/src/util/server.c b/src/util/server.c
index 646299718d79347ff4f687992f6b6c557180cd99..e6a753a18e6e20e019273b754a16b44731db4792 100644 (file)
--- a/src/util/server.c
+++ b/src/util/server.c
@@ -35,7 +35,7 @@
 #include "gnunet_time_lib.h"
 #include "gnunet_disk_lib.h"
 
-#define DEBUG_SERVER GNUNET_NO
+#define DEBUG_SERVER GNUNET_YES
 
 /**
  * List of arrays of message handlers.

diff --git a/src/util/test_connection.c b/src/util/test_connection.c
index 30eee76ce2c4a5500d1207cd1a3525f1e6936ac2..e144f66c1d9ff45166f6bc59cc0c8f13fa744237 100644 (file)
--- a/src/util/test_connection.c
+++ b/src/util/test_connection.c
@@ -144,6 +144,10 @@ make_hello (void *cls, size_t size, void *buf)
 #endif
   GNUNET_assert (size >= 12);
   strcpy ((char *) buf, "Hello World");
+#if VERBOSE
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Test destroys client socket\n");
+#endif
+  GNUNET_CONNECTION_destroy (csock);
   return 12;
 }
 
@@ -162,13 +166,10 @@ task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 #endif
   GNUNET_assert (NULL !=
                  GNUNET_CONNECTION_notify_transmit_ready (csock,
-                                                       12,
-                                                       GNUNET_TIME_UNIT_SECONDS,
-                                                       &make_hello, NULL));
-#if VERBOSE
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Test destroys client socket\n");
-#endif
-  GNUNET_CONNECTION_destroy (csock);
+                                                         12,
+                                                         GNUNET_TIME_UNIT_SECONDS,
+                                                         &make_hello, 
+                                                         NULL));
 #if VERBOSE
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Test prepares to accept\n");
 #endif