convert namestore_api to MQ

1 files changed, 548 insertions, 608 deletions

diff --git a/src/namestore/namestore_api.c b/src/namestore/namestore_api.c
index f65c45e85..c0aa79e3f 100644
--- a/src/namestore/namestore_api.c
+++ b/src/namestore/namestore_api.c
@@ -1,6 +1,6 @@
 /*
      This file is part of GNUnet.
-     Copyright (C) 2010-2013 GNUnet e.V.
+     Copyright (C) 2010-2013, 2016 GNUnet e.V.
 
      GNUnet is free software; you can redistribute it and/or modify
      it under the terms of the GNU General Public License as published
@@ -61,7 +61,7 @@ struct GNUNET_NAMESTORE_QueueEntry
   /**
    * Main handle to access the namestore.
    */
-  struct GNUNET_NAMESTORE_Handle *nsh;
+  struct GNUNET_NAMESTORE_Handle *h;
 
   /**
    * Continuation to call
@@ -69,7 +69,7 @@ struct GNUNET_NAMESTORE_QueueEntry
   GNUNET_NAMESTORE_ContinuationWithStatus cont;
 
   /**
-   * Closure for 'cont'.
+   * Closure for @e cont.
    */
   void *cont_cls;
 
@@ -84,6 +84,12 @@ struct GNUNET_NAMESTORE_QueueEntry
   void *proc_cls;
 
   /**
+   * Envelope of the message to send to the service, if not yet
+   * sent.
+   */
+  struct GNUNET_MQ_Envelope *env;
+
+  /**
    * The operation id this zone iteration operation has
    */
   uint32_t op_id;
@@ -120,7 +126,13 @@ struct GNUNET_NAMESTORE_ZoneIterator
   /**
    * Closure for @e proc.
    */
-  void* proc_cls;
+  void *proc_cls;
+
+  /**
+   * Envelope of the message to send to the service, if not yet
+   * sent.
+   */
+  struct GNUNET_MQ_Envelope *env;
 
   /**
    * Private key of the zone.
@@ -136,31 +148,6 @@ struct GNUNET_NAMESTORE_ZoneIterator
 
 
 /**
- * Message in linked list we should send to the service.  The
- * actual binary message follows this struct.
- */
-struct PendingMessage
-{
-
-  /**
-   * Kept in a DLL.
-   */
-  struct PendingMessage *next;
-
-  /**
-   * Kept in a DLL.
-   */
-  struct PendingMessage *prev;
-
-  /**
-   * Size of the message.
-   */
-  size_t size;
-
-};
-
-
-/**
  * Connection to the NAMESTORE service.
  */
 struct GNUNET_NAMESTORE_Handle
@@ -172,24 +159,9 @@ struct GNUNET_NAMESTORE_Handle
   const struct GNUNET_CONFIGURATION_Handle *cfg;
 
   /**
-   * Socket (if available).
+   * Connection to the service (if available).
    */
-  struct GNUNET_CLIENT_Connection *client;
-
-  /**
-   * Currently pending transmission request (or NULL).
-   */
-  struct GNUNET_CLIENT_TransmitHandle *th;
-
-  /**
-   * Head of linked list of pending messages to send to the service
-   */
-  struct PendingMessage *pending_head;
-
-  /**
-   * Tail of linked list of pending messages to send to the service
-   */
-  struct PendingMessage *pending_tail;
+  struct GNUNET_MQ_Handle *mq;
 
   /**
    * Head of pending namestore queue entries
@@ -214,7 +186,7 @@ struct GNUNET_NAMESTORE_Handle
   /**
    * Reconnect task
    */
-  struct GNUNET_SCHEDULER_Task * reconnect_task;
+  struct GNUNET_SCHEDULER_Task *reconnect_task;
 
   /**
    * Delay introduced before we reconnect.
@@ -227,11 +199,6 @@ struct GNUNET_NAMESTORE_Handle
   int reconnect;
 
   /**
-   * Did we start to receive yet?
-   */
-  int is_receiving;
-
-  /**
    * The last operation id used for a NAMESTORE operation
    */
   uint32_t last_op_id_used;
@@ -249,51 +216,129 @@ force_reconnect (struct GNUNET_NAMESTORE_Handle *h);
 
 
 /**
+ * Find the queue entry that matches the @a rid
+ *
+ * @param h namestore handle
+ * @param rid id to look up
+ * @return NULL if @a rid was not found
+ */
+static struct GNUNET_NAMESTORE_QueueEntry *
+find_qe (struct GNUNET_NAMESTORE_Handle *h,
+         uint32_t rid)
+{
+  struct GNUNET_NAMESTORE_QueueEntry *qe;
+
+  for (qe = h->op_head; qe != NULL; qe = qe->next)
+    if (qe->op_id == rid)
+      return qe;
+  return NULL;
+}
+
+
+/**
+ * Find the zone iteration entry that matches the @a rid
+ *
+ * @param h namestore handle
+ * @param rid id to look up
+ * @return NULL if @a rid was not found
+ */
+static struct GNUNET_NAMESTORE_ZoneIterator *
+find_zi (struct GNUNET_NAMESTORE_Handle *h,
+         uint32_t rid)
+{
+  struct GNUNET_NAMESTORE_ZoneIterator *ze;
+
+  for (ze = h->z_head; ze != NULL; ze = ze->next)
+    if (ze->op_id == rid)
+      return ze;
+  return NULL;
+}
+
+
+/**
+ * Free @a qe.
+ *
+ * @param qe entry to free
+ */
+static void
+free_qe (struct GNUNET_NAMESTORE_QueueEntry *qe)
+{
+  struct GNUNET_NAMESTORE_Handle *h = qe->h;
+
+  GNUNET_CONTAINER_DLL_remove (h->op_head,
+                               h->op_tail,
+                               qe);
+  if (NULL != qe->env)
+    GNUNET_MQ_discard (qe->env);
+  GNUNET_free (qe);
+}
+
+
+/**
+ * Free @a ze.
+ *
+ * @param ze entry to free
+ */
+static void
+free_ze (struct GNUNET_NAMESTORE_ZoneIterator *ze)
+{
+  struct GNUNET_NAMESTORE_Handle *h = ze->h;
+
+  GNUNET_CONTAINER_DLL_remove (h->z_head,
+                               h->z_tail,
+                               ze);
+  if (NULL != ze->env)
+    GNUNET_MQ_discard (ze->env);
+  GNUNET_free (ze);
+}
+
+
+/**
  * Handle an incoming message of type
  * #GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_STORE_RESPONSE
  *
- * @param qe the respective entry in the message queue
+ * @param cls
  * @param msg the message we received
- * @param size the message size
- * @return #GNUNET_OK on success, #GNUNET_SYSERR on error and we did NOT notify the client
  */
-static int
-handle_record_store_response (struct GNUNET_NAMESTORE_QueueEntry *qe,
-                              const struct RecordStoreResponseMessage* msg,
-                              size_t size)
+static void
+handle_record_store_response (void *cls,
+                              const struct RecordStoreResponseMessage *msg)
 {
+  struct GNUNET_NAMESTORE_Handle *h = cls;
+  struct GNUNET_NAMESTORE_QueueEntry *qe;
   int res;
   const char *emsg;
 
+  qe = find_qe (h,
+                ntohl (msg->gns_header.r_id));
+  res = ntohl (msg->op_result);
   LOG (GNUNET_ERROR_TYPE_DEBUG,
-       "Received `%s' with result %i\n",
-       "RECORD_STORE_RESPONSE",
-       ntohl (msg->op_result));
+       "Received RECORD_STORE_RESPONSE with result %d\n",
+       res);
   /* TODO: add actual error message from namestore to response... */
