update peerinfo API to use MQ

5 files changed, 353 insertions, 588 deletions

diff --git a/src/peerinfo/peerinfo_api.c b/src/peerinfo/peerinfo_api.c
index 0637eda72..e477186ee 100644
--- a/src/peerinfo/peerinfo_api.c
+++ b/src/peerinfo/peerinfo_api.c
@@ -32,46 +32,6 @@
 
 
 /**
- * Entry in the transmission queue to PEERINFO service.  We use
- * the same structure for queueing 'iteration' requests and
- * actual 'add' messages.
- */
-struct GNUNET_PEERINFO_AddContext
-{
-  /**
-   * This is a linked list.
-   */
-  struct GNUNET_PEERINFO_AddContext *next;
-
-  /**
-   * This is a linked list.
-   */
-  struct GNUNET_PEERINFO_AddContext *prev;
-
-  /**
-   * Handle to the PEERINFO service.
-   */
-  struct GNUNET_PEERINFO_Handle *h;
-
-  /**
-   * Function to call after request has been transmitted, or NULL.
-   */
-  GNUNET_PEERINFO_Continuation cont;
-
-  /**
-   * Closure for @e cont.
-   */
-  void *cont_cls;
-
-  /**
-   * Number of bytes of the request message (follows after this struct).
-   */
-  size_t size;
-
-};
-
-
-/**
  * Context for an iteration request.
  */
 struct GNUNET_PEERINFO_IteratorContext
@@ -103,21 +63,6 @@ struct GNUNET_PEERINFO_IteratorContext
   void *callback_cls;
 
   /**
-   * Our entry in the transmission queue.
-   */
-  struct GNUNET_PEERINFO_AddContext *ac;
-
-  /**
-   * Task responsible for timeout.
-   */
-  struct GNUNET_SCHEDULER_Task *timeout_task;
-
-  /**
-   * Timeout for the operation.
-   */
-  struct GNUNET_TIME_Absolute timeout;
-
-  /**
    * Peer we are interested in (only valid if iteration was restricted to one peer).
    */
   struct GNUNET_PeerIdentity peer;
@@ -128,10 +73,9 @@ struct GNUNET_PEERINFO_IteratorContext
   int have_peer;
 
   /**
-   * Set to #GNUNET_YES if we are currently receiving replies from the
-   * service.
+   * Only include friends in reply?
    */
-  int request_transmitted;
+  int include_friend_only;
 
 };
 
@@ -149,22 +93,7 @@ struct GNUNET_PEERINFO_Handle
   /**
    * Connection to the service.
    */
-  struct GNUNET_CLIENT_Connection *client;
-
-  /**
-   * Head of transmission queue.
-   */
-  struct GNUNET_PEERINFO_AddContext *ac_head;
-
-  /**
-   * Tail of transmission queue.
-   */
-  struct GNUNET_PEERINFO_AddContext *ac_tail;
-
-  /**
-   * Handle for the current transmission request, or NULL if none is pending.
-   */
-  struct GNUNET_CLIENT_TransmitHandle *th;
+  struct GNUNET_MQ_Handle *mq;
 
   /**
    * Head of iterator DLL.
@@ -181,15 +110,19 @@ struct GNUNET_PEERINFO_Handle
    */
   struct GNUNET_SCHEDULER_Task *r_task;
 
