LRN: Use GNUNET_EXTRA_LOGGING to manage compile-time logging calls

[oweals/gnunet.git] / src / peerinfo / peerinfo_api.c

diff --git a/src/peerinfo/peerinfo_api.c b/src/peerinfo/peerinfo_api.c
index 5def415e979748df16e3fff259a63aba4c922b3d..28828f3a3f1be3680f59dfcbfc86538c6895eca9 100644 (file)
--- a/src/peerinfo/peerinfo_api.c
+++ b/src/peerinfo/peerinfo_api.c
@@ -1,10 +1,10 @@
 /*
      This file is part of GNUnet.
 /*
      This file is part of GNUnet.

-     (C) 2001, 2002, 2004, 2005, 2007, 2009 Christian Grothoff (and other contributing authors)
+     (C) 2001, 2002, 2004, 2005, 2007, 2009, 2010 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


@@ -33,12 +33,11 @@
 
 /**
  * Function to call after transmission has succeeded.
 
 /**
  * Function to call after transmission has succeeded.

- * 
+ *

  * @param cls closure
  * @param success GNUNET_OK if transmission worked, GNUNET_SYSERR on error
  */
  * @param cls closure
  * @param success GNUNET_OK if transmission worked, GNUNET_SYSERR on error
  */

-typedef void (*TransmissionContinuation)(void *cls,
-                                        int success);
+typedef void (*TransmissionContinuation) (void *cls, int success);

 
 
 /**
 
 
 /**


@@ -50,7 +49,7 @@ struct TransmissionQueueEntry
    * This is a linked list.
    */
   struct TransmissionQueueEntry *next;
    * This is a linked list.
    */
   struct TransmissionQueueEntry *next;

-  
+

   /**
    * This is a linked list.
    */
   /**
    * This is a linked list.
    */


@@ -61,7 +60,7 @@ struct TransmissionQueueEntry
    * case we must consider sending the next entry immediately).
    */
   TransmissionContinuation cont;
    * case we must consider sending the next entry immediately).
    */
   TransmissionContinuation cont;

-  
+

   /**
    * Closure for 'cont'.
    */
   /**
    * Closure for 'cont'.
    */


@@ -90,11 +89,6 @@ struct GNUNET_PEERINFO_Handle
    */
   const struct GNUNET_CONFIGURATION_Handle *cfg;
 
    */
   const struct GNUNET_CONFIGURATION_Handle *cfg;
 

-  /**
-   * Our scheduler.
-   */
-  struct GNUNET_SCHEDULER_Handle *sched;
-

   /**
    * Connection to the service.
    */
   /**
    * Connection to the service.
    */


@@ -115,6 +109,11 @@ struct GNUNET_PEERINFO_Handle
    */
   struct GNUNET_CLIENT_TransmitHandle *th;
 
    */
   struct GNUNET_CLIENT_TransmitHandle *th;
 

+  /**
+   * ID for a reconnect task.
+   */
+  GNUNET_SCHEDULER_TaskIdentifier r_task;
+

   /**
    * Set to GNUNET_YES if we are currently receiving replies from the
    * service.
   /**
    * Set to GNUNET_YES if we are currently receiving replies from the
    * service.


@@ -127,25 +126,18 @@ struct GNUNET_PEERINFO_Handle
 /**
  * Connect to the peerinfo service.
  *
 /**
  * Connect to the peerinfo service.
  *

- * @param sched scheduler to use

  * @param cfg configuration to use
  * @return NULL on error (configuration related, actual connection
  * @param cfg configuration to use
  * @return NULL on error (configuration related, actual connection

- *         etablishment may happen asynchronously).
+ *         establishment may happen asynchronously).

  */
 struct GNUNET_PEERINFO_Handle *
  */
 struct GNUNET_PEERINFO_Handle *

-GNUNET_PEERINFO_connect (struct GNUNET_SCHEDULER_Handle *sched,
-                        const struct GNUNET_CONFIGURATION_Handle *cfg)                  
+GNUNET_PEERINFO_connect (const struct GNUNET_CONFIGURATION_Handle *cfg)

 {
 {

-  struct GNUNET_CLIENT_Connection *client;

   struct GNUNET_PEERINFO_Handle *ret;
 
   struct GNUNET_PEERINFO_Handle *ret;
 

-  client = GNUNET_CLIENT_connect (sched, "peerinfo", cfg);
-  if (client == NULL)
-    return NULL;

   ret = GNUNET_malloc (sizeof (struct GNUNET_PEERINFO_Handle));
   ret = GNUNET_malloc (sizeof (struct GNUNET_PEERINFO_Handle));

-  ret->client = client;
+  ret->client = GNUNET_CLIENT_connect ("peerinfo", cfg);

   ret->cfg = cfg;
   ret->cfg = cfg;

-  ret->sched = sched;

   return ret;
 }
 
   return ret;
 }
 