-  res = ntohl (msg->op_result);
   if (GNUNET_SYSERR == res)
     emsg = _("Namestore failed to store record\n");
   else
     emsg = NULL;
   if (NULL != qe->cont)
-    qe->cont (qe->cont_cls, res, emsg);
-  return GNUNET_OK;
+    qe->cont (qe->cont_cls,
+              res,
+              emsg);
+  free_qe (qe);
 }
 
 
 /**
- * Handle an incoming message of type
+ * Check validity of an incoming message of type
  * #GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_LOOKUP_RESPONSE
  *
- * @param qe the respective entry in the message queue
+ * @param cls
  * @param msg the message we received
- * @param size the message size
- * @return #GNUNET_OK on success, #GNUNET_SYSERR on error and we did NOT notify the client
+ * @return #GNUNET_OK on success, #GNUNET_SYSERR on error
  */
 static int
-handle_lookup_result (struct GNUNET_NAMESTORE_QueueEntry *qe,
-                      const struct LabelLookupResponseMessage *msg,
-                      size_t size)
+check_lookup_result (void *cls,
+                     const struct LabelLookupResponseMessage *msg)
 {
   const char *name;
   const char *rd_tmp;
@@ -302,18 +347,12 @@ handle_lookup_result (struct GNUNET_NAMESTORE_QueueEntry *qe,
   size_t name_len;
   size_t rd_len;
   unsigned int rd_count;
-  int found;
-
-  LOG (GNUNET_ERROR_TYPE_DEBUG,
-       "Received `%s'\n",
-       "RECORD_LOOKUP_RESULT");
 
   rd_len = ntohs (msg->rd_len);
   rd_count = ntohs (msg->rd_count);
   msg_len = ntohs (msg->gns_header.header.size);
   name_len = ntohs (msg->name_len);
-  found = ntohs (msg->found);
-  exp_msg_len = sizeof (struct LabelLookupResponseMessage) + name_len + rd_len;
+  exp_msg_len = sizeof (*msg) + name_len + rd_len;
   if (msg_len != exp_msg_len)
   {
     GNUNET_break (0);
@@ -326,26 +365,84 @@ handle_lookup_result (struct GNUNET_NAMESTORE_QueueEntry *qe,
     GNUNET_break (0);
     return GNUNET_SYSERR;
   }
-  if (GNUNET_NO == found)
+  if (GNUNET_NO == ntohs (msg->found))
+  {
+    if (0 != rd_count)
+    {
+      GNUNET_break (0);
+      return GNUNET_SYSERR;
+    }
+    return GNUNET_OK;
+  }
+  rd_tmp = &name[name_len];
+  {
+    struct GNUNET_GNSRECORD_Data rd[rd_count];
+
+    if (GNUNET_OK !=
+        GNUNET_GNSRECORD_records_deserialize (rd_len,
+                                              rd_tmp,
+                                              rd_count,
+                                              rd))
+    {
+      GNUNET_break (0);
+      return GNUNET_SYSERR;
+    }
+  }
+  return GNUNET_OK;
+}
+
+
+/**
+ * Handle an incoming message of type
+ * #GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_LOOKUP_RESPONSE
+ *
+ * @param cls
+ * @param msg the message we received
+ */
+static void
+handle_lookup_result (void *cls,
+                      const struct LabelLookupResponseMessage *msg)
+{
+  struct GNUNET_NAMESTORE_Handle *h = cls;
+  struct GNUNET_NAMESTORE_QueueEntry *qe;
+  const char *name;
+  const char *rd_tmp;
+  size_t name_len;
+  size_t rd_len;
+  unsigned int rd_count;
+
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Received RECORD_LOOKUP_RESULT\n");
+  qe = find_qe (h,
+                ntohl (msg->gns_header.r_id));
+  if (NULL == qe)
+    return;
+  rd_len = ntohs (msg->rd_len);
+  rd_count = ntohs (msg->rd_count);
+  name_len = ntohs (msg->name_len);
+  name = (const char *) &msg[1];
+  if (GNUNET_NO == ntohs (msg->found))
   {
     /* label was not in namestore */
     if (NULL != qe->proc)
       qe->proc (qe->proc_cls,
                 &msg->private_key,
                 name,
-                0, NULL);
-    return GNUNET_OK;
+                0,
+                NULL);
+    free_qe (qe);
+    return;
   }
 
   rd_tmp = &name[name_len];
   {
     struct GNUNET_GNSRECORD_Data rd[rd_count];
 
-    if (GNUNET_OK != GNUNET_GNSRECORD_records_deserialize(rd_len, rd_tmp, rd_count, rd))
-    {
-      GNUNET_break (0);
-      return GNUNET_SYSERR;
-    }
+    GNUNET_assert (GNUNET_OK ==
+                   GNUNET_GNSRECORD_records_deserialize (rd_len,
+                                                         rd_tmp,
+                                                         rd_count,
+                                                         rd));
     if (0 == name_len)
       name = NULL;
     if (NULL != qe->proc)
@@ -355,7 +452,7 @@ handle_lookup_result (struct GNUNET_NAMESTORE_QueueEntry *qe,
                 rd_count,
                 (rd_count > 0) ? rd : NULL);
   }
-  return GNUNET_OK;
+  free_qe (qe);
 }
 
 
@@ -363,15 +460,13 @@ handle_lookup_result (struct GNUNET_NAMESTORE_QueueEntry *qe,
  * Handle an incoming message of type
  * #GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_RESULT
  *
- * @param qe the respective entry in the message queue
+ * @param cls
  * @param msg the message we received
- * @param size the message size
- * @return #GNUNET_OK on success, #GNUNET_SYSERR on error and we did NOT notify the client
+ * @return #GNUNET_OK on success, #GNUNET_SYSERR on error
  */
 static int
-handle_record_result (struct GNUNET_NAMESTORE_QueueEntry *qe,
-                      const struct RecordResultMessage *msg,
-                      size_t size)
+check_record_result (void *cls,
+                     const struct RecordResultMessage *msg)
 {
   const char *name;
   const char *rd_tmp;
@@ -381,14 +476,15 @@ handle_record_result (struct GNUNET_NAMESTORE_QueueEntry *qe,
   size_t rd_len;
   unsigned int rd_count;
 
-  LOG (GNUNET_ERROR_TYPE_DEBUG,
-       "Received `%s'\n",
-       "RECORD_RESULT");
   rd_len = ntohs (msg->rd_len);
   rd_count = ntohs (msg->rd_count);
   msg_len = ntohs (msg->gns_header.header.size);
   name_len = ntohs (msg->name_len);
-  GNUNET_break (0 == ntohs (msg->reserved));
+  if (0 != ntohs (msg->reserved))
+  {
+    GNUNET_break (0);
+    return GNUNET_SYSERR;
+  }
   exp_msg_len = sizeof (struct RecordResultMessage) + name_len + rd_len;
   if (msg_len != exp_msg_len)
   {
@@ -406,19 +502,15 @@ handle_record_result (struct GNUNET_NAMESTORE_QueueEntry *qe,
   {
     struct GNUNET_GNSRECORD_Data rd[rd_count];
 
-    if (GNUNET_OK != GNUNET_GNSRECORD_records_deserialize(rd_len, rd_tmp, rd_count, rd))
+    if (GNUNET_OK !=
+        GNUNET_GNSRECORD_records_deserialize(rd_len,
+                                             rd_tmp,
+                                             rd_count,
+                                             rd))
     {
       GNUNET_break (0);
       return GNUNET_SYSERR;
     }
-    if (0 == name_len)
-      name = NULL;
-    if (NULL != qe->proc)
-      qe->proc (qe->proc_cls,
-                &msg->private_key,
-                name,
-                rd_count,
-                (rd_count > 0) ? rd : NULL);
   }
   return GNUNET_OK;
 }
@@ -426,424 +518,240 @@ handle_record_result (struct GNUNET_NAMESTORE_QueueEntry *qe,
 
 /**
  * Handle an incoming message of type
- * #GNUNET_MESSAGE_TYPE_NAMESTORE_ZONE_TO_NAME_RESPONSE.
+ * #GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_RESULT
  *
- * @param qe the respective entry in the message queue
+ * @param cls
  * @param msg the message we received
- * @param size the message size
- * @return #GNUNET_OK on success, #GNUNET_NO if we notified the client about
- *         the error, #GNUNET_SYSERR on error and we did NOT notify the client
  */
-static int
-handle_zone_to_name_response (struct GNUNET_NAMESTORE_QueueEntry *qe,
-                              const struct ZoneToNameResponseMessage *msg,
-                              size_t size)
+static void
+handle_record_result (void *cls,
+                      const struct RecordResultMessage *msg)
 {
-  int res;
+  static struct GNUNET_CRYPTO_EcdsaPrivateKey priv_dummy;
+  struct GNUNET_NAMESTORE_Handle *h = cls;
+  struct GNUNET_NAMESTORE_QueueEntry *qe;
+  struct GNUNET_NAMESTORE_ZoneIterator *ze;
+  const char *name;
+  const char *rd_tmp;
   size_t name_len;
-  size_t rd_ser_len;
+  size_t rd_len;
   unsigned int rd_count;
-  const char *name_tmp;
-  const char *rd_tmp;
 
   LOG (GNUNET_ERROR_TYPE_DEBUG,
-       "Received `%s'\n",
-       "ZONE_TO_NAME_RESPONSE");
-  res = ntohs (msg->res);
-  switch (res)
+       "Received RECORD_RESULT\n");
+  rd_len = ntohs (msg->rd_len);
+  rd_count = ntohs (msg->rd_count);
+  name_len = ntohs (msg->name_len);
+  ze = find_zi (h,
+                ntohl (msg->gns_header.r_id));
+  qe = find_qe (h,
+                ntohl (msg->gns_header.r_id));
+  if ( (NULL == ze) && (NULL == qe) )
+    return; /* rid not found */
+  if ( (NULL != ze) && (NULL != qe) )
+  {
+    GNUNET_break (0);   /* rid ambigous */
+    force_reconnect (h);
+    return;
+  }
+  if ( (0 == name_len) &&
+       (0 == (memcmp (&msg->private_key,
+                      &priv_dummy,
+                      sizeof (priv_dummy)))) )
   {
-  case GNUNET_SYSERR:
-    LOG (GNUNET_ERROR_TYPE_DEBUG,
-         "An error occured during zone to name operation\n");
-    break;
-  case GNUNET_NO:
-    LOG (GNUNET_ERROR_TYPE_DEBUG,
-         "Namestore has no result for zone to name mapping \n");
-    if (NULL != qe->proc)
-      qe->proc (qe->proc_cls, &msg->zone, NULL, 0, NULL);
-    return GNUNET_NO;
-  case GNUNET_YES:
     LOG (GNUNET_ERROR_TYPE_DEBUG,
-         "Namestore has result for zone to name mapping \n");
-    name_len = ntohs (msg->name_len);
-    rd_count = ntohs (msg->rd_count);
-    rd_ser_len = ntohs (msg->rd_len);
-    name_tmp = (const char *) &msg[1];
-    if ( (name_len > 0) &&
-         ('\0' != name_tmp[name_len -1]) )
+         "Zone iteration completed!\n");
+    if (NULL == ze)
     {
       GNUNET_break (0);
-      return GNUNET_SYSERR;
-    }
-    rd_tmp = &name_tmp[name_len];
-    {
-      struct GNUNET_GNSRECORD_Data rd[rd_count];
-
-      if (GNUNET_OK != GNUNET_GNSRECORD_records_deserialize(rd_ser_len, rd_tmp, rd_count, rd))
-      {
-        GNUNET_break (0);
-        return GNUNET_SYSERR;
-      }
-      /* normal end, call continuation with result */
-      if (NULL != qe->proc)
-        qe->proc (qe->proc_cls,
-                  &msg->zone,
-                  name_tmp,
-                  rd_count, rd);
-      /* return is important here: break would call continuation with error! */
-      return GNUNET_OK;
+      force_reconnect (h);
+      return;
     }
-  default:
-    GNUNET_break (0);
-    return GNUNET_SYSERR;
+    if (NULL != ze->proc)
+      ze->proc (ze->proc_cls, NULL, NULL, 0, NULL);
+    free_ze (ze);
+    return;
   }
-  /* error case, call continuation with error */
-  if (NULL != qe->proc)
-    qe->proc (qe->proc_cls, NULL, NULL, 0, NULL);
-  return GNUNET_NO;
-}
 
-
-/**
- * Handle incoming messages for record operations
- *
- * @param qe the respective zone iteration handle
- * @param msg the message we received
- * @param type the message type in host byte order
- * @param size the message size
- * @return #GNUNET_OK on success, #GNUNET_NO if we notified the client about
- *         the error, #GNUNET_SYSERR on error and we did NOT notify the client
- */
-static int
-manage_record_operations (struct GNUNET_NAMESTORE_QueueEntry *qe,
-                          const struct GNUNET_MessageHeader *msg,
-                          uint16_t type,
-                          size_t size)
-{
-  /* handle different message type */
-  switch (type)
+  name = (const char *) &msg[1];
+  rd_tmp = &name[name_len];
   {
-  case GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_STORE_RESPONSE:
-    if (size != sizeof (struct RecordStoreResponseMessage))
-    {
-      GNUNET_break (0);
-      return GNUNET_SYSERR;
-    }
-    return handle_record_store_response (qe, (const struct RecordStoreResponseMessage *) msg, size);
-  case GNUNET_MESSAGE_TYPE_NAMESTORE_ZONE_TO_NAME_RESPONSE:
-    if (size < sizeof (struct ZoneToNameResponseMessage))
-    {
-      GNUNET_break (0);
-      return GNUNET_SYSERR;
-    }
-    return handle_zone_to_name_response (qe, (const struct ZoneToNameResponseMessage *) msg, size);
-  case GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_RESULT:
-    if (size < sizeof (struct RecordResultMessage))
+    struct GNUNET_GNSRECORD_Data rd[rd_count];
+
+    GNUNET_assert (GNUNET_OK ==
+                   GNUNET_GNSRECORD_records_deserialize(rd_len,
+                                                        rd_tmp,
+                                                        rd_count,
+                                                        rd));
+    if (0 == name_len)
+      name = NULL;
+    if (NULL != qe)
     {
-      GNUNET_break (0);
-      return GNUNET_SYSERR;
+      if (NULL != qe->proc)
+        qe->proc (qe->proc_cls,
+                  &msg->private_key,
+                  name,
+                  rd_count,
+                  (rd_count > 0) ? rd : NULL);
+      free_qe (qe);
+      return;
     }
-    return handle_record_result (qe, (const struct RecordResultMessage *) msg, size);
-  case GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_LOOKUP_RESPONSE:
-    if (size < sizeof (struct LabelLookupResponseMessage))
+    if (NULL != ze)
     {
-      GNUNET_break (0);
-      return GNUNET_SYSERR;
+      if (NULL != ze->proc)
+        ze->proc (ze->proc_cls,
+                  &msg->private_key,
+                  name,
+                  rd_count,
+                  rd);
+      return;
     }
-    return handle_lookup_result (qe, (const struct LabelLookupResponseMessage *) msg, size);
-  default:
-    GNUNET_break (0);
-    return GNUNET_SYSERR;
   }
+  GNUNET_assert (0);
 }
 
 
 /**
- * Handle a response from NAMESTORE service for a zone iteration request
+ * Handle an incoming message of type
+ * #GNUNET_MESSAGE_TYPE_NAMESTORE_ZONE_TO_NAME_RESPONSE.
  *
- * @param ze the respective iterator for this operation
- * @param msg the message containing the respoonse
- * @param size the message size
- * @return #GNUNET_YES on success, @a ze should be kept, #GNUNET_NO on success if @a ze should
- *         not be kept any longer, #GNUNET_SYSERR on error (disconnect) and @a ze should be kept
+ * @param qe the respective entry in the message queue
+ * @param msg the message we received
+ * @return #GNUNET_OK on success, #GNUNET_SYSERR if message malformed
  */
 static int
-handle_zone_iteration_response (struct GNUNET_NAMESTORE_ZoneIterator *ze,
-                                const struct RecordResultMessage *msg,
-                                size_t size)
+check_zone_to_name_response (void *cls,
+                             const struct ZoneToNameResponseMessage *msg)
 {
-  static struct GNUNET_CRYPTO_EcdsaPrivateKey priv_dummy;
-  size_t msg_len;
-  size_t exp_msg_len;
   size_t name_len;
-  size_t rd_len;
-  unsigned rd_count;
+  size_t rd_ser_len;
+  unsigned int rd_count;
   const char *name_tmp;
-  const char *rd_ser_tmp;
+  const char *rd_tmp;
+
+  if (GNUNET_OK != ntohs (msg->res))
+    return GNUNET_OK;
 
-  LOG (GNUNET_ERROR_TYPE_DEBUG,
-       "Received `%s'\n",
-       "ZONE_ITERATION_RESPONSE");
-  msg_len = ntohs (msg->gns_header.header.size);
-  rd_len = ntohs (msg->rd_len);
-  rd_count = ntohs (msg->rd_count);
   name_len = ntohs (msg->name_len);
-  exp_msg_len = sizeof (struct RecordResultMessage) + name_len + rd_len;
-  if (msg_len != exp_msg_len)
-  {
-    GNUNET_break (0);
-    return GNUNET_SYSERR;
-  }
-  if ( (0 == name_len) &&
-       (0 == (memcmp (&msg->private_key,
-                      &priv_dummy,
-                      sizeof (priv_dummy)))) )
-  {
-    LOG (GNUNET_ERROR_TYPE_DEBUG,
-         "Zone iteration completed!\n");
-    if (NULL != ze->proc)
-      ze->proc (ze->proc_cls, NULL, NULL, 0, NULL);
-    return GNUNET_NO;
-  }
+  rd_count = ntohs (msg->rd_count);
+  rd_ser_len = ntohs (msg->rd_len);
   name_tmp = (const char *) &msg[1];
-  if ((name_tmp[name_len -1] != '\0') || (name_len > MAX_NAME_LEN))
+  if ( (name_len > 0) &&
+       ('\0' != name_tmp[name_len -1]) )
   {
     GNUNET_break (0);
     return GNUNET_SYSERR;
   }
-  rd_ser_tmp = (const char *) &name_tmp[name_len];
+  rd_tmp = &name_tmp[name_len];
   {
     struct GNUNET_GNSRECORD_Data rd[rd_count];
 
-    if (GNUNET_OK != GNUNET_GNSRECORD_records_deserialize (rd_len,
-                                                           rd_ser_tmp,
-                                                           rd_count,
-                                                           rd))
+    if (GNUNET_OK !=
+        GNUNET_GNSRECORD_records_deserialize (rd_ser_len,
+                                              rd_tmp,
+                                              rd_count,
+                                              rd))
     {
       GNUNET_break (0);
       return GNUNET_SYSERR;
     }
-    if (NULL != ze->proc)
-      ze->proc (ze->proc_cls,
-                &msg->private_key,
-                name_tmp,
-                rd_count, rd);
-    return GNUNET_YES;
   }
+  return GNUNET_OK;
 }
 
 
 /**
- * Handle incoming messages for zone iterations
+ * Handle an incoming message of type
+ * #GNUNET_MESSAGE_TYPE_NAMESTORE_ZONE_TO_NAME_RESPONSE.
  *
- * @param ze the respective zone iteration handle
+ * @param cls
  * @param msg the message we received
- * @param type the message type in HBO
- * @param size the message size
- * @return #GNUNET_YES on success, @a ze should be kept, #GNUNET_NO on success if @a ze should
- *         not be kept any longer, #GNUNET_SYSERR on error (disconnect) and @a ze should be kept
- */
-static int
-manage_zone_operations (struct GNUNET_NAMESTORE_ZoneIterator *ze,
-                        const struct GNUNET_MessageHeader *msg,
-                        int type, size_t size)
-{
-  /* handle different message type */
-  switch (type)
-  {
-  case GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_RESULT:
-    if (size < sizeof (struct RecordResultMessage))
-    {
-      GNUNET_break (0);
-      return GNUNET_SYSERR;
-    }
-    return handle_zone_iteration_response (ze,
-                                           (const struct RecordResultMessage *) msg,
-                                           size);
-  default:
-    GNUNET_break (0);
-    return GNUNET_SYSERR;
-  }
-}
-
-
-/**
- * Type of a function to call when we receive a message
- * from the service.
- *
- * @param cls the `struct GNUNET_NAMESTORE_SchedulingHandle`
- * @param msg message received, NULL on timeout or fatal error
  */
 static void
-process_namestore_message (void *cls,
-                           const struct GNUNET_MessageHeader *msg)
+handle_zone_to_name_response (void *cls,
+                              const struct ZoneToNameResponseMessage *msg)
 {
   struct GNUNET_NAMESTORE_Handle *h = cls;
-  const struct GNUNET_NAMESTORE_Header *gm;
   struct GNUNET_NAMESTORE_QueueEntry *qe;
-  struct GNUNET_NAMESTORE_ZoneIterator *ze;
-  uint16_t size;
-  uint16_t type;
-  uint32_t r_id;
-  int ret;
-
-  if (NULL == msg)
-  {
-    force_reconnect (h);
-    return;
-  }
-  size = ntohs (msg->size);
-  type = ntohs (msg->type);
-  if (size < sizeof (struct GNUNET_NAMESTORE_Header))
-  {
-    GNUNET_break_op (0);
-    GNUNET_CLIENT_receive (h->client,
-                           &process_namestore_message, h,
-                           GNUNET_TIME_UNIT_FOREVER_REL);
-    return;
-  }
-  gm = (const struct GNUNET_NAMESTORE_Header *) msg;
-  r_id = ntohl (gm->r_id);
+  int res;
+  size_t name_len;
+  size_t rd_ser_len;
+  unsigned int rd_count;
+  const char *name_tmp;
+  const char *rd_tmp;
 
   LOG (GNUNET_ERROR_TYPE_DEBUG,
-       "Received message type %u size %u op %u\n",
-       (unsigned int) type,
-       (unsigned int) size,
-       (unsigned int) r_id);
-
-  /* Is it a record related operation ? */
-  for (qe = h->op_head; qe != NULL; qe = qe->next)
-    if (qe->op_id == r_id)
-      break;
-  if (NULL != qe)
-  {
-    ret = manage_record_operations (qe, msg, type, size);
-    if (GNUNET_SYSERR == ret)
-    {
-      /* protocol error, need to reconnect */
-      h->reconnect = GNUNET_YES;
-    }
-    else
-    {
-      /* client was notified about success or failure, clean up 'qe' */
-      GNUNET_CONTAINER_DLL_remove (h->op_head,
-                                   h->op_tail,
-                                   qe);
-      GNUNET_free (qe);
-    }
-  }
-  /* Is it a zone iteration operation? */
-  for (ze = h->z_head; ze != NULL; ze = ze->next)
-    if (ze->op_id == r_id)
-      break;
-  if (NULL != ze)
+       "Received ZONE_TO_NAME_RESPONSE\n");
+  qe = find_qe (h,
+                ntohl (msg->gns_header.r_id));
+  res = ntohs (msg->res);
+  switch (res)
   {
-    ret = manage_zone_operations (ze, msg, type, size);
-    if (GNUNET_NO == ret)
-    {
-      /* end of iteration, clean up 'ze' */
-      GNUNET_CONTAINER_DLL_remove (h->z_head,
-                                   h->z_tail,
-                                   ze);
-      GNUNET_free (ze);
-    }
-    if (GNUNET_SYSERR == ret)
+  case GNUNET_SYSERR:
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+         "An error occured during zone to name operation\n");
+    break;
+  case GNUNET_NO:
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+         "Namestore has no result for zone to name mapping \n");
+    if (NULL != qe->proc)
+      qe->proc (qe->proc_cls, &msg->zone, NULL, 0, NULL);
+    free_qe (qe);
+    return;
+  case GNUNET_YES:
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+         "Namestore has result for zone to name mapping \n");
+    name_len = ntohs (msg->name_len);
+    rd_count = ntohs (msg->rd_count);
+    rd_ser_len = ntohs (msg->rd_len);
+    name_tmp = (const char *) &msg[1];
+    rd_tmp = &name_tmp[name_len];
     {
-      /* protocol error, need to reconnect */
-      h->reconnect = GNUNET_YES;
+      struct GNUNET_GNSRECORD_Data rd[rd_count];
+
+      GNUNET_assert (GNUNET_OK ==
+                     GNUNET_GNSRECORD_records_deserialize (rd_ser_len,
+                                                           rd_tmp,
+                                                           rd_count,
+                                                           rd));
+      /* normal end, call continuation with result */
+      if (NULL != qe->proc)
+        qe->proc (qe->proc_cls,
+                  &msg->zone,
+                  name_tmp,
+                  rd_count, rd);
+      /* return is important here: break would call continuation with error! */
+      free_qe (qe);
+      return;
     }
-  }
-  if (GNUNET_YES == h->reconnect)
-  {
+  default:
+    GNUNET_break (0);
     force_reconnect (h);
     return;
   }
-  GNUNET_CLIENT_receive (h->client, &process_namestore_message, h,
-                         GNUNET_TIME_UNIT_FOREVER_REL);
+  /* error case, call continuation with error */
+  if (NULL != qe->proc)
+    qe->proc (qe->proc_cls, NULL, NULL, 0, NULL);
+  free_qe (qe);
 }
 
 