-  /**
-   * Are we now receiving?
-   */
-  int in_receive;
-
 };
 
 
 /**
+ * Close the existing connection to PEERINFO and reconnect.
+ *
+ * @param h handle to the service
+ */
+static void
+reconnect (struct GNUNET_PEERINFO_Handle *h);
+
+
+/**
  * Connect to the peerinfo service.
  *
  * @param cfg configuration to use
@@ -202,8 +135,13 @@ GNUNET_PEERINFO_connect (const struct GNUNET_CONFIGURATION_Handle *cfg)
   struct GNUNET_PEERINFO_Handle *h;
 
   h = GNUNET_new (struct GNUNET_PEERINFO_Handle);
-  h->client = GNUNET_CLIENT_connect ("peerinfo", cfg);
   h->cfg = cfg;
+  reconnect (h);
+  if (NULL == h->mq)
+  {
+    GNUNET_free (h);
+    return NULL;
+  }
   return h;
 }
 
@@ -220,32 +158,19 @@ GNUNET_PEERINFO_connect (const struct GNUNET_CONFIGURATION_Handle *cfg)
 void
 GNUNET_PEERINFO_disconnect (struct GNUNET_PEERINFO_Handle *h)
 {
-  struct GNUNET_PEERINFO_AddContext *ac;
   struct GNUNET_PEERINFO_IteratorContext *ic;
 
   while (NULL != (ic = h->ic_head))
   {
-    GNUNET_break (GNUNET_YES == ic->request_transmitted);
-    ic->request_transmitted = GNUNET_NO;
-    GNUNET_PEERINFO_iterate_cancel (ic);
-  }
-  while (NULL != (ac = h->ac_head))
-  {
-    GNUNET_CONTAINER_DLL_remove (h->ac_head, h->ac_tail, ac);
-    if (NULL != ac->cont)
-      ac->cont (ac->cont_cls,
-                _("aborted due to explicit disconnect request"));
-    GNUNET_free (ac);
-  }
-  if (NULL != h->th)
-  {
-    GNUNET_CLIENT_notify_transmit_ready_cancel (h->th);
-    h->th = NULL;
+    GNUNET_CONTAINER_DLL_remove (h->ic_head,
+                                 h->ic_tail,
+                                 ic);
+    GNUNET_free (ic);
   }
-  if (NULL != h->client)
+  if (NULL != h->mq)
   {
-    GNUNET_CLIENT_disconnect (h->client);
-    h->client = NULL;
+    GNUNET_MQ_destroy (h->mq);
+    h->mq = NULL;
   }
   if (NULL != h->r_task)
   {
@@ -257,25 +182,6 @@ GNUNET_PEERINFO_disconnect (struct GNUNET_PEERINFO_Handle *h)
 
 
 /**
- * Check if we have a request pending in the transmission queue and are
- * able to transmit it right now.  If so, schedule transmission.
- *
- * @param h handle to the service
- */
-static void
-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 *`
@@ -291,277 +197,79 @@ reconnect_task (void *cls)
 
 
 /**
- * Close the existing connection to PEERINFO and reconnect.
+ * We encountered an error, reconnect to the PEERINFO service.
  *
- * @param h handle to the service
+ * @param h handle to reconnect
  */
 static void
-reconnect (struct GNUNET_PEERINFO_Handle *h)
+do_reconnect (struct GNUNET_PEERINFO_Handle *h)
 {
-  if (NULL != h->r_task)
-  {
-    GNUNET_SCHEDULER_cancel (h->r_task);
-    h->r_task = NULL;
-  }
-  if (NULL != h->th)
-  {
-    GNUNET_CLIENT_notify_transmit_ready_cancel (h->th);
-    h->th = NULL;
-  }
-  if (NULL != h->client)
-  {
-    GNUNET_CLIENT_disconnect (h->client);
-    h->client = NULL;
-  }
-  h->in_receive = GNUNET_NO;
-  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);
-}
-
-
-/**
- * Transmit the request at the head of the transmission queue
- * and trigger continuation (if any).
- *
- * @param cls the `struct GNUNET_PEERINFO_Handle *` (with the queue)
- * @param size size of @a buf (0 on error)
- * @param buf where to copy the message
- * @return number of bytes copied to @a buf
- */
-static size_t
-do_transmit (void *cls,
-             size_t size,
-             void *buf)
-{
-  struct GNUNET_PEERINFO_Handle *h = cls;
-  struct GNUNET_PEERINFO_AddContext *ac = h->ac_head;
-  size_t ret;
+  struct GNUNET_PEERINFO_IteratorContext *ic = h->ic_head;
 
-  h->th = NULL;
-  if (NULL == ac)
-    return 0; /* request was cancelled in the meantime */
-  if (NULL == buf)
+  GNUNET_MQ_destroy (h->mq);
+  h->mq = NULL;
+  if (NULL != ic)
   {
-    /* peerinfo service died */
-    LOG (GNUNET_ERROR_TYPE_DEBUG | GNUNET_ERROR_TYPE_BULK,
-         "Failed to transmit message to `%s' service.\n",
-         "PEERINFO");
-    GNUNET_CONTAINER_DLL_remove (h->ac_head, h->ac_tail, ac);
-    reconnect (h);
-    if (NULL != ac->cont)
-      ac->cont (ac->cont_cls,
-                _("failed to transmit request (service down?)"));
-    GNUNET_free (ac);
-    return 0;
+    GNUNET_CONTAINER_DLL_remove (h->ic_head,
+                                 h->ic_tail,
+                                 ic);
+    if (NULL != ic->callback)
+      ic->callback (ic->callback_cls,
+                    NULL,
+                    NULL,
+                    _("Failed to receive response from `PEERINFO' service."));
+    GNUNET_free (ic);
   }
-  ret = ac->size;
-  if (size < ret)
-  {
-    /* change in head of queue (i.e. cancel + add), try again */
-    trigger_transmit (h);
-    return 0;
-  }
-  LOG (GNUNET_ERROR_TYPE_DEBUG,
-       "Transmitting request of size %u to `%s' service.\n",
-       ret,
-       "PEERINFO");
-  memcpy (buf, &ac[1], ret);
-  GNUNET_CONTAINER_DLL_remove (h->ac_head, h->ac_tail, ac);
-  trigger_transmit (h);
-  if (NULL != ac->cont)
-    ac->cont (ac->cont_cls, NULL);
-  GNUNET_free (ac);
-  return ret;
+  h->r_task = GNUNET_SCHEDULER_add_now (&reconnect_task,
+                                        h);
 }
 
 
 /**
- * Check if we have a request pending in the transmission queue and are
- * able to transmit it right now.  If so, schedule transmission.
+ * We got a disconnect after asking regex to do the announcement.
+ * Retry.
  *
- * @param h handle to the service
+ * @param cls the `struct GNUNET_PEERINFO_Handle` to retry
+ * @param error error code
  */
 static void