@@ -165,20 +157,27 @@ GNUNET_PEERINFO_disconnect (struct GNUNET_PEERINFO_Handle *h)
   struct TransmissionQueueEntry *tqe;
 
   while (NULL != (tqe = h->tq_head))
   struct TransmissionQueueEntry *tqe;
 
   while (NULL != (tqe = h->tq_head))

-    {     
-      GNUNET_CONTAINER_DLL_remove (h->tq_head,
-                                  h->tq_tail,
-                                  tqe);
-      if (tqe->cont != NULL)
-       tqe->cont (tqe->cont_cls, GNUNET_SYSERR);
-      GNUNET_free (tqe);
-    }
+  {
+    GNUNET_CONTAINER_DLL_remove (h->tq_head, h->tq_tail, tqe);
+    if (tqe->cont != NULL)
+      tqe->cont (tqe->cont_cls, GNUNET_SYSERR);
+    GNUNET_free (tqe);
+  }

   if (h->th != NULL)
   if (h->th != NULL)

-    {
-      GNUNET_CLIENT_notify_transmit_ready_cancel (h->th);
-      h->th = NULL;
-    }
-  GNUNET_CLIENT_disconnect (h->client, GNUNET_NO);
+  {
+    GNUNET_CLIENT_notify_transmit_ready_cancel (h->th);
+    h->th = NULL;
+  }
+  if (NULL != h->client)
+  {
+    GNUNET_CLIENT_disconnect (h->client, GNUNET_NO);
+    h->client = NULL;
+  }
+  if (GNUNET_SCHEDULER_NO_TASK != h->r_task)
+  {
+    GNUNET_SCHEDULER_cancel (h->r_task);
+    h->r_task = GNUNET_SCHEDULER_NO_TASK;
+  }

   GNUNET_free (h);
 }
 
   GNUNET_free (h);
 }
 


@@ -193,6 +192,30 @@ static void
 trigger_transmit (struct GNUNET_PEERINFO_Handle *h);
 
 
 trigger_transmit (struct GNUNET_PEERINFO_Handle *h);
 
 