-/**
- * Transmit messages from the message queue to the service
- * (if there are any, and if we are not already trying).
- *
- * @param h handle to use
- */
-static void
-do_transmit (struct GNUNET_NAMESTORE_Handle *h);
-
 
 /**
- * We can now transmit a message to NAMESTORE. Do it.
+ * Generic error handler, called with the appropriate error code and
+ * the same closure specified at the creation of the message queue.
+ * Not every message queue implementation supports an error handler.
  *
- * @param cls the `struct GNUNET_NAMESTORE_Handle`
- * @param size number of bytes we can transmit
- * @param buf where to copy the messages
- * @return number of bytes copied into @a buf
+ * @param cls closure with the `struct GNUNET_NAMESTORE_Handle *`
+ * @param error error code
  */
-static size_t
-transmit_message_to_namestore (void *cls,
-                               size_t size,
-                               void *buf)
+static void
+mq_error_handler (void *cls,
+                  enum GNUNET_MQ_Error error)
 {
   struct GNUNET_NAMESTORE_Handle *h = cls;
-  struct PendingMessage *p;
-  size_t ret;
-  char *cbuf;
 
-  h->th = NULL;
-  if ((0 == size) || (NULL == buf))
-  {
-    force_reconnect (h);
-    return 0;
-  }
-  ret = 0;
-  cbuf = buf;
-  while ( (NULL != (p = h->pending_head)) &&
-          (p->size <= size) )
-  {
-    memcpy (&cbuf[ret], &p[1], p->size);
-    ret += p->size;
-    size -= p->size;
-    GNUNET_CONTAINER_DLL_remove (h->pending_head,
-                                 h->pending_tail,
-                                 p);
-    if (GNUNET_NO == h->is_receiving)
-    {
-      h->is_receiving = GNUNET_YES;
-      GNUNET_CLIENT_receive (h->client,
-                             &process_namestore_message, h,
-                             GNUNET_TIME_UNIT_FOREVER_REL);
-    }
-    GNUNET_free (p);
-  }
-  do_transmit (h);
-  return ret;
-}
-
-
-/**
- * Transmit messages from the message queue to the service
- * (if there are any, and if we are not already trying).
- *
- * @param h handle to use
- */
-static void
-do_transmit (struct GNUNET_NAMESTORE_Handle *h)
-{
-  struct PendingMessage *p;
-
-  if (NULL != h->th)
-    return; /* transmission request already pending */
-  if (NULL == (p = h->pending_head))
-    return; /* transmission queue empty */
-  if (NULL == h->client)
-    return;                     /* currently reconnecting */
-  h->th = GNUNET_CLIENT_notify_transmit_ready (h->client, p->size,
-                                               GNUNET_TIME_UNIT_FOREVER_REL,
-                                               GNUNET_NO, &transmit_message_to_namestore,
-                                               h);
-  GNUNET_break (NULL != h->th);
+  force_reconnect (h);
 }
 
 