-trigger_transmit (struct GNUNET_PEERINFO_Handle *h)
+mq_error_handler (void *cls,
+                  enum GNUNET_MQ_Error error)
 {
-  struct GNUNET_PEERINFO_AddContext *ac;
-
-  if (NULL == (ac = h->ac_head))
-    return; /* no requests queued */
-  if (NULL != h->th)
-    return; /* request already pending */
-  if (NULL == h->client)
-  {
-    /* disconnected, try to reconnect */
-    reconnect (h);
-    return;
-  }
-  h->th =
-    GNUNET_CLIENT_notify_transmit_ready (h->client,
-                                         ac->size,
-                                         GNUNET_TIME_UNIT_FOREVER_REL,
-                                         GNUNET_YES,
-                                         &do_transmit, h);
-}
-
-
-/**
- * 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
- * same peer before the first one was transmitted, PEERINFO may
- * merge the two HELLOs prior to transmission to the service.
- *
- * @param h handle to the peerinfo service
- * @param hello the verified (!) HELLO message
- * @param cont continuation to call when done, NULL is allowed
- * @param cont_cls closure for @a cont
- * @return handle to cancel add operation; all pending
- *         'add' operations will be cancelled automatically
- *        on disconnect, so it is not necessary to keep this
- *        handle (unless @a cont is NULL and at some point
- *        calling @a cont must be prevented)
- */
-struct GNUNET_PEERINFO_AddContext *
-GNUNET_PEERINFO_add_peer (struct GNUNET_PEERINFO_Handle *h,
-                          const struct GNUNET_HELLO_Message *hello,
-                          GNUNET_PEERINFO_Continuation cont,
-                          void *cont_cls)
-{
-  uint16_t hs = GNUNET_HELLO_size (hello);
-  struct GNUNET_PEERINFO_AddContext *ac;
-  struct GNUNET_PeerIdentity peer;
+  struct GNUNET_PEERINFO_Handle *h = cls;
 
-  GNUNET_assert (GNUNET_OK == GNUNET_HELLO_get_id (hello, &peer));
-  LOG (GNUNET_ERROR_TYPE_DEBUG,
-       "Adding peer `%s' to PEERINFO database (%u bytes of HELLO)\n",
-       GNUNET_i2s (&peer),
-       hs);
-  ac = GNUNET_malloc (sizeof (struct GNUNET_PEERINFO_AddContext) + hs);
-  ac->h = h;
-  ac->size = hs;
-  ac->cont = cont;
-  ac->cont_cls = cont_cls;
-  memcpy (&ac[1], hello, hs);
-  GNUNET_CONTAINER_DLL_insert_tail (h->ac_head, h->ac_tail, ac);
-  trigger_transmit (h);
-  return ac;
+  do_reconnect (h);
 }
 
 
-/**
- * Cancel pending 'add' operation.  Must only be called before
- * either 'cont' or #GNUNET_PEERINFO_disconnect() are invoked.
- *
- * @param ac handle for the add operation to cancel
- */
-void
-GNUNET_PEERINFO_add_peer_cancel (struct GNUNET_PEERINFO_AddContext *ac)
-{
-  struct GNUNET_PEERINFO_Handle *h = ac->h;
-
-  GNUNET_CONTAINER_DLL_remove (h->ac_head, h->ac_tail, ac);
-  GNUNET_free (ac);
-}
-
 
 /**
- * Type of a function to call when we receive a message from the
- * service.  Call the iterator with the result and (if applicable)
- * continue to receive more messages or trigger processing the next
- * event (if applicable).
+ * Function called when we receive an info message. Check it is
+ * well-formed.
  *
  * @param cls closure
- * @param msg message received, NULL on timeout or fatal error
+ * @param im message received
+ * @return #GNUNET_OK if the message is OK
  */