+/**
+ * Close the existing connection to PEERINFO and reconnect.
+ *
+ * @param h handle to the service
+ */
+static void
+reconnect (struct GNUNET_PEERINFO_Handle *h);
+
+/**
+ * Task scheduled to re-try connecting to the peerinfo service.
+ *
+ * @param cls the 'struct GNUNET_PEERINFO_Handle'
+ * @param tc scheduler context
+ */
+static void
+reconnect_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+{
+  struct GNUNET_PEERINFO_Handle *h = cls;
+
+  h->r_task = GNUNET_SCHEDULER_NO_TASK;
+  reconnect (h);
+}
+
+

 /**
  * Close the existing connection to PEERINFO and reconnect.
  *
 /**
  * Close the existing connection to PEERINFO and reconnect.
  *


@@ -201,9 +224,30 @@ trigger_transmit (struct GNUNET_PEERINFO_Handle *h);
 static void
 reconnect (struct GNUNET_PEERINFO_Handle *h)
 {
 static void
 reconnect (struct GNUNET_PEERINFO_Handle *h)
 {

-  GNUNET_CLIENT_disconnect (h->client, GNUNET_SYSERR);
-  h->client = GNUNET_CLIENT_connect (h->sched, "peerinfo", h->cfg);
-  GNUNET_assert (h->client != NULL);
+  if (h->r_task != GNUNET_SCHEDULER_NO_TASK)
+  {
+    GNUNET_SCHEDULER_cancel (h->r_task);
+    h->r_task = GNUNET_SCHEDULER_NO_TASK;
+  }
+  if (NULL != h->th)
+  {
+    GNUNET_CLIENT_notify_transmit_ready_cancel (h->th);
+    h->th = NULL;
+  }
+  if (NULL != h->client)
+  {
+    GNUNET_CLIENT_disconnect (h->client, GNUNET_SYSERR);
+    h->client = NULL;
+  }
+  h->client = GNUNET_CLIENT_connect ("peerinfo", h->cfg);
+  if (NULL == h->client)
+  {
+    h->r_task =
+        GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS, &reconnect_task,
+                                      h);
+    return;
+  }
+  trigger_transmit (h);

 }
 
 
 }
 
 


@@ -224,34 +268,28 @@ do_transmit (void *cls, size_t size, void *buf)
   size_t ret;
 
   h->th = NULL;
   size_t ret;
 
   h->th = NULL;

+  if (tqe == NULL)
+    return 0;

   if (buf == NULL)
   if (buf == NULL)

-    {
-#if DEBUG_PEERINFO
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  _
-                  ("Failed to transmit message of type %u to `%s' service.\n"),
-                  ntohs (msg->type), "peerinfo");
-#endif
-      if (tqe != NULL)
-       GNUNET_CONTAINER_DLL_remove (h->tq_head,
-                                    h->tq_tail,
-                                    tqe);
-      reconnect (h);
-      trigger_transmit (h);
-      if (tqe != NULL)
-       {
-         if (tqe->cont != NULL)
-           tqe->cont (tqe->cont_cls, GNUNET_SYSERR);
-         GNUNET_free (tqe);
-       }
-      return 0;
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING | GNUNET_ERROR_TYPE_BULK,
+                _("Failed to transmit message to `%s' service.\n"), "PEERINFO");
+    GNUNET_CONTAINER_DLL_remove (h->tq_head, h->tq_tail, tqe);
+    reconnect (h);
+    if (tqe->cont != NULL)
+      tqe->cont (tqe->cont_cls, GNUNET_SYSERR);
+    GNUNET_free (tqe);
+    return 0;
+  }

   ret = tqe->size;
   GNUNET_assert (size >= ret);
   memcpy (buf, &tqe[1], ret);
   ret = tqe->size;
   GNUNET_assert (size >= ret);
   memcpy (buf, &tqe[1], ret);

-  GNUNET_CONTAINER_DLL_remove (h->tq_head,
-                              h->tq_tail,
-                              tqe);
+#if DEBUG_PEERINFO
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Transmitting request of size %u to `%s' service.\n", ret,
+              "PEERINFO");
+#endif
+  GNUNET_CONTAINER_DLL_remove (h->tq_head, h->tq_tail, tqe);

   if (tqe->cont != NULL)
     tqe->cont (tqe->cont_cls, GNUNET_OK);
   else
   if (tqe->cont != NULL)
     tqe->cont (tqe->cont_cls, GNUNET_OK);
   else


@@ -278,16 +316,21 @@ trigger_transmit (struct GNUNET_PEERINFO_Handle *h)
     return;
   if (h->in_receive == GNUNET_YES)
     return;
     return;
   if (h->in_receive == GNUNET_YES)
     return;

-  h->th = GNUNET_CLIENT_notify_transmit_ready (h->client,
-                                              tqe->size,
-                                              GNUNET_TIME_absolute_get_remaining (tqe->timeout),
-                                              GNUNET_YES,
-                                              &do_transmit, h);  
+  if (NULL == h->client)
+  {
+    reconnect (h);
+    return;
+  }
+  h->th =
+      GNUNET_CLIENT_notify_transmit_ready (h->client, tqe->size,
+                                           GNUNET_TIME_absolute_get_remaining
+                                           (tqe->timeout), GNUNET_YES,
+                                           &do_transmit, h);

 }
 
 
 /**
 }
 
 
 /**

- * Add a host to the persistent list.  This method operates in 
+ * Add a host to the persistent list.  This method operates in

  * semi-reliable mode: if the transmission is not completed by
  * the time 'GNUNET_PEERINFO_disconnect' is called, it will be
  * aborted.  Furthermore, if a second HELLO is added for the
  * semi-reliable mode: if the transmission is not completed by
  * the time 'GNUNET_PEERINFO_disconnect' is called, it will be
  * aborted.  Furthermore, if a second HELLO is added for the


@@ -299,28 +342,24 @@ trigger_transmit (struct GNUNET_PEERINFO_Handle *h)
  */
 void
 GNUNET_PEERINFO_add_peer (struct GNUNET_PEERINFO_Handle *h,
  */
 void
 GNUNET_PEERINFO_add_peer (struct GNUNET_PEERINFO_Handle *h,

-                         const struct GNUNET_HELLO_Message *hello)
+                          const struct GNUNET_HELLO_Message *hello)

 {
   uint16_t hs = GNUNET_HELLO_size (hello);
   struct TransmissionQueueEntry *tqe;
 {
   uint16_t hs = GNUNET_HELLO_size (hello);
   struct TransmissionQueueEntry *tqe;

-  
+

 #if DEBUG_PEERINFO
   struct GNUNET_PeerIdentity peer;
 #if DEBUG_PEERINFO
   struct GNUNET_PeerIdentity peer;

+

   GNUNET_assert (GNUNET_OK == GNUNET_HELLO_get_id (hello, &peer));
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
   GNUNET_assert (GNUNET_OK == GNUNET_HELLO_get_id (hello, &peer));
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,

-             "Adding peer `%s' to PEERINFO database (%u bytes of `%s')\n",
-             GNUNET_i2s(&peer),
-             hs,
-             "HELLO");
+              "Adding peer `%s' to PEERINFO database (%u bytes of `%s')\n",
+              GNUNET_i2s (&peer), hs, "HELLO");

 #endif
   tqe = GNUNET_malloc (sizeof (struct TransmissionQueueEntry) + hs);
   tqe->size = hs;
   tqe->timeout = GNUNET_TIME_UNIT_FOREVER_ABS;
   memcpy (&tqe[1], hello, hs);
 #endif
   tqe = GNUNET_malloc (sizeof (struct TransmissionQueueEntry) + hs);
   tqe->size = hs;
   tqe->timeout = GNUNET_TIME_UNIT_FOREVER_ABS;
   memcpy (&tqe[1], hello, hs);