@@ -855,10 +763,49 @@ do_transmit (struct GNUNET_NAMESTORE_Handle *h)
 static void
 reconnect (struct GNUNET_NAMESTORE_Handle *h)
 {
-  GNUNET_assert (NULL == h->client);
-  h->client = GNUNET_CLIENT_connect ("namestore", h->cfg);
-  GNUNET_assert (NULL != h->client);
-  do_transmit (h);
+  GNUNET_MQ_hd_fixed_size (record_store_response,
+                           GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_STORE_RESPONSE,
+                           struct RecordStoreResponseMessage);
+  GNUNET_MQ_hd_var_size (zone_to_name_response,
+                         GNUNET_MESSAGE_TYPE_NAMESTORE_ZONE_TO_NAME_RESPONSE,
+                         struct ZoneToNameResponseMessage);
+  GNUNET_MQ_hd_var_size (record_result,
+                         GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_RESULT,
+                         struct RecordResultMessage);
+  GNUNET_MQ_hd_var_size (lookup_result,
+                         GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_LOOKUP_RESPONSE,
+                         struct LabelLookupResponseMessage);
+  struct GNUNET_MQ_MessageHandler handlers[] = {
+    make_record_store_response_handler (h),
+    make_zone_to_name_response_handler (h),
+    make_record_result_handler (h),
+    make_lookup_result_handler (h),
+    GNUNET_MQ_handler_end ()
+  };
+  struct GNUNET_NAMESTORE_ZoneIterator *it;
+  struct GNUNET_NAMESTORE_QueueEntry *qe;
+
+  GNUNET_assert (NULL == h->mq);
+  h->mq = GNUNET_CLIENT_connecT (h->cfg,
+                                 "namestore",
+                                 handlers,
+                                 &mq_error_handler,
+                                 h);
+  if (NULL == h->mq)
+    return;
+  /* re-transmit pending requests that waited for a reconnect... */
+  for (it = h->z_head; NULL != it; it = it->next)
+  {
+    GNUNET_MQ_send (h->mq,
+                    it->env);
+    it->env = NULL;
+  }
+  for (qe = h->op_head; NULL != qe; qe = qe->next)
+  {
+    GNUNET_MQ_send (h->mq,
+                    qe->env);
+    qe->env = NULL;
+  }
 }
 
 