-static void
-peerinfo_handler (void *cls,
-                  const struct GNUNET_MessageHeader *msg)
+static int
+check_info (void *cls,
+            const struct InfoMessage *im)
 {
   struct GNUNET_PEERINFO_Handle *h = cls;
   struct GNUNET_PEERINFO_IteratorContext *ic = h->ic_head;
-  const struct InfoMessage *im;
-  const struct GNUNET_HELLO_Message *hello;
-  GNUNET_PEERINFO_Processor cb;
-  struct GNUNET_PeerIdentity id;
-  void *cb_cls;
-  uint16_t ms;
+  uint16_t ms = ntohs (im->header.size) - sizeof (*im);
 
-  h->in_receive = GNUNET_NO;
-  if (NULL == msg)
+  if (0 != ntohl (im->reserved))
   {
-    /* peerinfo service died, signal error */
-    if (NULL != ic)
-    {
-      cb = ic->callback;
-      cb_cls = ic->callback_cls;
-      GNUNET_PEERINFO_iterate_cancel (ic);
-    }
-    else
-    {
-      cb = NULL;
-    }
-    reconnect (h);
-    if (NULL != cb)
-      cb (cb_cls, NULL, NULL,
-          _("Failed to receive response from `PEERINFO' service."));
-    return;
+    GNUNET_break (0);
+    return GNUNET_SYSERR;
   }
   if (NULL == ic)
   {
-    /* didn't expect a response, reconnect */
-    reconnect (h);
-    return;
-  }
-  ic->request_transmitted = GNUNET_NO;
-  cb = ic->callback;
-  cb_cls = ic->callback_cls;
-  if (GNUNET_MESSAGE_TYPE_PEERINFO_INFO_END == ntohs (msg->type))
-  {
-    /* normal end of list of peers, signal end, process next pending request */
-    LOG (GNUNET_ERROR_TYPE_DEBUG,
-         "Received end of list of peers from `%s' service\n",
-         "PEERINFO");
-    GNUNET_PEERINFO_iterate_cancel (ic);
-    trigger_transmit (h);
-    if ( (GNUNET_NO == h->in_receive) &&
-         (NULL != h->ic_head) )
-    {
-      h->in_receive = GNUNET_YES;
-      GNUNET_CLIENT_receive (h->client,
-                             &peerinfo_handler,
-                             h,
-                             GNUNET_TIME_absolute_get_remaining (h->ic_head->timeout));
-    }
-    if (NULL != cb)
-      cb (cb_cls, NULL, NULL, NULL);
-    return;
-  }
-
-  ms = ntohs (msg->size);
-  if ((ms < sizeof (struct InfoMessage)) ||
-      (ntohs (msg->type) != GNUNET_MESSAGE_TYPE_PEERINFO_INFO))
-  {
-    /* malformed message */
+    /* didn't expect a response, bad */
     GNUNET_break (0);
-    GNUNET_PEERINFO_iterate_cancel (ic);
-    reconnect (h);
-    if (NULL != cb)
-      cb (cb_cls, NULL, NULL,
-          _("Received invalid message from `PEERINFO' service."));
-    return;
+    return GNUNET_SYSERR;
   }
-  im = (const struct InfoMessage *) msg;
-  GNUNET_break (0 == ntohl (im->reserved));
   if ( (GNUNET_YES == ic->have_peer) &&
        (0 != memcmp (&ic->peer,
                      &im->peer,
@@ -572,46 +280,28 @@ peerinfo_handler (void *cls,
          "Received HELLO for peer `%s', expected peer `%s'\n",
          GNUNET_i2s (&im->peer),
          GNUNET_i2s (&ic->peer));
-
     GNUNET_break (0);
-    GNUNET_PEERINFO_iterate_cancel (ic);
-    reconnect (h);
-    if (NULL != cb)
-      cb (cb_cls,
-          NULL,
-          NULL,
-          _("Received invalid message from `PEERINFO' service."));
-    return;
+    return GNUNET_SYSERR;
   }
-  hello = NULL;
-  if (ms > sizeof (struct InfoMessage) + sizeof (struct GNUNET_MessageHeader))
+  if (ms > sizeof (struct GNUNET_MessageHeader))
   {
+    const struct GNUNET_HELLO_Message *hello;
+    struct GNUNET_PeerIdentity id;
+
     hello = (const struct GNUNET_HELLO_Message *) &im[1];
-    if (ms != sizeof (struct InfoMessage) + GNUNET_HELLO_size (hello))
+    if (ms != GNUNET_HELLO_size (hello))
     {
       /* malformed message */
       GNUNET_break (0);
-      GNUNET_PEERINFO_iterate_cancel (ic);
-      reconnect (h);
-      if (NULL != cb)
-        cb (cb_cls,
-            NULL,
-            NULL,
-            _("Received invalid message from `PEERINFO' service."));
-      return;
+      return GNUNET_SYSERR;
     }
-    if (GNUNET_OK != GNUNET_HELLO_get_id (hello, &id))
+    if (GNUNET_OK !=
+        GNUNET_HELLO_get_id (hello,
+                             &id))
     {
       /* malformed message */
       GNUNET_break (0);
-      GNUNET_PEERINFO_iterate_cancel (ic);
-      reconnect (h);
-      if (NULL != cb)
-        cb (cb_cls,
-            NULL,
-            NULL,
-            _("Received invalid message from `PEERINFO' service."));
-      return;
+      return GNUNET_SYSERR;
     }
     if (0 != memcmp (&im->peer,
                      &id,
@@ -619,100 +309,166 @@ peerinfo_handler (void *cls,
     {
       /* malformed message */
       GNUNET_break (0);
-      GNUNET_PEERINFO_iterate_cancel (ic);
-      reconnect (h);
-      if (NULL != cb)
-        cb (cb_cls,
-            NULL,
-            NULL,
-            _("Received invalid message from `PEERINFO' service."));
-      return;
+      return GNUNET_SYSERR;
     }
   }
+  else if (0 != ms)
+  {
+    /* malformed message */
+    GNUNET_break (0);
+    return GNUNET_SYSERR;
+  }
+  return GNUNET_OK;
+}
 
-  /* normal data message */
-  LOG (GNUNET_ERROR_TYPE_DEBUG,
-       "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");
-  h->in_receive = GNUNET_YES;
-  GNUNET_CLIENT_receive (h->client,
-                         &peerinfo_handler,
-                         h,
-                         GNUNET_TIME_absolute_get_remaining (ic->timeout));
-  if (NULL != cb)
-    cb (cb_cls,
-        &im->peer,
-        hello,
-        NULL);
+
+/**
+ * Handle info message.
+ *
+ * @param cls closure
+ * @param im message received
+ */
+static void
+handle_info (void *cls,
+             const struct InfoMessage *im)
+{
+  struct GNUNET_PEERINFO_Handle *h = cls;
+  struct GNUNET_PEERINFO_IteratorContext *ic = h->ic_head;
+  const struct GNUNET_HELLO_Message *hello;
+  uint16_t ms;
+
+  ms = ntohs (im->header.size);
+  hello = (0 == ms) ? NULL : (const struct GNUNET_HELLO_Message *) &im[1];
+  if (NULL != ic->callback)
+    ic->callback (ic->callback_cls,
+                  &im->peer,
+                  hello,
+                  NULL);
 }
 
 
 /**
- * We've transmitted the iteration request.  Now get ready to process
- * the results (or handle transmission error).
+ * Send the next IC request at the head of the queue.
  *
- * @param cls the `struct GNUNET_PEERINFO_IteratorContext *`
- * @param emsg error message, NULL if transmission worked
+ * @param h handle
  */
 static void
-iterator_start_receive (void *cls,
-                        const char *emsg)
+send_ic_request (struct GNUNET_PEERINFO_Handle *h)
 {
-  struct GNUNET_PEERINFO_IteratorContext *ic = cls;
-  struct GNUNET_PEERINFO_Handle *h = ic->h;
-  GNUNET_PEERINFO_Processor cb;
-  void *cb_cls;
+  struct GNUNET_PEERINFO_IteratorContext *ic = h->ic_head;
+  struct GNUNET_MQ_Envelope *env;
+  struct ListAllPeersMessage *lapm;
+  struct ListPeerMessage *lpm;
 
-  ic->ac = NULL;
-  if (NULL != emsg)
+  if (NULL == ic)
   {
-    cb = ic->callback;
-    cb_cls = ic->callback_cls;
-    GNUNET_PEERINFO_iterate_cancel (ic);
-    reconnect (h);
-    if (NULL != cb)
-      cb (cb_cls, NULL, NULL, emsg);
+    GNUNET_break (0);
     return;
   }
-  LOG (GNUNET_ERROR_TYPE_DEBUG,
-       "Waiting for response from `%s' service.\n",
-       "PEERINFO");
-  ic->request_transmitted = GNUNET_YES;
-  if (GNUNET_NO == h->in_receive)
+  if (NULL == h->mq)
+  {
+    GNUNET_break (0);
+    return;
+  }
+  if (GNUNET_NO == ic->have_peer)
+  {
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+         "Requesting list of peers from PEERINFO service\n");
+    env = GNUNET_MQ_msg (lapm,
+                         GNUNET_MESSAGE_TYPE_PEERINFO_GET_ALL);
+    lapm->include_friend_only = htonl (ic->include_friend_only);
+  }
+  else
+  {
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+         "Requesting information on peer `%s' from PEERINFO service\n",
+         GNUNET_i2s (&ic->peer));
+    env = GNUNET_MQ_msg (lpm,
+                         GNUNET_MESSAGE_TYPE_PEERINFO_GET);
+    lpm->include_friend_only = htonl (ic->include_friend_only);
+    lpm->peer = ic->peer;
+  }
+  GNUNET_MQ_send (h->mq,
+                  env);
+}
+
+
+/**
+ * Type of a function to call when we receive a message from the
+ * service.  Call the iterator with the result and (if applicable)
+ * continue to receive more messages or trigger processing the next
+ * event (if applicable).
+ *
+ * @param cls closure
+ * @param msg message received, NULL on timeout or fatal error
+ */
+static void
+handle_end_iteration (void *cls,
+                      const struct GNUNET_MessageHeader *msg)
+{
+  struct GNUNET_PEERINFO_Handle *h = cls;
+  struct GNUNET_PEERINFO_IteratorContext *ic = h->ic_head;
+
+  if (NULL == ic)
   {
-    h->in_receive = GNUNET_YES;
-    GNUNET_CLIENT_receive (h->client,
-                           &peerinfo_handler,
-                           h,
-                           GNUNET_TIME_absolute_get_remaining (ic->timeout));
+    /* didn't expect a response, reconnect */
+    GNUNET_break (0);
+    reconnect (h);
+    return;
   }
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Received end of list of peers from PEERINFO service\n");
+  GNUNET_CONTAINER_DLL_remove (h->ic_head,
+                               h->ic_tail,
+                               ic);
+  if (NULL != h->ic_head)
+    send_ic_request (h);
+  if (NULL != ic->callback)
+    ic->callback (ic->callback_cls,
+                  NULL,
+                  NULL,
+                  NULL);
+  GNUNET_free (ic);
 }
 
 
 /**
- * Peerinfo iteration request has timed out.
+ * Close the existing connection to PEERINFO and reconnect.
  *
- * @param cls the `struct GNUNET_PEERINFO_IteratorContext *`
+ * @param h handle to the service
  */
 static void
-signal_timeout (void *cls)
+reconnect (struct GNUNET_PEERINFO_Handle *h)
 {
-  struct GNUNET_PEERINFO_IteratorContext *ic = cls;
-  GNUNET_PEERINFO_Processor cb;
-  void *cb_cls;
-
-  ic->timeout_task = NULL;
-  cb = ic->callback;
-  cb_cls = ic->callback_cls;
-  GNUNET_PEERINFO_iterate_cancel (ic);
-  if (NULL != cb)
-    cb (cb_cls,
-        NULL,
-        NULL,
-        _("Timeout transmitting iteration request to `PEERINFO' service."));
+  GNUNET_MQ_hd_var_size (info,
+                         GNUNET_MESSAGE_TYPE_PEERINFO_INFO,
+                         struct InfoMessage);
+  GNUNET_MQ_hd_fixed_size (end_iteration,
+                           GNUNET_MESSAGE_TYPE_PEERINFO_INFO_END,
+                           struct GNUNET_MessageHeader);
+  struct GNUNET_MQ_MessageHandler handlers[] = {
+    make_info_handler (h),
+    make_end_iteration_handler (h),
+    GNUNET_MQ_handler_end ()
+  };
+
+  if (NULL != h->r_task)
+  {
+    GNUNET_SCHEDULER_cancel (h->r_task);
+    h->r_task = NULL;
+  }
+  if (NULL != h->mq)
+  {
+    GNUNET_MQ_destroy (h->mq);
+    h->mq = NULL;
+  }
+  h->mq = GNUNET_CLIENT_connecT (h->cfg,
+                                 "peerinfo",
+                                 handlers,
+                                 &mq_error_handler,
+                                 h);
+  if (NULL != h->ic_head)
+    send_ic_request (h);
 }
 
 
@@ -728,7 +484,6 @@ signal_timeout (void *cls)
  * @param h handle to the peerinfo service
  * @param include_friend_only include HELLO messages for friends only
  * @param peer restrict iteration to this peer only (can be NULL)
- * @param timeout how long to wait until timing out
  * @param callback the method to call for each peer
  * @param callback_cls closure for @a callback
  * @return iterator context
@@ -737,62 +492,26 @@ struct GNUNET_PEERINFO_IteratorContext *
 GNUNET_PEERINFO_iterate (struct GNUNET_PEERINFO_Handle *h,
                          int include_friend_only,
                          const struct GNUNET_PeerIdentity *peer,
-                         struct GNUNET_TIME_Relative timeout,
                          GNUNET_PEERINFO_Processor callback,
                          void *callback_cls)
 {
-  struct ListAllPeersMessage *lapm;
-  struct ListPeerMessage *lpm;
   struct GNUNET_PEERINFO_IteratorContext *ic;
-  struct GNUNET_PEERINFO_AddContext *ac;
 
   ic = GNUNET_new (struct GNUNET_PEERINFO_IteratorContext);
-  if (NULL == peer)
-  {
-    LOG (GNUNET_ERROR_TYPE_DEBUG,
-         "Requesting list of peers from PEERINFO service\n");
-    ac =
-        GNUNET_malloc (sizeof (struct GNUNET_PEERINFO_AddContext) +
-                       sizeof (struct ListAllPeersMessage));
-    ac->size = sizeof (struct ListAllPeersMessage);
-    lapm = (struct ListAllPeersMessage *) &ac[1];
-    lapm->header.size = htons (sizeof (struct ListAllPeersMessage));
-    lapm->header.type = htons (GNUNET_MESSAGE_TYPE_PEERINFO_GET_ALL);
-    lapm->include_friend_only = htonl (include_friend_only);
-  }
-  else
+  ic->h = h;
+  ic->include_friend_only = include_friend_only;
+  ic->callback = callback;
+  ic->callback_cls = callback_cls;
+  if (NULL != peer)
   {
-    LOG (GNUNET_ERROR_TYPE_DEBUG,
-         "Requesting information on peer `%4s' from PEERINFO service\n",
-         GNUNET_i2s (peer));
-    ac =
-        GNUNET_malloc (sizeof (struct GNUNET_PEERINFO_AddContext) +
-                       sizeof (struct ListPeerMessage));
-    ac->size = sizeof (struct ListPeerMessage);
-    lpm = (struct ListPeerMessage *) &ac[1];
-    lpm->header.size = htons (sizeof (struct ListPeerMessage));
-    lpm->header.type = htons (GNUNET_MESSAGE_TYPE_PEERINFO_GET);
-    lpm->include_friend_only = htonl (include_friend_only);
-    memcpy (&lpm->peer, peer, sizeof (struct GNUNET_PeerIdentity));
     ic->have_peer = GNUNET_YES;
     ic->peer = *peer;
   }
-  ic->h = h;
-  ic->ac = ac;
-  ic->callback = callback;
-  ic->callback_cls = callback_cls;
-  ic->timeout = GNUNET_TIME_relative_to_absolute (timeout);
-  ic->timeout_task =
-      GNUNET_SCHEDULER_add_delayed (timeout, &signal_timeout, ic);
-  ac->cont = &iterator_start_receive;
-  ac->cont_cls = ic;
-  GNUNET_CONTAINER_DLL_insert_tail (h->ac_head,
-                                    h->ac_tail,
-                                    ac);
   GNUNET_CONTAINER_DLL_insert_tail (h->ic_head,
                                     h->ic_tail,
                                     ic);
-  trigger_transmit (h);
+  if (h->ic_head == ic)
+    send_ic_request (h);
   return ic;
 }
 
@@ -805,29 +524,62 @@ GNUNET_PEERINFO_iterate (struct GNUNET_PEERINFO_Handle *h,
 void
 GNUNET_PEERINFO_iterate_cancel (struct GNUNET_PEERINFO_IteratorContext *ic)
 {
-  struct GNUNET_PEERINFO_Handle *h;
+  struct GNUNET_PEERINFO_Handle *h = ic->h;
 
-  h = ic->h;
-  if (NULL != ic->timeout_task)
-  {
-    GNUNET_SCHEDULER_cancel (ic->timeout_task);
-    ic->timeout_task = NULL;
-  }
   ic->callback = NULL;
-  if (GNUNET_YES == ic->request_transmitted)
-    return;                     /* need to finish processing */
+  if (ic == h->ic_head)
+    return;
   GNUNET_CONTAINER_DLL_remove (h->ic_head,
                                h->ic_tail,
                                ic);
-  if (NULL != ic->ac)
-  {
-    GNUNET_CONTAINER_DLL_remove (h->ac_head,
-                                 h->ac_tail,
-                                 ic->ac);
-    GNUNET_free (ic->ac);
-  }
   GNUNET_free (ic);
 }
 
 
+/**
+ * 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
+ * same peer before the first one was transmitted, PEERINFO may
+ * merge the two HELLOs prior to transmission to the service.
+ *
+ * @param h handle to the peerinfo service
+ * @param hello the verified (!) HELLO message
+ * @param cont continuation to call when done, NULL is allowed
+ * @param cont_cls closure for @a cont
+ * @return handle to cancel add operation; all pending
+ *         'add' operations will be cancelled automatically
+ *        on disconnect, so it is not necessary to keep this
+ *        handle (unless @a cont is NULL and at some point
+ *        calling @a cont must be prevented)
+ */
+struct GNUNET_MQ_Envelope *
+GNUNET_PEERINFO_add_peer (struct GNUNET_PEERINFO_Handle *h,
+                          const struct GNUNET_HELLO_Message *hello,
+                          GNUNET_MQ_NotifyCallback cont,
+                          void *cont_cls)
+{
+  struct GNUNET_MQ_Envelope *env;
+  struct GNUNET_PeerIdentity peer;
+
+  if (NULL == h->mq)
+    return NULL;
+  GNUNET_assert (GNUNET_OK ==
+                 GNUNET_HELLO_get_id (hello,
+                                      &peer));
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Adding peer `%s' to PEERINFO database\n",
+       GNUNET_i2s (&peer));
+  env = GNUNET_MQ_msg_copy ((const struct GNUNET_MessageHeader *) hello);
+  if (NULL != cont)
+    GNUNET_MQ_notify_sent (env,
+                           cont,
+                           cont_cls);
+  GNUNET_MQ_send (h->mq,
+                  env);
+  return env;
+}
+
+
 /* end of peerinfo_api.c */
diff --git a/src/peerinfo/test_peerinfo_api.c b/src/peerinfo/test_peerinfo_api.c
index 9fe6bf712..96e73e20a 100644
--- a/src/peerinfo/test_peerinfo_api.c
+++ b/src/peerinfo/test_peerinfo_api.c
@@ -119,8 +119,7 @@ process (void *cls, const struct GNUNET_PeerIdentity *peer,
       retries++;
       add_peer ();
       ic = GNUNET_PEERINFO_iterate (h, GNUNET_NO, NULL,
-                                    GNUNET_TIME_relative_multiply
-                                    (GNUNET_TIME_UNIT_SECONDS, 15), &process,
+                                    &process,
                                     cls);
       return;
     }
@@ -135,7 +134,8 @@ process (void *cls, const struct GNUNET_PeerIdentity *peer,
   {
     GNUNET_assert (3 == global_ret);
     agc = 3;
-    GNUNET_HELLO_iterate_addresses (hello, GNUNET_NO, &check_it, &agc);
+    GNUNET_HELLO_iterate_addresses (hello, GNUNET_NO,
+                                    &check_it, &agc);
     GNUNET_assert (agc == 0);
     global_ret = 2;
   }
@@ -151,8 +151,7 @@ run (void *cls,
   GNUNET_assert (NULL != h);
   add_peer ();
   ic = GNUNET_PEERINFO_iterate (h, GNUNET_NO, &pid,
-                                GNUNET_TIME_relative_multiply
-                                (GNUNET_TIME_UNIT_SECONDS, 15), &process, cls);
+                                &process, cls);
 }
 
 
diff --git a/src/peerinfo/test_peerinfo_api_friend_only.c b/src/peerinfo/test_peerinfo_api_friend_only.c
index 1275e4668..8086d8d43 100644
--- a/src/peerinfo/test_peerinfo_api_friend_only.c
+++ b/src/peerinfo/test_peerinfo_api_friend_only.c
@@ -32,18 +32,23 @@
 #include "gnunet_util_lib.h"
 #include "gnunet_peerinfo_service.h"
 #include "gnunet_testing_lib.h"
-#include "peerinfo.h"
+
 
 static struct GNUNET_PEERINFO_IteratorContext *ic;
 
 static struct GNUNET_PEERINFO_Handle *h;
 
+static struct GNUNET_PeerIdentity pid;
+
 static unsigned int retries;
 
 static int global_ret;
 
+
 static ssize_t
-address_generator (void *cls, size_t max, void *buf)
+address_generator (void *cls,
+                   size_t max,
+                   void *buf)
 {
   size_t *agc = cls;
   ssize_t ret;
@@ -51,19 +56,20 @@ address_generator (void *cls, size_t max, void *buf)
 
   if (0 == *agc)
     return GNUNET_SYSERR; /* Done */
-  memset (&address.peer, 0, sizeof (struct GNUNET_PeerIdentity));
+  memset (&address.peer,
+          0,
+          sizeof (struct GNUNET_PeerIdentity));
   address.address = "Address";
   address.transport_name = "peerinfotest";
   address.address_length = *agc;
-  ret =
-      GNUNET_HELLO_add_address (&address,
-                                GNUNET_TIME_relative_to_absolute
-                                (GNUNET_TIME_UNIT_HOURS), buf, max);
+  ret = GNUNET_HELLO_add_address (&address,
+                                  GNUNET_TIME_relative_to_absolute (GNUNET_TIME_UNIT_HOURS),
+                                  buf,
+                                  max);
   (*agc)--;
   return ret;
 }
 
-struct GNUNET_PeerIdentity pid;
 
 static void
 add_peer ()
@@ -73,24 +79,32 @@ add_peer ()
 
   agc = 2;
   memset (&pid, 32, sizeof (pid));
-  h2 = GNUNET_HELLO_create (&pid.public_key, &address_generator, &agc, GNUNET_YES);
-  GNUNET_PEERINFO_add_peer (h, h2, NULL, NULL);
+  h2 = GNUNET_HELLO_create (&pid.public_key,
+                            &address_generator,
+                            &agc,
+                            GNUNET_YES);
+  GNUNET_PEERINFO_add_peer (h,
+                            h2,
+                            NULL,
+                            NULL);
   GNUNET_free (h2);
 
 }
 
 
 static void
-process (void *cls, const struct GNUNET_PeerIdentity *peer,
-         const struct GNUNET_HELLO_Message *hello, const char *err_msg)
+process (void *cls,
+         const struct GNUNET_PeerIdentity *peer,
+         const struct GNUNET_HELLO_Message *hello,
+         const char *err_msg)
 {
-  if (err_msg != NULL)
+  if (NULL != err_msg)
   {
     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                _("Error in communication with PEERINFO service\n"));
+                "Error in communication with PEERINFO service: %s\n",
+                err_msg);
   }
-
-  if (peer == NULL)
+  if (NULL == peer)
   {
     ic = NULL;
     if ((3 == global_ret) && (retries < 50))
@@ -98,29 +112,26 @@ process (void *cls, const struct GNUNET_PeerIdentity *peer,
       /* try again */
       retries++;
       add_peer ();
-      ic = GNUNET_PEERINFO_iterate (h, GNUNET_NO, NULL,
-                                    GNUNET_TIME_relative_multiply
-                                    (GNUNET_TIME_UNIT_SECONDS, 15), &process,
+      ic = GNUNET_PEERINFO_iterate (h,
+                                    GNUNET_NO,
+                                    NULL,
+                                    &process,
                                     cls);
       return;
     }
     GNUNET_assert (peer == NULL);
-    GNUNET_assert (2 == global_ret);
     GNUNET_PEERINFO_disconnect (h);
     h = NULL;
     global_ret = 0;
     return;
   }
 
-  if (hello == NULL)
-  {
-      GNUNET_assert (3 == global_ret);
-      global_ret = 2;
-  }
-  else
+  if ( (NULL != hello) &&
+       (GNUNET_YES == GNUNET_HELLO_is_friend_only (hello)) )
   {
-                fprintf (stderr, "Received %s HELLO\n",
-                                (GNUNET_YES == GNUNET_HELLO_is_friend_only (hello)) ? "friend only" : "public");
+    fprintf (stderr,
+             "Received friend-only HELLO\n");
+    global_ret = 1;
     GNUNET_PEERINFO_disconnect (h);
     h = NULL;
     return;
@@ -136,14 +147,17 @@ run (void *cls,
   h = GNUNET_PEERINFO_connect (cfg);
   GNUNET_assert (NULL != h);
   add_peer ();
-  ic = GNUNET_PEERINFO_iterate (h, GNUNET_NO, &pid,
-                                GNUNET_TIME_relative_multiply
-                                (GNUNET_TIME_UNIT_SECONDS, 15), &process, cls);
+  ic = GNUNET_PEERINFO_iterate (h,
+                                GNUNET_NO,
+                                &pid,
+                                &process,
+                                NULL);
 }
 
 
 int
-main (int argc, char *argv[])
+main (int argc,
+      char *argv[])
 {
   global_ret = 3;
   if (0 != GNUNET_TESTING_service_run ("test-peerinfo-api-friend-only",
diff --git a/src/peerinfo/test_peerinfo_api_notify_friend_only.c b/src/peerinfo/test_peerinfo_api_notify_friend_only.c
index 403ed4b71..e91610c25 100644
--- a/src/peerinfo/test_peerinfo_api_notify_friend_only.c
+++ b/src/peerinfo/test_peerinfo_api_notify_friend_only.c
@@ -209,22 +209,6 @@ process_wo_fo (void *cls, const struct GNUNET_PeerIdentity *peer,
 
 
 static void
-add_peer_done (void *cls, const char *emsg)
-{
-  if (NULL == emsg)
-  {
-    return;
-  }
-  else
-  {
-    GNUNET_break(0);
-    GNUNET_SCHEDULER_cancel (timeout_task);
-    timeout_task = GNUNET_SCHEDULER_add_now (&end_badly, NULL);
-  }
-}
-
-
-static void
 add_peer ()
 {
   struct GNUNET_HELLO_Message *h2;
@@ -233,10 +217,9 @@ add_peer ()
   agc = 2;
   memset (&pid, 32, sizeof(pid));
   h2 = GNUNET_HELLO_create (&pid.public_key, &address_generator, &agc,
-      GNUNET_YES);
-  GNUNET_PEERINFO_add_peer (h, h2, &add_peer_done, NULL);
+                            GNUNET_YES);
+  GNUNET_PEERINFO_add_peer (h, h2, NULL, NULL);
   GNUNET_free(h2);
-
 }
 
 
diff --git a/src/peerinfo/test_peerinfo_shipped_hellos.c b/src/peerinfo/test_peerinfo_shipped_hellos.c
index 7e3ba09d0..dfaac5da9 100644
--- a/src/peerinfo/test_peerinfo_shipped_hellos.c
+++ b/src/peerinfo/test_peerinfo_shipped_hellos.c
@@ -38,12 +38,13 @@ static struct GNUNET_PEERINFO_Handle *h;
 
 static int global_ret;
 
+
 static int
 addr_cb (void *cls,
          const struct GNUNET_HELLO_Address *address,
          struct GNUNET_TIME_Absolute expiration)
 {
-  int *addr = cls;
+  unsigned int *addr = cls;
 
   (*addr) ++;
   return GNUNET_OK;
@@ -57,28 +58,35 @@ process (void *cls,
          const char *err_msg)
 {
   static unsigned int calls = 0;
-  int addr;
+  unsigned int addr;
 
-  if (err_msg != NULL)
+  if (NULL != err_msg)
   {
     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                _("Error in communication with PEERINFO service\n"));
+                "Error in communication with PEERINFO service: %s\n",
+                err_msg);
   }
   if (NULL != peer)
   {
     addr = 0;
     if (NULL != hello)
     {
-      GNUNET_HELLO_iterate_addresses (hello, GNUNET_NO, &addr_cb, &addr);
+      GNUNET_HELLO_iterate_addresses (hello,
+                                      GNUNET_NO,
+                                      &addr_cb,
+                                      &addr);
       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Got information about peer `%s' with %u addresses \n",
-                  GNUNET_i2s (peer), addr);
+                  "Got information about peer %s with %u addresses\n",
+                  GNUNET_i2s (peer),
+                  addr);
       calls++;
     }
     else
-      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                  "Fail: Got information about peer `%s' without HELLO \n",
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "Got no HELLP for peer %s\n",
                   GNUNET_i2s (peer));
+    }
   }
   else
   {
@@ -87,13 +95,18 @@ process (void *cls,
       fprintf (stderr,
                "Failed: got no callbacks!\n");
       global_ret = 1;
+      GNUNET_PEERINFO_disconnect (h);
+      h = NULL;
     }
     else
-      {
-        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                    "Got %u callbacks\n", calls);
-        global_ret = 0;
-      }
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "Got %u HELLOs in total\n",
+                  calls);
+      global_ret = 0;
+      GNUNET_PEERINFO_disconnect (h);
+      h = NULL;
+    }
   }
 }
 
@@ -105,14 +118,18 @@ run (void *cls,
 {
   h = GNUNET_PEERINFO_connect (cfg);
   GNUNET_assert (NULL != h);
-  ic = GNUNET_PEERINFO_iterate (h, GNUNET_YES, NULL,
-                                GNUNET_TIME_relative_multiply
-                                (GNUNET_TIME_UNIT_SECONDS, 15), &process, cls);
+  ic = GNUNET_PEERINFO_iterate (h,
+                                GNUNET_YES,
+                                NULL,
+                                &process,
+                                cls);
+  GNUNET_assert (NULL != ic);
 }
 
 
 int
-main (int argc, char *argv[])
+main (int argc,
+      char *argv[])
 {
   global_ret = 3;
   if (0 != GNUNET_TESTING_service_run ("test_peerinfo_shipped_hellos",