-  GNUNET_CONTAINER_DLL_insert_after (h->tq_head,
-                                    h->tq_tail,
-                                    h->tq_tail,
-                                    tqe);
+  GNUNET_CONTAINER_DLL_insert_after (h->tq_head, h->tq_tail, h->tq_tail, tqe);

   trigger_transmit (h);
 }
 
   trigger_transmit (h);
 }
 


@@ -384,82 +423,74 @@ peerinfo_handler (void *cls, const struct GNUNET_MessageHeader *msg)
 
   ic->h->in_receive = GNUNET_NO;
   if (msg == NULL)
 
   ic->h->in_receive = GNUNET_NO;
   if (msg == NULL)

-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-                  _("Failed to receive response from `%s' service.\n"),
-                  "peerinfo");
-      reconnect (ic->h);
-      trigger_transmit (ic->h);
-      if (ic->timeout_task != GNUNET_SCHEDULER_NO_TASK)
-       GNUNET_SCHEDULER_cancel (ic->h->sched, 
-                                ic->timeout_task);
-      if (ic->callback != NULL)
-       ic->callback (ic->callback_cls, NULL, NULL, 1);
-      GNUNET_free (ic);
-      return;
-    }
+  {
+    reconnect (ic->h);
+    if (ic->timeout_task != GNUNET_SCHEDULER_NO_TASK)
+      GNUNET_SCHEDULER_cancel (ic->timeout_task);
+    if (ic->callback != NULL)
+      ic->callback (ic->callback_cls, NULL, NULL,
+                    _("Failed to receive response from `PEERINFO' service."));
+    GNUNET_free (ic);
+    return;
+  }

   if (ntohs (msg->type) == GNUNET_MESSAGE_TYPE_PEERINFO_INFO_END)
   if (ntohs (msg->type) == GNUNET_MESSAGE_TYPE_PEERINFO_INFO_END)