@@ -885,17 +832,30 @@ reconnect_task (void *cls)
 static void
 force_reconnect (struct GNUNET_NAMESTORE_Handle *h)
 {
-  if (NULL != h->th)
+  struct GNUNET_NAMESTORE_ZoneIterator *ze;
+  struct GNUNET_NAMESTORE_QueueEntry *qe;
+
+  GNUNET_MQ_destroy (h->mq);
+  h->mq = NULL;
+  for (ze = h->z_head; NULL != ze; ze = ze->next)
   {
-    GNUNET_CLIENT_notify_transmit_ready_cancel (h->th);
-    h->th = NULL;
+    /* FIXME: This does not allow clients to distinguish
+       iteration error from successful termination! */
+    if (NULL != ze->proc)
+      ze->proc (ze->proc_cls, NULL, NULL, 0, NULL);
+    free_ze (ze);
   }
-  h->reconnect = GNUNET_NO;
-  GNUNET_CLIENT_disconnect (h->client);
+  for (qe = h->op_head; NULL != qe; qe = qe->next)
+  {
+    /* FIXME: This does not allow clients to distinguish
+       iteration error from successful termination! */
+    if (NULL != qe->proc)
+      qe->proc (qe->proc_cls, NULL, NULL, 0, NULL);
+    free_qe (qe);
+  }
+
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "Reconnecting to namestore\n");
-  h->is_receiving = GNUNET_NO;
-  h->client = NULL;
   h->reconnect_delay = GNUNET_TIME_STD_BACKOFF (h->reconnect_delay);
   h->reconnect_task = GNUNET_SCHEDULER_add_delayed (h->reconnect_delay,
                                                     &reconnect_task,
@@ -929,8 +889,12 @@ GNUNET_NAMESTORE_connect (const struct GNUNET_CONFIGURATION_Handle *cfg)
 
   h = GNUNET_new (struct GNUNET_NAMESTORE_Handle);
   h->cfg = cfg;
-  h->reconnect_task = GNUNET_SCHEDULER_add_now (&reconnect_task, h);
-  h->last_op_id_used = 0;
+  reconnect (h);
+  if (NULL == h->mq)
+  {
+    GNUNET_free (h);
+    return NULL;
+  }
   return h;
 }
 