-    {
+  {

 #if DEBUG_PEERINFO
 #if DEBUG_PEERINFO

-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                 "Received end of list of peers from peerinfo database\n");
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Received end of list of peers from `%s' service\n",
+                "PEERINFO");

 #endif
 #endif

-      trigger_transmit (ic->h);
-      if (ic->timeout_task != GNUNET_SCHEDULER_NO_TASK)
-       GNUNET_SCHEDULER_cancel (ic->h->sched, 
-                                ic->timeout_task);
-      if (ic->callback != NULL)
-       ic->callback (ic->callback_cls, NULL, NULL, 0);
-      GNUNET_free (ic);
-      return;
-    }
+    trigger_transmit (ic->h);
+    if (ic->timeout_task != GNUNET_SCHEDULER_NO_TASK)
+      GNUNET_SCHEDULER_cancel (ic->timeout_task);
+    if (ic->callback != NULL)
+      ic->callback (ic->callback_cls, NULL, NULL, NULL);
+    GNUNET_free (ic);
+    return;
+  }

   ms = ntohs (msg->size);
   if ((ms < sizeof (struct InfoMessage)) ||
       (ntohs (msg->type) != GNUNET_MESSAGE_TYPE_PEERINFO_INFO))
   ms = ntohs (msg->size);
   if ((ms < sizeof (struct InfoMessage)) ||
       (ntohs (msg->type) != GNUNET_MESSAGE_TYPE_PEERINFO_INFO))

+  {
+    GNUNET_break (0);
+    reconnect (ic->h);
+    if (ic->timeout_task != GNUNET_SCHEDULER_NO_TASK)
+      GNUNET_SCHEDULER_cancel (ic->timeout_task);
+    if (ic->callback != NULL)
+      ic->callback (ic->callback_cls, NULL, NULL,
+                    _("Received invalid message from `PEERINFO' service.\n"));
+    GNUNET_free (ic);
+    return;
+  }
+  im = (const struct InfoMessage *) msg;
+  GNUNET_break (0 == ntohl (im->reserved));
+  hello = NULL;
+  if (ms > sizeof (struct InfoMessage) + sizeof (struct GNUNET_MessageHeader))
+  {
+    hello = (const struct GNUNET_HELLO_Message *) &im[1];
+    if (ms != sizeof (struct InfoMessage) + GNUNET_HELLO_size (hello))

     {
       GNUNET_break (0);
       reconnect (ic->h);
     {
       GNUNET_break (0);
       reconnect (ic->h);

-      trigger_transmit (ic->h);

       if (ic->timeout_task != GNUNET_SCHEDULER_NO_TASK)
       if (ic->timeout_task != GNUNET_SCHEDULER_NO_TASK)

-       GNUNET_SCHEDULER_cancel (ic->h->sched, 
-                                ic->timeout_task);
+        GNUNET_SCHEDULER_cancel (ic->timeout_task);

       if (ic->callback != NULL)
       if (ic->callback != NULL)

-       ic->callback (ic->callback_cls, NULL, NULL, 2);
+        ic->callback (ic->callback_cls, NULL, NULL,
+                      _("Received invalid message from `PEERINFO' service.\n"));

       GNUNET_free (ic);
       return;
     }
       GNUNET_free (ic);
       return;
     }

-  im = (const struct InfoMessage *) msg;
-  hello = NULL;
-  if (ms > sizeof (struct InfoMessage) + sizeof (struct GNUNET_MessageHeader))
-    {
-      hello = (const struct GNUNET_HELLO_Message *) &im[1];
-      if (ms != sizeof (struct InfoMessage) + GNUNET_HELLO_size (hello))
-        {
-         GNUNET_break (0);
-         reconnect (ic->h);
-         trigger_transmit (ic->h);
-         if (ic->timeout_task != GNUNET_SCHEDULER_NO_TASK)
-           GNUNET_SCHEDULER_cancel (ic->h->sched, 
-                                    ic->timeout_task);
-         if (ic->callback != NULL)
-           ic->callback (ic->callback_cls, NULL, NULL, 2);
-         GNUNET_free (ic);
-          return;
-        }
-    }
+  }

 #if DEBUG_PEERINFO
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 #if DEBUG_PEERINFO
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,

-             "Received %u bytes of `%s' information about peer `%s' from PEERINFO database\n",
-             (hello == NULL) ? 0 : (unsigned int) GNUNET_HELLO_size (hello),
-             "HELLO",
-             GNUNET_i2s (&im->peer));
+              "Received %u bytes of `%s' information about peer `%s' from `%s' service\n",
+              (hello == NULL) ? 0 : (unsigned int) GNUNET_HELLO_size (hello),
+              "HELLO", GNUNET_i2s (&im->peer), "PEERINFO");

 #endif
   ic->h->in_receive = GNUNET_YES;
   if (ic->callback != NULL)
 #endif
   ic->h->in_receive = GNUNET_YES;
   if (ic->callback != NULL)

-    ic->callback (ic->callback_cls, &im->peer, hello, ntohl (im->trust));
-  GNUNET_CLIENT_receive (ic->h->client,
-                         &peerinfo_handler,
-                         ic,
+    ic->callback (ic->callback_cls, &im->peer, hello, NULL);
+  GNUNET_CLIENT_receive (ic->h->client, &peerinfo_handler, ic,

                          GNUNET_TIME_absolute_get_remaining (ic->timeout));
 }
 
                          GNUNET_TIME_absolute_get_remaining (ic->timeout));
 }
 


@@ -472,57 +503,58 @@ peerinfo_handler (void *cls, const struct GNUNET_MessageHeader *msg)
  * @param transmit_success GNUNET_OK if transmission worked
  */
 static void
  * @param transmit_success GNUNET_OK if transmission worked
  */
 static void

-iterator_start_receive (void *cls,
-                       int transmit_success)
+iterator_start_receive (void *cls, int transmit_success)

 {
   struct GNUNET_PEERINFO_IteratorContext *ic = cls;
 
   if (GNUNET_OK != transmit_success)
 {
   struct GNUNET_PEERINFO_IteratorContext *ic = cls;
 
   if (GNUNET_OK != transmit_success)

+  {
+    if (ic->timeout_task != GNUNET_SCHEDULER_NO_TASK)

     {
     {

-      if (ic->timeout_task != GNUNET_SCHEDULER_NO_TASK)
-       {
-         GNUNET_SCHEDULER_cancel (ic->h->sched,
-                                  ic->timeout_task);
-         ic->timeout_task = GNUNET_SCHEDULER_NO_TASK;
-       }
-      reconnect (ic->h);
-      trigger_transmit (ic->h);
-      ic->callback (ic->callback_cls, NULL, NULL, 1);
-      GNUNET_free (ic);
-      return;
-    }  
+      GNUNET_SCHEDULER_cancel (ic->timeout_task);
+      ic->timeout_task = GNUNET_SCHEDULER_NO_TASK;
+    }
+    reconnect (ic->h);
+    if (ic->callback != NULL)
+      ic->callback (ic->callback_cls, NULL, NULL,
+                    _
+                    ("Failed to transmit iteration request to `PEERINFO' service\n"));
+    GNUNET_free (ic);
+    return;
+  }
+#if DEBUG_PEERINFO
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Waiting for response from `%s' service.\n", "PEERINFO");
+#endif

   ic->h->in_receive = GNUNET_YES;
   ic->in_receive = GNUNET_YES;
   ic->tqe = NULL;
   ic->h->in_receive = GNUNET_YES;
   ic->in_receive = GNUNET_YES;
   ic->tqe = NULL;

-  GNUNET_CLIENT_receive (ic->h->client,
-                         &peerinfo_handler,
-                         ic,
+  GNUNET_CLIENT_receive (ic->h->client, &peerinfo_handler, ic,

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

- * Peerinfo iteration request has timed out.  
+ * Peerinfo iteration request has timed out.

  *
  * @param cls the 'struct GNUNET_PEERINFO_IteratorContext*'
  * @param tc scheduler context
  */
 static void
  *
  * @param cls the 'struct GNUNET_PEERINFO_IteratorContext*'
  * @param tc scheduler context
  */
 static void

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

 {
   struct GNUNET_PEERINFO_IteratorContext *ic = cls;
 
   ic->timeout_task = GNUNET_SCHEDULER_NO_TASK;
 {
   struct GNUNET_PEERINFO_IteratorContext *ic = cls;
 
   ic->timeout_task = GNUNET_SCHEDULER_NO_TASK;

-  if (! ic->in_receive)
-    GNUNET_CONTAINER_DLL_remove (ic->h->tq_head,
-                                ic->h->tq_tail,
-                                ic->tqe);
-  ic->callback (ic->callback_cls, NULL, NULL, 1);
+  if (!ic->in_receive)
+    GNUNET_CONTAINER_DLL_remove (ic->h->tq_head, ic->h->tq_tail, ic->tqe);
+  else
+    reconnect (ic->h);
+  ic->callback (ic->callback_cls, NULL, NULL,
+                _
+                ("Timeout transmitting iteration request to `PEERINFO' service.\n"));

   ic->callback = NULL;
   ic->callback = NULL;

-  if (ic->in_receive)
-    return;
-  GNUNET_free (ic->tqe);
+  GNUNET_free_non_null (ic->tqe);

   GNUNET_free (ic);
 }
 
   GNUNET_free (ic);
 }
 