@@ -944,38 +908,31 @@ GNUNET_NAMESTORE_connect (const struct GNUNET_CONFIGURATION_Handle *cfg)
 void
 GNUNET_NAMESTORE_disconnect (struct GNUNET_NAMESTORE_Handle *h)
 {
-  struct PendingMessage *p;
   struct GNUNET_NAMESTORE_QueueEntry *q;
   struct GNUNET_NAMESTORE_ZoneIterator *z;
 
-  LOG (GNUNET_ERROR_TYPE_DEBUG, "Cleaning up\n");
-  GNUNET_assert (NULL != h);
-  if (NULL != h->th)
-  {
-    GNUNET_CLIENT_notify_transmit_ready_cancel (h->th);
-    h->th = NULL;
-  }
-  while (NULL != (p = h->pending_head))
-  {
-    GNUNET_CONTAINER_DLL_remove (h->pending_head, h->pending_tail, p);
-    GNUNET_free (p);
-  }
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Cleaning up\n");
   GNUNET_break (NULL == h->op_head);
   while (NULL != (q = h->op_head))
   {
-    GNUNET_CONTAINER_DLL_remove (h->op_head, h->op_tail, q);
+    GNUNET_CONTAINER_DLL_remove (h->op_head,
+                                 h->op_tail,
+                                 q);
     GNUNET_free (q);
   }
   GNUNET_break (NULL == h->z_head);
   while (NULL != (z = h->z_head))
   {
-    GNUNET_CONTAINER_DLL_remove (h->z_head, h->z_tail, z);
+    GNUNET_CONTAINER_DLL_remove (h->z_head,
+                                 h->z_tail,
+                                 z);
     GNUNET_free (z);
   }
-  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->reconnect_task)
   {
@@ -994,7 +951,7 @@ GNUNET_NAMESTORE_disconnect (struct GNUNET_NAMESTORE_Handle *h)
  * @param h handle to the namestore
  * @param pkey private key of the zone
  * @param label name that is being mapped (at most 255 characters long)
- * @param rd_count number of records in the 'rd' array
+ * @param rd_count number of records in the @a rd array
  * @param rd array of records with data to store
  * @param cont continuation to call when done
  * @param cont_cls closure for @a cont
@@ -1010,18 +967,14 @@ GNUNET_NAMESTORE_records_store (struct GNUNET_NAMESTORE_Handle *h,
                                 void *cont_cls)
 {
   struct GNUNET_NAMESTORE_QueueEntry *qe;
-  struct PendingMessage *pe;
+  struct GNUNET_MQ_Envelope *env;
   char *name_tmp;
   char *rd_ser;
   size_t rd_ser_len;
-  size_t msg_size;
   size_t name_len;
   uint32_t rid;
   struct RecordStoreMessage *msg;
 
-  GNUNET_assert (NULL != h);
-  GNUNET_assert (NULL != pkey);
-  GNUNET_assert (NULL != label);
   name_len = strlen (label) + 1;
   if (name_len > MAX_NAME_LEN)
   {
@@ -1030,20 +983,20 @@ GNUNET_NAMESTORE_records_store (struct GNUNET_NAMESTORE_Handle *h,
   }
   rid = get_op_id (h);
   qe = GNUNET_new (struct GNUNET_NAMESTORE_QueueEntry);
-  qe->nsh = h;
+  qe->h = h;
   qe->cont = cont;
   qe->cont_cls = cont_cls;
   qe->op_id = rid;
-  GNUNET_CONTAINER_DLL_insert_tail (h->op_head, h->op_tail, qe);
+  GNUNET_CONTAINER_DLL_insert_tail (h->op_head,
+                                    h->op_tail,
+                                    qe);
 
   /* setup msg */
-  rd_ser_len = GNUNET_GNSRECORD_records_get_size (rd_count, rd);
-  msg_size = sizeof (struct RecordStoreMessage) + name_len + rd_ser_len;
-  pe = GNUNET_malloc (sizeof (struct PendingMessage) + msg_size);
-  pe->size = msg_size;
-  msg = (struct RecordStoreMessage *) &pe[1];
-  msg->gns_header.header.type = htons (GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_STORE);
-  msg->gns_header.header.size = htons (msg_size);
+  rd_ser_len = GNUNET_GNSRECORD_records_get_size (rd_count,
+                                                  rd);
+  env = GNUNET_MQ_msg_extra (msg,
+                             name_len + rd_ser_len,
+                             GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_STORE);
   msg->gns_header.r_id = htonl (rid);
   msg->name_len = htons (name_len);
   msg->rd_count = htons (rd_count);
@@ -1052,21 +1005,29 @@ GNUNET_NAMESTORE_records_store (struct GNUNET_NAMESTORE_Handle *h,
   msg->private_key = *pkey;
 
   name_tmp = (char *) &msg[1];
-  memcpy (name_tmp, label, name_len);
+  memcpy (name_tmp,
+          label,
+          name_len);
   rd_ser = &name_tmp[name_len];
-  GNUNET_break (rd_ser_len ==
-                GNUNET_GNSRECORD_records_serialize (rd_count, rd,
-                                                    rd_ser_len,
-                                                    rd_ser));
+  GNUNET_assert (rd_ser_len ==
+                 GNUNET_GNSRECORD_records_serialize (rd_count,
+                                                     rd,
+                                                     rd_ser_len,
+                                                     rd_ser));
   LOG (GNUNET_ERROR_TYPE_DEBUG,
-       "Sending `%s' message for name `%s' with size %u and %u records\n",
-       "NAMESTORE_RECORD_STORE", label, msg_size,
+       "Sending NAMESTORE_RECORD_STORE message for name `%s' with %u records\n",
+       label,
        rd_count);
-  GNUNET_CONTAINER_DLL_insert_tail (h->pending_head, h->pending_tail, pe);
-  do_transmit (h);
+
+  if (NULL == h->mq)
+    qe->env = env;
+  else
+    GNUNET_MQ_send (h->mq,
+                    env);
   return qe;
 }
 
+
 /**
  * Set the desired nick name for a zone
  *
@@ -1074,7 +1035,7 @@ GNUNET_NAMESTORE_records_store (struct GNUNET_NAMESTORE_Handle *h,
  * @param pkey private key of the zone
  * @param nick the nick name to set
  * @param cont continuation to call when done
- * @param cont_cls closure for 'cont'
+ * @param cont_cls closure for @a cont
  * @return handle to abort the request
  */
 struct GNUNET_NAMESTORE_QueueEntry *
@@ -1086,13 +1047,21 @@ GNUNET_NAMESTORE_set_nick (struct GNUNET_NAMESTORE_Handle *h,
 {
   struct GNUNET_GNSRECORD_Data rd;
 
+  if (NULL == h->mq)
+    return NULL;
   memset (&rd, 0, sizeof (rd));
   rd.data = nick;
   rd.data_size = strlen (nick) +1;
   rd.record_type = GNUNET_GNSRECORD_TYPE_NICK;
   rd.expiration_time = GNUNET_TIME_UNIT_FOREVER_ABS.abs_value_us;
   rd.flags |= GNUNET_GNSRECORD_RF_PRIVATE;
-  return GNUNET_NAMESTORE_records_store(h, pkey, GNUNET_GNS_MASTERZONE_STR, 1, &rd, cont, cont_cls);
+  return GNUNET_NAMESTORE_records_store (h,
+                                         pkey,
+                                         GNUNET_GNS_MASTERZONE_STR,
+                                         1,
+                                         &rd,
+                                         cont,
+                                         cont_cls);
 }
 
 
@@ -1114,39 +1083,39 @@ GNUNET_NAMESTORE_records_lookup (struct GNUNET_NAMESTORE_Handle *h,
                                  void *rm_cls)
 {
   struct GNUNET_NAMESTORE_QueueEntry *qe;
-  struct PendingMessage *pe;
-  struct LabelLookupMessage * msg;
-  size_t msg_size;
+  struct GNUNET_MQ_Envelope *env;
+  struct LabelLookupMessage *msg;
   size_t label_len;
 
-  GNUNET_assert (NULL != h);
-  GNUNET_assert (NULL != pkey);
-  GNUNET_assert (NULL != label);
-
   if (1 == (label_len = strlen (label) + 1))
+  {
+    GNUNET_break (0);
     return NULL;
+  }
 
   qe = GNUNET_new (struct GNUNET_NAMESTORE_QueueEntry);
-  qe->nsh = h;
+  qe->h = h;
   qe->proc = rm;
   qe->proc_cls = rm_cls;
   qe->op_id = get_op_id(h);
-  GNUNET_CONTAINER_DLL_insert_tail (h->op_head, h->op_tail, qe);
-
-  msg_size = sizeof (struct LabelLookupMessage) + label_len;
-  pe = GNUNET_malloc (sizeof (struct PendingMessage) + msg_size);
-  pe->size = msg_size;
-  msg = (struct LabelLookupMessage *) &pe[1];
-  msg->gns_header.header.type = htons (GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_LOOKUP);
-  msg->gns_header.header.size = htons (msg_size);
+  GNUNET_CONTAINER_DLL_insert_tail (h->op_head,
+                                    h->op_tail,
+                                    qe);
+
+  env = GNUNET_MQ_msg_extra (msg,
+                             label_len,
+                             GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_LOOKUP);
   msg->gns_header.r_id = htonl (qe->op_id);
   msg->zone = *pkey;
-  msg->label_len = htonl(label_len);
-  memcpy (&msg[1], label, label_len);
-
-  /* transmit message */
-  GNUNET_CONTAINER_DLL_insert_tail (h->pending_head, h->pending_tail, pe);
-  do_transmit (h);
+  msg->label_len = htonl (label_len);
+  memcpy (&msg[1],
+          label,
+          label_len);
+  if (NULL == h->mq)
+    qe->env = env;
+  else
+    GNUNET_MQ_send (h->mq,
+                    env);
   return qe;
 }
 
@@ -1168,38 +1137,34 @@ struct GNUNET_NAMESTORE_QueueEntry *
 GNUNET_NAMESTORE_zone_to_name (struct GNUNET_NAMESTORE_Handle *h,
                                const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone,
                                const struct GNUNET_CRYPTO_EcdsaPublicKey *value_zone,
-                               GNUNET_NAMESTORE_RecordMonitor proc, void *proc_cls)
+                               GNUNET_NAMESTORE_RecordMonitor proc,
+                               void *proc_cls)
 {
   struct GNUNET_NAMESTORE_QueueEntry *qe;
-  struct PendingMessage *pe;
-  struct ZoneToNameMessage * msg;
-  size_t msg_size;
+  struct GNUNET_MQ_Envelope *env;
+  struct ZoneToNameMessage *msg;
   uint32_t rid;
 
-  GNUNET_assert (NULL != h);
-  GNUNET_assert (NULL != zone);
-  GNUNET_assert (NULL != value_zone);
   rid = get_op_id(h);
   qe = GNUNET_new (struct GNUNET_NAMESTORE_QueueEntry);
-  qe->nsh = h;
+  qe->h = h;
   qe->proc = proc;
   qe->proc_cls = proc_cls;
   qe->op_id = rid;
-  GNUNET_CONTAINER_DLL_insert_tail (h->op_head, h->op_tail, qe);
-
-  msg_size = sizeof (struct ZoneToNameMessage);
-  pe = GNUNET_malloc (sizeof (struct PendingMessage) + msg_size);
-  pe->size = msg_size;
-  msg = (struct ZoneToNameMessage *) &pe[1];
-  msg->gns_header.header.type = htons (GNUNET_MESSAGE_TYPE_NAMESTORE_ZONE_TO_NAME);
-  msg->gns_header.header.size = htons (msg_size);
+  GNUNET_CONTAINER_DLL_insert_tail (h->op_head,
+                                    h->op_tail,
+                                    qe);
+
+  env = GNUNET_MQ_msg (msg,
+                       GNUNET_MESSAGE_TYPE_NAMESTORE_ZONE_TO_NAME);
   msg->gns_header.r_id = htonl (rid);
   msg->zone = *zone;
   msg->value_zone = *value_zone;
-
-  /* transmit message */
-  GNUNET_CONTAINER_DLL_insert_tail (h->pending_head, h->pending_tail, pe);
-  do_transmit (h);
+  if (NULL == h->mq)
+    qe->env = env;
+  else
+    GNUNET_MQ_send (h->mq,
+                    env);
   return qe;
 }
 
@@ -1227,13 +1192,11 @@ GNUNET_NAMESTORE_zone_iteration_start (struct GNUNET_NAMESTORE_Handle *h,
                                        void *proc_cls)
 {
   struct GNUNET_NAMESTORE_ZoneIterator *it;
-  struct PendingMessage *pe;
-  struct ZoneIterationStartMessage * msg;
-  size_t msg_size;
+  struct GNUNET_MQ_Envelope *env;
+  struct ZoneIterationStartMessage *msg;
   uint32_t rid;
 
-  GNUNET_assert (NULL != h);
-  rid = get_op_id(h);
+  rid = get_op_id (h);
   it = GNUNET_new (struct GNUNET_NAMESTORE_ZoneIterator);
   it->h = h;
   it->proc = proc;
@@ -1241,19 +1204,19 @@ GNUNET_NAMESTORE_zone_iteration_start (struct GNUNET_NAMESTORE_Handle *h,
   it->op_id = rid;
   if (NULL != zone)
     it->zone = *zone;
-  GNUNET_CONTAINER_DLL_insert_tail (h->z_head, h->z_tail, it);
-
-  msg_size = sizeof (struct ZoneIterationStartMessage);
-  pe = GNUNET_malloc (sizeof (struct PendingMessage) + msg_size);
-  pe->size = msg_size;
-  msg = (struct ZoneIterationStartMessage *) &pe[1];
-  msg->gns_header.header.type = htons (GNUNET_MESSAGE_TYPE_NAMESTORE_ZONE_ITERATION_START);
-  msg->gns_header.header.size = htons (msg_size);
+  GNUNET_CONTAINER_DLL_insert_tail (h->z_head,
+                                    h->z_tail,
+                                    it);
+  env = GNUNET_MQ_msg (msg,
+                       GNUNET_MESSAGE_TYPE_NAMESTORE_ZONE_ITERATION_START);
   msg->gns_header.r_id = htonl (rid);
   if (NULL != zone)
     msg->zone = *zone;
-  GNUNET_CONTAINER_DLL_insert_tail (h->pending_head, h->pending_tail, pe);
-  do_transmit (h);
+  if (NULL == h->mq)
+    it->env = env;
+  else
+    GNUNET_MQ_send (h->mq,
+                    env);
   return it;
 }
 
@@ -1267,25 +1230,17 @@ GNUNET_NAMESTORE_zone_iteration_start (struct GNUNET_NAMESTORE_Handle *h,
 void
 GNUNET_NAMESTORE_zone_iterator_next (struct GNUNET_NAMESTORE_ZoneIterator *it)
 {
-  struct GNUNET_NAMESTORE_Handle *h;
-  struct ZoneIterationNextMessage * msg;
-  struct PendingMessage *pe;
-  size_t msg_size;
-
-  GNUNET_assert (NULL != it);
-  h = it->h;
-  msg_size = sizeof (struct ZoneIterationNextMessage);
-  pe = GNUNET_malloc (sizeof (struct PendingMessage) + msg_size);
-  pe->size = msg_size;
-  msg = (struct ZoneIterationNextMessage *) &pe[1];
-  msg->gns_header.header.type = htons (GNUNET_MESSAGE_TYPE_NAMESTORE_ZONE_ITERATION_NEXT);
-  msg->gns_header.header.size = htons (msg_size);
-  msg->gns_header.r_id = htonl (it->op_id);
+  struct GNUNET_NAMESTORE_Handle *h = it->h;
+  struct ZoneIterationNextMessage *msg;
+  struct GNUNET_MQ_Envelope *env;
+
   LOG (GNUNET_ERROR_TYPE_DEBUG,
-       "Sending `%s' message\n",
-       "ZONE_ITERATION_NEXT");
-  GNUNET_CONTAINER_DLL_insert_tail (h->pending_head, h->pending_tail, pe);
-  do_transmit (h);
+       "Sending ZONE_ITERATION_NEXT message\n");
+  env = GNUNET_MQ_msg (msg,
+                       GNUNET_MESSAGE_TYPE_NAMESTORE_ZONE_ITERATION_NEXT);
+  msg->gns_header.r_id = htonl (it->op_id);
+  GNUNET_MQ_send (h->mq,
+                  env);
 }
 
 
@@ -1297,29 +1252,18 @@ GNUNET_NAMESTORE_zone_iterator_next (struct GNUNET_NAMESTORE_ZoneIterator *it)
 void
 GNUNET_NAMESTORE_zone_iteration_stop (struct GNUNET_NAMESTORE_ZoneIterator *it)
 {
-  struct GNUNET_NAMESTORE_Handle *h;
-  struct PendingMessage *pe;
-  size_t msg_size;
-  struct ZoneIterationStopMessage * msg;
+  struct GNUNET_NAMESTORE_Handle *h = it->h;
+  struct GNUNET_MQ_Envelope *env;
+  struct ZoneIterationStopMessage *msg;
 
-  GNUNET_assert (NULL != it);
-  h = it->h;
-  GNUNET_CONTAINER_DLL_remove (h->z_head,
-                               h->z_tail,
-                               it);
-  msg_size = sizeof (struct ZoneIterationStopMessage);
-  pe = GNUNET_malloc (sizeof (struct PendingMessage) + msg_size);
-  pe->size = msg_size;
-  msg = (struct ZoneIterationStopMessage *) &pe[1];
-  msg->gns_header.header.type = htons (GNUNET_MESSAGE_TYPE_NAMESTORE_ZONE_ITERATION_STOP);
-  msg->gns_header.header.size = htons (msg_size);
-  msg->gns_header.r_id = htonl (it->op_id);
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Sending `%s' message\n",
-              "ZONE_ITERATION_STOP");
-  GNUNET_CONTAINER_DLL_insert_tail (h->pending_head, h->pending_tail, pe);
-  do_transmit (h);
-  GNUNET_free (it);
+              "Sending ZONE_ITERATION_STOP message\n");
+  env = GNUNET_MQ_msg (msg,
+                       GNUNET_MESSAGE_TYPE_NAMESTORE_ZONE_ITERATION_STOP);
+  msg->gns_header.r_id = htonl (it->op_id);
+  GNUNET_MQ_send (h->mq,
+                  env);
+  free_ze (it);
 }
 
 
@@ -1332,11 +1276,7 @@ GNUNET_NAMESTORE_zone_iteration_stop (struct GNUNET_NAMESTORE_ZoneIterator *it)
 void
 GNUNET_NAMESTORE_cancel (struct GNUNET_NAMESTORE_QueueEntry *qe)
 {
-  struct GNUNET_NAMESTORE_Handle *h = qe->nsh;
-
-  GNUNET_assert (NULL != qe);
-  GNUNET_CONTAINER_DLL_remove (h->op_head, h->op_tail, qe);
-  GNUNET_free(qe);
+  free_qe (qe);
 }