@@ -533,84 +565,75 @@ signal_timeout (void *cls,
  * host and then finally once with a NULL pointer.  After that final
  * invocation, the iterator context must no longer be used.
  *
  * host and then finally once with a NULL pointer.  After that final
  * invocation, the iterator context must no longer be used.
  *

- * Note that the last call can be triggered by timeout or by simply
- * being done; however, the trust argument will be set to zero if we
- * are done, 1 if we timed out and 2 for fatal error.
+ * Instead of calling this function with 'peer == NULL' it is often
+ * better to use 'GNUNET_PEERINFO_notify'.

  *
  *

- * Instead of calling this function with 'peer == NULL' and 'trust ==
- * 0', it is often better to use 'GNUNET_PEERINFO_notify'.
- * 

  * @param h handle to the peerinfo service
  * @param peer restrict iteration to this peer only (can be NULL)
  * @param h handle to the peerinfo service
  * @param peer restrict iteration to this peer only (can be NULL)

- * @param trust_delta how much to change the trust in all matching peers

  * @param timeout how long to wait until timing out
  * @param callback the method to call for each peer
  * @param callback_cls closure for callback
  * @param timeout how long to wait until timing out
  * @param callback the method to call for each peer
  * @param callback_cls closure for callback

- * @return NULL on error (in this case, 'callback' is never called!), 
- *         otherwise an iterator context
+ * @return iterator context

  */
 struct GNUNET_PEERINFO_IteratorContext *
 GNUNET_PEERINFO_iterate (struct GNUNET_PEERINFO_Handle *h,
  */
 struct GNUNET_PEERINFO_IteratorContext *
 GNUNET_PEERINFO_iterate (struct GNUNET_PEERINFO_Handle *h,

-                        const struct GNUNET_PeerIdentity *peer,
-                        int trust_delta,
-                        struct GNUNET_TIME_Relative timeout,
-                        GNUNET_PEERINFO_Processor callback,
-                        void *callback_cls)
+                         const struct GNUNET_PeerIdentity *peer,
+                         struct GNUNET_TIME_Relative timeout,
+                         GNUNET_PEERINFO_Processor callback, void *callback_cls)

 {
 {

-  struct ListAllPeersMessage *lapm;
+  struct GNUNET_MessageHeader *lapm;

   struct ListPeerMessage *lpm;
   struct GNUNET_PEERINFO_IteratorContext *ic;
   struct TransmissionQueueEntry *tqe;
 
   struct ListPeerMessage *lpm;
   struct GNUNET_PEERINFO_IteratorContext *ic;
   struct TransmissionQueueEntry *tqe;
 

+  if (peer == NULL)
+  {

 #if DEBUG_PEERINFO
 #if DEBUG_PEERINFO

-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-             "Requesting list of peers from peerinfo database\n");
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Requesting list of peers from PEERINFO service\n");

 #endif
 #endif

-  if (peer == NULL)
-    {
-      tqe = GNUNET_malloc (sizeof (struct TransmissionQueueEntry) +
-                          sizeof (struct ListAllPeersMessage));
-      tqe->size = sizeof (struct ListAllPeersMessage);
-      lapm = (struct ListAllPeersMessage *) &tqe[1];
-      lapm->header.size = htons (sizeof (struct ListAllPeersMessage));
-      lapm->header.type = htons (GNUNET_MESSAGE_TYPE_PEERINFO_GET_ALL);
-      lapm->trust_change = htonl (trust_delta);
-    }
+    tqe =
+        GNUNET_malloc (sizeof (struct TransmissionQueueEntry) +
+                       sizeof (struct GNUNET_MessageHeader));
+    tqe->size = sizeof (struct GNUNET_MessageHeader);
+    lapm = (struct GNUNET_MessageHeader *) &tqe[1];
+    lapm->size = htons (sizeof (struct GNUNET_MessageHeader));
+    lapm->type = htons (GNUNET_MESSAGE_TYPE_PEERINFO_GET_ALL);
+  }

   else
   else

-    {
-      tqe = GNUNET_malloc (sizeof (struct TransmissionQueueEntry) +
-                          sizeof (struct ListPeerMessage));
-      tqe->size = sizeof (struct ListPeerMessage);
-      lpm = (struct ListPeerMessage *) &tqe[1];
-      lpm->header.size = htons (sizeof (struct ListPeerMessage));
-      lpm->header.type = htons (GNUNET_MESSAGE_TYPE_PEERINFO_GET);
-      lpm->trust_change = htonl (trust_delta);
-      memcpy (&lpm->peer, peer, sizeof (struct GNUNET_PeerIdentity));
-    }
+  {
+#if DEBUG_PEERINFO
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Requesting information on peer `%4s' from PEERINFO service\n",
+                GNUNET_i2s (peer));
+#endif
+    tqe =
+        GNUNET_malloc (sizeof (struct TransmissionQueueEntry) +
+                       sizeof (struct ListPeerMessage));
+    tqe->size = sizeof (struct ListPeerMessage);
+    lpm = (struct ListPeerMessage *) &tqe[1];
+    lpm->header.size = htons (sizeof (struct ListPeerMessage));
+    lpm->header.type = htons (GNUNET_MESSAGE_TYPE_PEERINFO_GET);
+    memcpy (&lpm->peer, peer, sizeof (struct GNUNET_PeerIdentity));
+  }

   ic = GNUNET_malloc (sizeof (struct GNUNET_PEERINFO_IteratorContext));
   ic->h = h;
   ic->tqe = tqe;
   ic->callback = callback;
   ic->callback_cls = callback_cls;
   ic->timeout = GNUNET_TIME_relative_to_absolute (timeout);
   ic = GNUNET_malloc (sizeof (struct GNUNET_PEERINFO_IteratorContext));
   ic->h = h;
   ic->tqe = tqe;
   ic->callback = callback;
   ic->callback_cls = callback_cls;
   ic->timeout = GNUNET_TIME_relative_to_absolute (timeout);

-  ic->timeout_task = GNUNET_SCHEDULER_add_delayed (h->sched, 
-                                                  timeout,
-                                                  &signal_timeout,
-                                                  ic);
+  ic->timeout_task =
+      GNUNET_SCHEDULER_add_delayed (timeout, &signal_timeout, ic);

   tqe->timeout = ic->timeout;
   tqe->cont = &iterator_start_receive;
   tqe->cont_cls = ic;
   tqe->timeout = ic->timeout;
   tqe->timeout = ic->timeout;
   tqe->cont = &iterator_start_receive;
   tqe->cont_cls = ic;
   tqe->timeout = ic->timeout;

-  GNUNET_CONTAINER_DLL_insert_after (h->tq_head,
-                                    h->tq_tail,
-                                    h->tq_tail,
-                                    tqe);
+  GNUNET_CONTAINER_DLL_insert_after (h->tq_head, h->tq_tail, h->tq_tail, tqe);

   trigger_transmit (h);
   return ic;
 }
 
 
   trigger_transmit (h);
   return ic;
 }
 
 

-

 /**
  * Cancel an iteration over peer information.
  *
 /**
  * Cancel an iteration over peer information.
  *


@@ -620,17 +643,14 @@ void
 GNUNET_PEERINFO_iterate_cancel (struct GNUNET_PEERINFO_IteratorContext *ic)
 {
   if (ic->timeout_task != GNUNET_SCHEDULER_NO_TASK)
 GNUNET_PEERINFO_iterate_cancel (struct GNUNET_PEERINFO_IteratorContext *ic)
 {
   if (ic->timeout_task != GNUNET_SCHEDULER_NO_TASK)

-    {
-      GNUNET_SCHEDULER_cancel (ic->h->sched,
-                              ic->timeout_task);
-      ic->timeout_task = GNUNET_SCHEDULER_NO_TASK;
-    }
+  {
+    GNUNET_SCHEDULER_cancel (ic->timeout_task);
+    ic->timeout_task = GNUNET_SCHEDULER_NO_TASK;
+  }

   ic->callback = NULL;
   ic->callback = NULL;

-  if (ic->in_receive)
-    return; /* need to finish processing */
-  GNUNET_CONTAINER_DLL_remove (ic->h->tq_head,
-                              ic->h->tq_tail,
-                              ic->tqe);
+  if (GNUNET_YES == ic->in_receive)
+    return;                     /* need to finish processing */
+  GNUNET_CONTAINER_DLL_remove (ic->h->tq_head, ic->h->tq_tail, ic->tqe);

   GNUNET_free (ic->tqe);
   GNUNET_free (ic);
 }
   GNUNET_free (ic->tqe);
   GNUNET_free (ic);
 }