X-Git-Url: https://git.librecmc.org/?a=blobdiff_plain;f=src%2Fidentity%2Fidentity_api.c;h=30a6fb23d9998e2081da42fdf72b766f34e53e85;hb=341c1dd692c62a88eeff34fca155ce2377677d4b;hp=f03f7b449f505095f8fa7082b50f6ff9ef23b5fe;hpb=d0e0b8256a32f05dee2bc79494e4fba7830e63d2;p=oweals%2Fgnunet.git

diff --git a/src/identity/identity_api.c b/src/identity/identity_api.c
index f03f7b449..30a6fb23d 100644
--- a/src/identity/identity_api.c
+++ b/src/identity/identity_api.c
@@ -1,21 +1,19 @@
 /*
      This file is part of GNUnet.
-     (C) 2013 Christian Grothoff (and other contributing authors)
+     Copyright (C) 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 Liceidentity as published
-     by the Free Software Foundation; either version 3, or (at your
-     option) any later version.
+     GNUnet is free software: you can redistribute it and/or modify it
+     under the terms of the GNU Affero General Public License as published
+     by the Free Software Foundation, either version 3 of the License,
+     or (at your option) any later version.
 
      GNUnet is distributed in the hope that it will be useful, but
      WITHOUT ANY WARRANTY; without even the implied warranty of
      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-     General Public Liceidentity for more details.
-
-     You should have received a copy of the GNU General Public Liceidentity
-     along with GNUnet; see the file COPYING.  If not, write to the
-     Free Software Foundation, Inc., 59 Temple Place - Suite 330,
-     Boston, MA 02111-1307, USA.
+     Affero General Public License for more details.
+    
+     You should have received a copy of the GNU Affero General Public License
+     along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
 /**
@@ -24,33 +22,28 @@
  * @author Christian Grothoff
  */
 #include "platform.h"
-#include "gnunet_client_lib.h"
+#include "gnunet_util_lib.h"
 #include "gnunet_constants.h"
-#include "gnunet_container_lib.h"
-#include "gnunet_arm_service.h"
-#include "gnunet_hello_lib.h"
 #include "gnunet_protocols.h"
-#include "gnunet_server_lib.h"
-#include "gnunet_time_lib.h"
 #include "gnunet_identity_service.h"
 #include "identity.h"
 
 #define LOG(kind,...) GNUNET_log_from (kind, "identity-api",__VA_ARGS__)
 
-/** 
- * Handle for a ego.
+/**
+ * Handle for an ego.
  */
 struct GNUNET_IDENTITY_Ego
 {
   /**
    * Private key associated with this ego.
    */
-  struct GNUNET_CRYPTO_EccPrivateKey *pk;
+  struct GNUNET_CRYPTO_EcdsaPrivateKey *pk;
 
   /**
-   * Current identifier (name) associated with this ego.
+   * Current name associated with this ego.
    */
-  char *identifier;
+  char *name;
 
   /**
    * Client context associated with this ego.
@@ -64,7 +57,7 @@ struct GNUNET_IDENTITY_Ego
 };
 
 
-/** 
+/**
  * Handle for an operation with the identity service.
  */
 struct GNUNET_IDENTITY_Operation
@@ -74,7 +67,7 @@ struct GNUNET_IDENTITY_Operation
    * Main identity handle.
    */
   struct GNUNET_IDENTITY_Handle *h;
-  
+
   /**
    * We keep operations in a DLL.
    */
@@ -92,19 +85,19 @@ struct GNUNET_IDENTITY_Operation
   const struct GNUNET_MessageHeader *msg;
 
   /**
-   * Continuation to invoke with the result of the transmission; 'cb'
+   * Continuation to invoke with the result of the transmission; @e cb
    * will be NULL in this case.
    */
   GNUNET_IDENTITY_Continuation cont;
 
   /**
    * Continuation to invoke with the result of the transmission for
-   * 'get' operations ('cont' will be NULL in this case).
+   * 'get' operations (@e cont will be NULL in this case).
    */
   GNUNET_IDENTITY_Callback cb;
 
   /**
-   * Closure for 'cont' or 'cb'.
+   * Closure for @e cont or @e cb.
    */
   void *cls;
 
@@ -122,13 +115,13 @@ struct GNUNET_IDENTITY_Handle
   const struct GNUNET_CONFIGURATION_Handle *cfg;
 
   /**
-   * Socket (if available).
+   * Connection to service.
    */
-  struct GNUNET_CLIENT_Connection *client;
+  struct GNUNET_MQ_Handle *mq;
 
   /**
    * Hash map from the hash of the public key to the
-   * respective 'GNUNET_IDENTITY_Ego' handle.
+   * respective `GNUNET_IDENTITY_Ego` handle.
    */
   struct GNUNET_CONTAINER_MultiHashMap *egos;
 
@@ -138,29 +131,24 @@ struct GNUNET_IDENTITY_Handle
   GNUNET_IDENTITY_Callback cb;
 
   /**
-   * Closure for 'cb'.
+   * Closure for @e cb.
    */
   void *cb_cls;
 
   /**
    * Head of active operations.
-   */ 
+   */
   struct GNUNET_IDENTITY_Operation *op_head;
 
   /**
    * Tail of active operations.
-   */ 
-  struct GNUNET_IDENTITY_Operation *op_tail;
-
-  /**
-   * Currently pending transmission request, or NULL for none.
    */
-  struct GNUNET_CLIENT_TransmitHandle *th;
+  struct GNUNET_IDENTITY_Operation *op_tail;
 
   /**
    * Task doing exponential back-off trying to reconnect.
    */
-  GNUNET_SCHEDULER_TaskIdentifier reconnect_task;
+  struct GNUNET_SCHEDULER_Task *reconnect_task;
 
   /**
    * Time for next connect retry.
@@ -175,16 +163,68 @@ struct GNUNET_IDENTITY_Handle
 };
 
 
+/**
+ * Obtain the ego representing 'anonymous' users.
+ *
+ * @return handle for the anonymous user, must not be freed
+ */
+const struct GNUNET_IDENTITY_Ego *
+GNUNET_IDENTITY_ego_get_anonymous ()
+{
+  static struct GNUNET_IDENTITY_Ego anon;
+  struct GNUNET_CRYPTO_EcdsaPublicKey pub;
+
+  if (NULL != anon.pk)
+    return &anon;
+  anon.pk = (struct GNUNET_CRYPTO_EcdsaPrivateKey *) GNUNET_CRYPTO_ecdsa_key_get_anonymous ();
+  GNUNET_CRYPTO_ecdsa_key_get_public (anon.pk,
+                                      &pub);
+  GNUNET_CRYPTO_hash (&pub,
+                      sizeof (pub),
+                      &anon.id);
+  return &anon;
+}
+
 
 /**
- * Try again to connect to network size estimation service.
+ * Try again to connect to the identity service.
  *
- * @param cls the handle to the transport service
- * @param tc scheduler context
+ * @param cls handle to the identity service.
  */
 static void
-reconnect (void *cls,
-	   const struct GNUNET_SCHEDULER_TaskContext *tc);
+reconnect (void *cls);
+
+
+/**
+ * Free ego from hash map.
+ *
+ * @param cls identity service handle
+ * @param key unused
+ * @param value ego to free
+ * @return #GNUNET_OK (continue to iterate)
+ */
+static int
+free_ego (void *cls,
+	  const struct GNUNET_HashCode *key,
+	  void *value)
+{
+  struct GNUNET_IDENTITY_Handle *h = cls;
+  struct GNUNET_IDENTITY_Ego *ego = value;
+
+  if (NULL != h->cb)
+    h->cb (h->cb_cls,
+	   ego,
+	   &ego->ctx,
+	   NULL);
+  GNUNET_free (ego->pk);
+  GNUNET_free (ego->name);
+  GNUNET_assert (GNUNET_YES ==
+                 GNUNET_CONTAINER_multihashmap_remove (h->egos,
+                                                       key,
+                                                       value));
+  GNUNET_free (ego);
+  return GNUNET_OK;
+}
 
 
 /**
@@ -195,347 +235,355 @@ reconnect (void *cls,
 static void
 reschedule_connect (struct GNUNET_IDENTITY_Handle *h)
 {
-  GNUNET_assert (h->reconnect_task == GNUNET_SCHEDULER_NO_TASK);
+  struct GNUNET_IDENTITY_Operation *op;
 
-  if (NULL != h->th)
+  GNUNET_assert (NULL == h->reconnect_task);
+
+  if (NULL != h->mq)
   {
-    GNUNET_CLIENT_notify_transmit_ready_cancel (h->th);
-    h->th = NULL;
+    GNUNET_MQ_destroy (h->mq);
+    h->mq = NULL;
   }
-  if (NULL != h->client)
+  while (NULL != (op = h->op_head))
   {
-    GNUNET_CLIENT_disconnect (h->client);
-    h->client = NULL;
+    GNUNET_CONTAINER_DLL_remove (h->op_head,
+                                 h->op_tail,
+                                 op);
+    if (NULL != op->cont)
+      op->cont (op->cls,
+                "Error in communication with the identity service");
+    else if (NULL != op->cb)
+      op->cb (op->cls,
+              NULL,
+              NULL,
+              NULL);
+    GNUNET_free (op);
   }
-  h->in_receive = GNUNET_NO;
+  GNUNET_CONTAINER_multihashmap_iterate (h->egos,
+                                         &free_ego,
+                                         h);
   LOG (GNUNET_ERROR_TYPE_DEBUG,
        "Scheduling task to reconnect to identity service in %s.\n",
-       GNUNET_STRINGS_relative_time_to_string (h->reconnect_delay, GNUNET_YES));
+       GNUNET_STRINGS_relative_time_to_string (h->reconnect_delay,
+                                               GNUNET_YES));
   h->reconnect_task =
-      GNUNET_SCHEDULER_add_delayed (h->reconnect_delay, &reconnect, h);
+      GNUNET_SCHEDULER_add_delayed (h->reconnect_delay,
+                                    &reconnect,
+                                    h);
   h->reconnect_delay = GNUNET_TIME_STD_BACKOFF (h->reconnect_delay);
 }
 
 
 /**
- * Type of a function to call when we receive a message
- * from the service.
+ * 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 closure
- * @param msg message received, NULL on timeout or fatal error
+ * @param cls closure with the `struct GNUNET_IDENTITY_Handle *`
+ * @param error error code
  */
 static void
-message_handler (void *cls, 
-		 const struct GNUNET_MessageHeader *msg)
+mq_error_handler (void *cls,
+                  enum GNUNET_MQ_Error error)
 {
   struct GNUNET_IDENTITY_Handle *h = cls;
-  struct GNUNET_IDENTITY_Operation *op;
-  struct GNUNET_IDENTITY_Ego *ego;
-  const struct GNUNET_IDENTITY_ResultCodeMessage *rcm;
-  const struct GNUNET_IDENTITY_UpdateMessage *um;
-  const struct GNUNET_IDENTITY_SetDefaultMessage *sdm;
-  struct GNUNET_CRYPTO_EccPrivateKey *priv;
-  struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded pub;
-  struct GNUNET_HashCode id;
-  const char *str;
-  uint16_t size;
-  uint16_t pk_len;
-  uint16_t name_len;
 
-  if (NULL == msg)
+  reschedule_connect (h);
+}
+
+
+/**
+ * We received a result code from the service.  Check the message
+ * is well-formed.
+ *
+ * @param cls closure
+ * @param rcm result message received
+ * @return #GNUNET_OK if the message is well-formed
+ */
+static int
+check_identity_result_code (void *cls,
+                            const struct ResultCodeMessage *rcm)
+{
+  uint16_t size = ntohs (rcm->header.size) - sizeof (*rcm);
+  const char *str = (const char *) &rcm[1];
+
+  if (0 == size)
+    return GNUNET_OK;
+  if ('\0' != str[size - 1])
   {
-    reschedule_connect (h);
-    return;
+    GNUNET_break (0);
+    return GNUNET_SYSERR;
   }
-  size = ntohs (msg->size);
-  switch (ntohs (msg->type))
-  {
-  case GNUNET_MESSAGE_TYPE_IDENTITY_RESULT_CODE:
-    if (size < sizeof (struct GNUNET_IDENTITY_ResultCodeMessage))
-    {
-      GNUNET_break (0);
-      reschedule_connect (h);
-      return;
-    }
-    rcm = (const struct GNUNET_IDENTITY_ResultCodeMessage *) msg;
-    str = (const char *) &rcm[1];
-    if ( (size > sizeof (struct GNUNET_IDENTITY_ResultCodeMessage)) &&
-	 ('\0' != str[size - sizeof (struct GNUNET_IDENTITY_ResultCodeMessage) - 1]) )
-    {
-      GNUNET_break (0);
-      reschedule_connect (h);
-      return;
-    }
-    if (size == sizeof (struct GNUNET_IDENTITY_ResultCodeMessage))
-      str = NULL;
+  return GNUNET_OK;
+}
 
-    op = h->op_head;
-    GNUNET_CONTAINER_DLL_remove (h->op_head,
-				 h->op_tail,
-				 op);
-    if (NULL != op->cont)
-      op->cont (op->cls,
-		str);
-    GNUNET_break (NULL == op->cb);
-    GNUNET_free (op);
-    break;
-  case GNUNET_MESSAGE_TYPE_IDENTITY_UPDATE:
-    if (size < sizeof (struct GNUNET_IDENTITY_UpdateMessage))
-    {
-      GNUNET_break (0);
-      reschedule_connect (h);
-      return;
-    }
-    um = (const struct GNUNET_IDENTITY_UpdateMessage *) msg;
-    pk_len = ntohs (um->pk_len);
-    name_len = ntohs (um->name_len);    
-    str = (const char *) &um[1];
-    if ( (size != pk_len + name_len + sizeof (struct GNUNET_IDENTITY_UpdateMessage)) ||
-	 ( (0 != name_len) &&
-	   ('\0' != str[pk_len + name_len - 1])) )
-    {
-      GNUNET_break (0);
-      reschedule_connect (h);
-      return;
-    }
-    priv = GNUNET_CRYPTO_ecc_decode_key (str, pk_len, GNUNET_YES); 
-    if (NULL == priv)
-    {
-      GNUNET_break (0);
-      reschedule_connect (h);
-      return;
-    }
-    GNUNET_CRYPTO_ecc_key_get_public (priv,
-				      &pub);
-    GNUNET_CRYPTO_hash (&pub, sizeof (pub), &id);
-    if (0 == name_len)
-      str = NULL;
-    else
-      str = &str[pk_len];
-    ego = GNUNET_CONTAINER_multihashmap_get (h->egos,
-					     &id);
-    if (NULL == ego)
-    {
-      /* ego was created */
-      if (NULL == str)
-      {
-	/* deletion of unknown ego? not allowed */
-	GNUNET_break (0);
-	GNUNET_CRYPTO_ecc_key_free (priv);
-	reschedule_connect (h);
-	return;
-      }
-      ego = GNUNET_new (struct GNUNET_IDENTITY_Ego);
-      ego->pk = priv;
-      ego->identifier = GNUNET_strdup (str);
-      ego->id = id;
-      GNUNET_assert (GNUNET_YES ==
-		     GNUNET_CONTAINER_multihashmap_put (h->egos,
-							&ego->id,
-							ego,
-							GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
-    }
-    else
-    {
-      GNUNET_CRYPTO_ecc_key_free (priv);
-    }
-    /* inform application about change */
-    h->cb (h->cb_cls,
-	   ego,
-	   &ego->ctx,
-	   str);
-    if (NULL == str)
-    {
-      /* ego was deleted */
-      GNUNET_assert (GNUNET_YES ==
-		     GNUNET_CONTAINER_multihashmap_remove (h->egos,
-							   &ego->id,
-							   ego));
-      GNUNET_CRYPTO_ecc_key_free (ego->pk);
-      GNUNET_free (ego->identifier);
-      GNUNET_free (ego);
-    }
-    else
-      {
-      /* ego changed name */
-      GNUNET_free (ego->identifier);
-      ego->identifier = GNUNET_strdup (str);
-    }    
-    break;
-  case GNUNET_MESSAGE_TYPE_IDENTITY_SET_DEFAULT:
-    if (size < sizeof (struct GNUNET_IDENTITY_SetDefaultMessage))
-    {
-      GNUNET_break (0);
-      reschedule_connect (h);
-      return;
-    }
-    sdm = (const struct GNUNET_IDENTITY_SetDefaultMessage *) msg;
-    pk_len = ntohs (sdm->pk_len);
-    name_len = ntohs (sdm->name_len);
-    str = (const char *) &sdm[1];
-    if ( (size != pk_len + name_len + sizeof (struct GNUNET_IDENTITY_SetDefaultMessage)) ||
-	 ( (0 != name_len) &&
-	   ('\0' != str[pk_len + name_len - 1]) ) )
-    {
-      GNUNET_break (0);
-      reschedule_connect (h);
-      return;
-    }
-    priv = GNUNET_CRYPTO_ecc_decode_key (str, pk_len, GNUNET_YES); 
-    if (NULL == priv)
-    {
-      GNUNET_break (0);
-      reschedule_connect (h);
-      return;
-    }
-    GNUNET_CRYPTO_ecc_key_get_public (priv,
-				      &pub);
-    GNUNET_CRYPTO_ecc_key_free (priv);
-    GNUNET_CRYPTO_hash (&pub, sizeof (pub), &id);
-    if (0 == name_len)
-      str = NULL;
-    else
-      str = &str[pk_len];
-    ego = GNUNET_CONTAINER_multihashmap_get (h->egos,
-					     &id);
-    if (NULL == ego)
-    {
-      GNUNET_break (0);
-      reschedule_connect (h);
-      return;
-    }
-    op = h->op_head;
-    GNUNET_CONTAINER_DLL_remove (h->op_head,
-				 h->op_tail,
-				 op);
-    if (NULL != op->cb)
-      op->cb (op->cls,
-	      ego,
-	      &ego->ctx,
-	      ego->identifier);
-    GNUNET_break (NULL == op->cont);
-    GNUNET_free (op);
-    break;
-  default:
+
+/**
+ * We received a result code from the service.
+ *
+ * @param cls closure
+ * @param rcm result message received
+ */
+static void
+handle_identity_result_code (void *cls,
+                             const struct ResultCodeMessage *rcm)
+{
+  struct GNUNET_IDENTITY_Handle *h = cls;
+  struct GNUNET_IDENTITY_Operation *op;
+  uint16_t size = ntohs (rcm->header.size) - sizeof (*rcm);
+  const char *str = (0 == size) ? NULL : (const char *) &rcm[1];
+
+  op = h->op_head;
+  if (NULL == op)
+  {
     GNUNET_break (0);
     reschedule_connect (h);
     return;
   }
-  GNUNET_CLIENT_receive (h->client, &message_handler, h,
-                         GNUNET_TIME_UNIT_FOREVER_REL);
+  GNUNET_CONTAINER_DLL_remove (h->op_head,
+                               h->op_tail,
+                               op);
+  if (NULL != op->cont)
+    op->cont (op->cls,
+              str);
+  else if (NULL != op->cb)
+    op->cb (op->cls, NULL, NULL, NULL);
+  GNUNET_free (op);
 }
 
 
 /**
- * Schedule transmission of the next message from our queue.
+ * Check validity of identity update message.
  *
- * @param h identity handle
+ * @param cls closure
+ * @param um message received
+ * @return #GNUNET_OK if the message is well-formed
  */
-static void
-transmit_next (struct GNUNET_IDENTITY_Handle *h);
+static int
+check_identity_update (void *cls,
+                        const struct UpdateMessage *um)
+{
+  uint16_t size = ntohs (um->header.size);
+  uint16_t name_len = ntohs (um->name_len);
+  const char *str = (const char *) &um[1];
+
+  if ( (size != name_len + sizeof (struct UpdateMessage)) ||
+       ( (0 != name_len) &&
+         ('\0' != str[name_len - 1])) )
+  {
+    GNUNET_break (0);
+    return GNUNET_SYSERR;
+  }
+  return GNUNET_OK;
+}
 
 
 /**
- * Transmit next message to service.
+ * Handle identity update message.
  *
- * @param cls the 'struct GNUNET_IDENTITY_Handle'.
- * @param size number of bytes available in buf
- * @param buf where to copy the message
- * @return number of bytes copied to buf
+ * @param cls closure
+ * @param um message received
  */
-static size_t
-send_next_message (void *cls, 
-		   size_t size, 
-		   void *buf)
+static void
+handle_identity_update (void *cls,
+                        const struct UpdateMessage *um)
 {
   struct GNUNET_IDENTITY_Handle *h = cls;
-  struct GNUNET_IDENTITY_Operation *op = h->op_head;
-  size_t ret;
-  
-  h->th = NULL;
-  if (NULL == op)
-    return 0;
-  ret = ntohs (op->msg->size);
-  if (ret > size)
+  uint16_t name_len = ntohs (um->name_len);
+  const char *str = (0 == name_len) ? NULL : (const char *) &um[1];
+  struct GNUNET_CRYPTO_EcdsaPublicKey pub;
+  struct GNUNET_HashCode id;
+  struct GNUNET_IDENTITY_Ego *ego;
+
+  if (GNUNET_YES == ntohs (um->end_of_list))
   {
-    reschedule_connect (h);
-    return 0;
-  }  
-  memcpy (buf, op->msg, ret);
-  if ( (NULL == op->cont) &&
-       (NULL == op->cb) )
+    /* end of initial list of data */
+    if (NULL != h->cb)
+      h->cb (h->cb_cls,
+             NULL,
+             NULL,
+             NULL);
+    return;
+  }
+  GNUNET_CRYPTO_ecdsa_key_get_public (&um->private_key,
+				      &pub);
+  GNUNET_CRYPTO_hash (&pub,
+                      sizeof (pub),
+                      &id);
+  ego = GNUNET_CONTAINER_multihashmap_get (h->egos,
+                                           &id);
+  if (NULL == ego)
   {
-    GNUNET_CONTAINER_DLL_remove (h->op_head,
-				 h->op_tail,
-				 op);
-    GNUNET_free (op);
-    transmit_next (h);
+    /* ego was created */
+    if (NULL == str)
+    {
+      /* deletion of unknown ego? not allowed */
+      GNUNET_break (0);
+      reschedule_connect (h);
+      return;
+    }
+    ego = GNUNET_new (struct GNUNET_IDENTITY_Ego);
+    ego->pk = GNUNET_new (struct GNUNET_CRYPTO_EcdsaPrivateKey);
+    *ego->pk = um->private_key;
+    ego->name = GNUNET_strdup (str);
+    ego->id = id;
+    GNUNET_assert (GNUNET_YES ==
+                   GNUNET_CONTAINER_multihashmap_put (h->egos,
+                                                      &ego->id,
+                                                      ego,
+                                                      GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
+  }
+  if (NULL == str)
+  {
+    /* ego was deleted */
+    GNUNET_assert (GNUNET_YES ==
+                   GNUNET_CONTAINER_multihashmap_remove (h->egos,
+                                                         &ego->id,
+                                                         ego));
+  }
+  else
+  {
+    /* ego changed name */
+    GNUNET_free (ego->name);
+    ego->name = GNUNET_strdup (str);
   }
-  if (GNUNET_NO == h->in_receive)
+  /* inform application about change */
+  if (NULL != h->cb)
+    h->cb (h->cb_cls,
+           ego,
+           &ego->ctx,
+           str);
+  /* complete deletion */
+  if (NULL == str)
   {
-    h->in_receive = GNUNET_YES;
-    GNUNET_CLIENT_receive (h->client,
-			   &message_handler, h,
-			   GNUNET_TIME_UNIT_FOREVER_REL);
+    GNUNET_free (ego->pk);
+    GNUNET_free (ego->name);
+    GNUNET_free (ego);
   }
-  return ret;
 }
 
 
 /**
- * Schedule transmission of the next message from our queue.
+ * Function called when we receive a set default message from the
+ * service.
  *
- * @param h identity handle
+ * @param cls closure
+ * @param sdm message received
+ * @return #GNUNET_OK if the message is well-formed
+ */
+static int
+check_identity_set_default (void *cls,
+                            const struct SetDefaultMessage *sdm)
+{
+  uint16_t size = ntohs (sdm->header.size) - sizeof (*sdm);
+  uint16_t name_len = ntohs (sdm->name_len);
+  const char *str = (const char *) &sdm[1];
+
+  if ( (size != name_len) ||
+       ( (0 != name_len) &&
+         ('\0' != str[name_len - 1]) ) )
+  {
+    GNUNET_break (0);
+    return GNUNET_SYSERR;
+  }
+  GNUNET_break (0 == ntohs (sdm->reserved));
+  return GNUNET_OK;
+}
+
+
+/**
+ * Type of a function to call when we receive a message
+ * from the service.
+ *
+ * @param cls closure
+ * @param sdm message received
  */
 static void
-transmit_next (struct GNUNET_IDENTITY_Handle *h)
+handle_identity_set_default (void *cls,
+                             const struct SetDefaultMessage *sdm)
 {
-  struct GNUNET_IDENTITY_Operation *op = h->op_head;
+  struct GNUNET_IDENTITY_Handle *h = cls;
+  struct GNUNET_IDENTITY_Operation *op;
+  struct GNUNET_CRYPTO_EcdsaPublicKey pub;
+  struct GNUNET_HashCode id;
+  struct GNUNET_IDENTITY_Ego *ego;
 
-  GNUNET_assert (NULL == h->th);
+  GNUNET_CRYPTO_ecdsa_key_get_public (&sdm->private_key,
+				      &pub);
+  GNUNET_CRYPTO_hash (&pub,
+                      sizeof (pub),
+                      &id);
+  ego = GNUNET_CONTAINER_multihashmap_get (h->egos,
+                                           &id);
+  if (NULL == ego)
+  {
+    GNUNET_break (0);
+    reschedule_connect (h);
+    return;
+  }
+  op = h->op_head;
   if (NULL == op)
+  {
+    GNUNET_break (0);
+    reschedule_connect (h);
     return;
-  h->th = GNUNET_CLIENT_notify_transmit_ready (h->client,
-					       ntohs (op->msg->size),
-					       GNUNET_TIME_UNIT_FOREVER_REL,
-					       GNUNET_NO,
-					       &send_next_message,
-					       h);
-					       
+  }
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Received SET_DEFAULT message from identity service\n");
+  GNUNET_CONTAINER_DLL_remove (h->op_head,
+                               h->op_tail,
+                               op);
+  if (NULL != op->cb)
+    op->cb (op->cls,
+            ego,
+            &ego->ctx,
+            ego->name);
+  GNUNET_free (op);
 }
 
 
 /**
- * Try again to connect to network size estimation service.
+ * Try again to connect to the identity service.
  *
- * @param cls the handle to the transport service
- * @param tc scheduler context
+ * @param cls handle to the identity service.
  */
 static void
-reconnect (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+reconnect (void *cls)
 {
   struct GNUNET_IDENTITY_Handle *h = cls;
-  struct GNUNET_IDENTITY_Operation *op;
-  struct GNUNET_MessageHeader msg;
-
-  h->reconnect_task = GNUNET_SCHEDULER_NO_TASK;
+  struct GNUNET_MQ_MessageHandler handlers[] = {
+    GNUNET_MQ_hd_var_size (identity_result_code,
+                           GNUNET_MESSAGE_TYPE_IDENTITY_RESULT_CODE,
+                           struct ResultCodeMessage,
+                           h),
+    GNUNET_MQ_hd_var_size (identity_update,
+                           GNUNET_MESSAGE_TYPE_IDENTITY_UPDATE,
+                           struct UpdateMessage,
+                           h),
+    GNUNET_MQ_hd_var_size (identity_set_default,
+                           GNUNET_MESSAGE_TYPE_IDENTITY_SET_DEFAULT,
+                           struct SetDefaultMessage,
+                           h),
+    GNUNET_MQ_handler_end ()
+  };
+  struct GNUNET_MQ_Envelope *env;
+  struct GNUNET_MessageHeader *msg;
+
+  h->reconnect_task = NULL;
   LOG (GNUNET_ERROR_TYPE_DEBUG,
        "Connecting to identity service.\n");
-  GNUNET_assert (NULL == h->client);
-  h->client = GNUNET_CLIENT_connect ("identity", h->cfg);
-  GNUNET_assert (NULL != h->client);
-  op = GNUNET_malloc (sizeof (struct GNUNET_IDENTITY_Operation) + 
-		      sizeof (struct GNUNET_MessageHeader));
-  op->h = h;
-  op->msg = (const struct GNUNET_MessageHeader *) &op[1];
-  msg.size = htons (sizeof (msg));
-  msg.type = htons (GNUNET_MESSAGE_TYPE_IDENTITY_START);
-  memcpy (&op[1], &msg, sizeof (msg));
-  GNUNET_CONTAINER_DLL_insert (h->op_head,
-			       h->op_tail,
-			       op);
-  transmit_next (h);
-  GNUNET_assert (NULL != h->th);
+  GNUNET_assert (NULL == h->mq);
+  h->mq = GNUNET_CLIENT_connect (h->cfg,
+                                 "identity",
+                                 handlers,
+                                 &mq_error_handler,
+                                 h);
+  if (NULL == h->mq)
+    return;
+  env = GNUNET_MQ_msg (msg,
+                       GNUNET_MESSAGE_TYPE_IDENTITY_START);
+  GNUNET_MQ_send (h->mq,
+                  env);
 }
 
 
@@ -544,7 +592,7 @@ reconnect (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
  *
  * @param cfg the configuration to use
  * @param cb function to call on all identity events, can be NULL
- * @param cb_cls closure for 'cb'
+ * @param cb_cls closure for @a cb
  * @return handle to use
  */
 struct GNUNET_IDENTITY_Handle *
@@ -554,12 +602,17 @@ GNUNET_IDENTITY_connect (const struct GNUNET_CONFIGURATION_Handle *cfg,
 {
   struct GNUNET_IDENTITY_Handle *h;
 
-  h = GNUNET_malloc (sizeof (struct GNUNET_IDENTITY_Handle));
+  h = GNUNET_new (struct GNUNET_IDENTITY_Handle);
   h->cfg = cfg;
   h->cb = cb;
   h->cb_cls = cb_cls;
-  h->reconnect_delay = GNUNET_TIME_UNIT_ZERO;
-  h->reconnect_task = GNUNET_SCHEDULER_add_now (&reconnect, h);
+  h->egos = GNUNET_CONTAINER_multihashmap_create (16, GNUNET_YES);
+  reconnect (h);
+  if (NULL == h->mq)
+  {
+    GNUNET_free (h);
+    return NULL;
+  }
   return h;
 }
 
@@ -570,110 +623,289 @@ GNUNET_IDENTITY_connect (const struct GNUNET_CONFIGURATION_Handle *cfg,
  * @param ego the ego
  * @return associated ECC key, valid as long as the ego is valid
  */
-const struct GNUNET_CRYPTO_EccPrivateKey *
-GNUNET_IDENTITY_ego_get_key (struct GNUNET_IDENTITY_Ego *ego)
+const struct GNUNET_CRYPTO_EcdsaPrivateKey *
+GNUNET_IDENTITY_ego_get_private_key (const struct GNUNET_IDENTITY_Ego *ego)
 {
   return ego->pk;
 }
 
 
+/**
+ * Get the identifier (public key) of an ego.
+ *
+ * @param ego identity handle with the private key
+ * @param pk set to ego's public key
+ */
+void
+GNUNET_IDENTITY_ego_get_public_key (const struct GNUNET_IDENTITY_Ego *ego,
+				    struct GNUNET_CRYPTO_EcdsaPublicKey *pk)
+{
+  GNUNET_CRYPTO_ecdsa_key_get_public (ego->pk,
+                                      pk);
+}
+
+
 /**
  * Obtain the identity that is currently preferred/default
  * for a service.
  *
- * @param id identity service to query
+ * @param h identity service to query
  * @param service_name for which service is an identity wanted
  * @param cb function to call with the result (will only be called once)
- * @param cb_cls closure for cb
+ * @param cb_cls closure for @a cb
  * @return handle to abort the operation
  */
 struct GNUNET_IDENTITY_Operation *
-GNUNET_IDENTITY_get (struct GNUNET_IDENTITY_Handle *id,
+GNUNET_IDENTITY_get (struct GNUNET_IDENTITY_Handle *h,
 		     const char *service_name,
 		     GNUNET_IDENTITY_Callback cb,
 		     void *cb_cls)
 {
-  return NULL;
+  struct GNUNET_IDENTITY_Operation *op;
+  struct GNUNET_MQ_Envelope *env;
+  struct GetDefaultMessage *gdm;
+  size_t slen;
+
+  if (NULL == h->mq)
+    return NULL;
+  slen = strlen (service_name) + 1;
+  if (slen >= GNUNET_MAX_MESSAGE_SIZE - sizeof (struct GetDefaultMessage))
+  {
+    GNUNET_break (0);
+    return NULL;
+  }
+  op = GNUNET_new (struct GNUNET_IDENTITY_Operation);
+  op->h = h;
+  op->cb = cb;
+  op->cls = cb_cls;
+  GNUNET_CONTAINER_DLL_insert_tail (h->op_head,
+				    h->op_tail,
+				    op);
+  env = GNUNET_MQ_msg_extra (gdm,
+                             slen,
+                             GNUNET_MESSAGE_TYPE_IDENTITY_GET_DEFAULT);
+  gdm->name_len = htons (slen);
+  gdm->reserved = htons (0);
+  GNUNET_memcpy (&gdm[1],
+          service_name,
+          slen);
+  GNUNET_MQ_send (h->mq,
+                  env);
+  return op;
 }
 
 
 /**
  * Set the preferred/default identity for a service.
  *
- * @param id identity service to inform
+ * @param h identity service to inform
  * @param service_name for which service is an identity set
  * @param ego new default identity to be set for this service
  * @param cont function to call once the operation finished
- * @param cont_cls closure for cont
+ * @param cont_cls closure for @a cont
  * @return handle to abort the operation
  */
 struct GNUNET_IDENTITY_Operation *
-GNUNET_IDENTITY_set (struct GNUNET_IDENTITY_Handle *id,
+GNUNET_IDENTITY_set (struct GNUNET_IDENTITY_Handle *h,
 		     const char *service_name,
 		     struct GNUNET_IDENTITY_Ego *ego,
 		     GNUNET_IDENTITY_Continuation cont,
 		     void *cont_cls)
 {
-  return NULL;
+  struct GNUNET_IDENTITY_Operation *op;
+  struct GNUNET_MQ_Envelope *env;
+  struct SetDefaultMessage *sdm;
+  size_t slen;
+
+  if (NULL == h->mq)
+    return NULL;
+  slen = strlen (service_name) + 1;
+  if (slen >= GNUNET_MAX_MESSAGE_SIZE - sizeof (struct SetDefaultMessage))
+  {
+    GNUNET_break (0);
+    return NULL;
+  }
+  op = GNUNET_new (struct GNUNET_IDENTITY_Operation);
+  op->h = h;
+  op->cont = cont;
+  op->cls = cont_cls;
+  GNUNET_CONTAINER_DLL_insert_tail (h->op_head,
+				    h->op_tail,
+				    op);
+  env = GNUNET_MQ_msg_extra (sdm,
+                             slen,
+                             GNUNET_MESSAGE_TYPE_IDENTITY_SET_DEFAULT);
+  sdm->name_len = htons (slen);
+  sdm->reserved = htons (0);
+  sdm->private_key = *ego->pk;
+  GNUNET_memcpy (&sdm[1],
+          service_name,
+          slen);
+  GNUNET_MQ_send (h->mq,
+                  env);
+  return op;
 }
 
 
-/** 
- * Create a new identity with the given identifier.
+/**
+ * Create a new identity with the given name.
  *
- * @param id identity service to use
- * @param identifier desired identifier
- * @param cb function to call with the result (will only be called once)
- * @param cb_cls closure for cb
+ * @param h identity service to use
+ * @param name desired name
+ * @param cont function to call with the result (will only be called once)
+ * @param cont_cls closure for @a cont
  * @return handle to abort the operation
  */
 struct GNUNET_IDENTITY_Operation *
-GNUNET_IDENTITY_create (struct GNUNET_IDENTITY_Handle *id,
-			const char *identifier,
-			GNUNET_IDENTITY_Callback cb,
-			void *cb_cls)
+GNUNET_IDENTITY_create (struct GNUNET_IDENTITY_Handle *h,
+			const char *name,
+			GNUNET_IDENTITY_Continuation cont,
+			void *cont_cls)
 {
-  return NULL;
+  struct GNUNET_IDENTITY_Operation *op;
+  struct GNUNET_MQ_Envelope *env;
+  struct CreateRequestMessage *crm;
+  struct GNUNET_CRYPTO_EcdsaPrivateKey *pk;
+  size_t slen;
+
+  if (NULL == h->mq)
+    return NULL;
+  slen = strlen (name) + 1;
+  if (slen >= GNUNET_MAX_MESSAGE_SIZE - sizeof (struct CreateRequestMessage))
+  {
+    GNUNET_break (0);
+    return NULL;
+  }
+  op = GNUNET_new (struct GNUNET_IDENTITY_Operation);
+  op->h = h;
+  op->cont = cont;
+  op->cls = cont_cls;
+  GNUNET_CONTAINER_DLL_insert_tail (h->op_head,
+				    h->op_tail,
+				    op);
+  env = GNUNET_MQ_msg_extra (crm,
+                             slen,
+                             GNUNET_MESSAGE_TYPE_IDENTITY_CREATE);
+  crm->name_len = htons (slen);
+  crm->reserved = htons (0);
+  pk = GNUNET_CRYPTO_ecdsa_key_create ();
+  crm->private_key = *pk;
+  GNUNET_free (pk);
+  GNUNET_memcpy (&crm[1],
+          name,
+          slen);
+  GNUNET_MQ_send (h->mq,
+                  env);
+  return op;
 }
 
 
-/** 
+/**
  * Renames an existing identity.
  *
- * @param id identity service to use
- * @param old_identifier old identifier
- * @param new_identifier desired new identifier
+ * @param h identity service to use
+ * @param old_name old name
+ * @param new_name desired new name
  * @param cb function to call with the result (will only be called once)
- * @param cb_cls closure for cb
+ * @param cb_cls closure for @a cb
  * @return handle to abort the operation
  */
 struct GNUNET_IDENTITY_Operation *
-GNUNET_IDENTITY_rename (struct GNUNET_IDENTITY_Handle *id,
-			const char *old_identifier,
-			const char *new_identifier,
+GNUNET_IDENTITY_rename (struct GNUNET_IDENTITY_Handle *h,
+			const char *old_name,
+			const char *new_name,
 			GNUNET_IDENTITY_Continuation cb,
 			void *cb_cls)
 {
-  return NULL;
+  struct GNUNET_IDENTITY_Operation *op;
+  struct GNUNET_MQ_Envelope *env;
+  struct RenameMessage *grm;
+  size_t slen_old;
+  size_t slen_new;
+  char *dst;
+
+  if (NULL == h->mq)
+    return NULL;
+  slen_old = strlen (old_name) + 1;
+  slen_new = strlen (new_name) + 1;
+  if ( (slen_old >= GNUNET_MAX_MESSAGE_SIZE) ||
+       (slen_new >= GNUNET_MAX_MESSAGE_SIZE) ||
+       (slen_old + slen_new >= GNUNET_MAX_MESSAGE_SIZE - sizeof (struct RenameMessage)) )
+  {
+    GNUNET_break (0);
+    return NULL;
+  }
+  op = GNUNET_new (struct GNUNET_IDENTITY_Operation);
+  op->h = h;
+  op->cont = cb;
+  op->cls = cb_cls;
+  GNUNET_CONTAINER_DLL_insert_tail (h->op_head,
+				    h->op_tail,
+				    op);
+  env = GNUNET_MQ_msg_extra (grm,
+                             slen_old + slen_new,
+                             GNUNET_MESSAGE_TYPE_IDENTITY_RENAME);
+  grm->old_name_len = htons (slen_old);
+  grm->new_name_len = htons (slen_new);
+  dst = (char *) &grm[1];
+  GNUNET_memcpy (dst,
+          old_name,
+          slen_old);
+  GNUNET_memcpy (&dst[slen_old],
+          new_name,
+          slen_new);
+  GNUNET_MQ_send (h->mq,
+                  env);
+  return op;
 }
 
 
-/** 
+/**
  * Delete an existing identity.
  *
- * @param id identity service to use
- * @param identifier identifier of the identity to delete
+ * @param h identity service to use
+ * @param name name of the identity to delete
  * @param cb function to call with the result (will only be called once)
- * @param cb_cls closure for cb
+ * @param cb_cls closure for @a cb
  * @return handle to abort the operation
  */
 struct GNUNET_IDENTITY_Operation *
-GNUNET_IDENTITY_delete (struct GNUNET_IDENTITY_Handle *id,
-			const char *identifier,
+GNUNET_IDENTITY_delete (struct GNUNET_IDENTITY_Handle *h,
+			const char *name,
 			GNUNET_IDENTITY_Continuation cb,
 			void *cb_cls)
 {
-  return NULL;
+  struct GNUNET_IDENTITY_Operation *op;
+  struct GNUNET_MQ_Envelope *env;
+  struct DeleteMessage *gdm;
+  size_t slen;
+
+  if (NULL == h->mq)
+    return NULL;
+  slen = strlen (name) + 1;
+  if (slen >= GNUNET_MAX_MESSAGE_SIZE - sizeof (struct DeleteMessage))
+  {
+    GNUNET_break (0);
+    return NULL;
+  }
+  op = GNUNET_new (struct GNUNET_IDENTITY_Operation);
+  op->h = h;
+  op->cont = cb;
+  op->cls = cb_cls;
+  GNUNET_CONTAINER_DLL_insert_tail (h->op_head,
+				    h->op_tail,
+				    op);
+  env = GNUNET_MQ_msg_extra (gdm,
+                             slen,
+                             GNUNET_MESSAGE_TYPE_IDENTITY_DELETE);
+  gdm->name_len = htons (slen);
+  gdm->reserved = htons (0);
+  GNUNET_memcpy (&gdm[1],
+          name,
+          slen);
+  GNUNET_MQ_send (h->mq,
+                  env);
+  return op;
 }
 
 
@@ -686,33 +918,8 @@ GNUNET_IDENTITY_delete (struct GNUNET_IDENTITY_Handle *id,
  * @param op operation to cancel
  */
 void
-GNUNET_IDENITY_cancel (struct GNUNET_IDENTITY_Operation *op)
+GNUNET_IDENTITY_cancel (struct GNUNET_IDENTITY_Operation *op)
 {
-  struct GNUNET_IDENTITY_Handle *h = op->h;
-
-  if ( (h->op_head != op) ||
-       (NULL == h->client) )
-  {
-    /* request not active, can simply remove */
-    GNUNET_CONTAINER_DLL_remove (h->op_head,
-				 h->op_tail,
-				 op);
-    GNUNET_free (op);
-    return;
-  }
-  if (NULL != h->th)
-  {
-    /* request active but not yet with service, can still abort */
-    GNUNET_CLIENT_notify_transmit_ready_cancel (h->th);
-    h->th = NULL;
-    GNUNET_CONTAINER_DLL_remove (h->op_head,
-				 h->op_tail,
-				 op);
-    GNUNET_free (op);
-    transmit_next (h);
-    return;
-  }
-  /* request active with service, simply ensure continuations are not called */
   op->cont = NULL;
   op->cb = NULL;
 }
@@ -726,21 +933,34 @@ GNUNET_IDENITY_cancel (struct GNUNET_IDENTITY_Operation *op)
 void
 GNUNET_IDENTITY_disconnect (struct GNUNET_IDENTITY_Handle *h)
 {
+  struct GNUNET_IDENTITY_Operation *op;
+
   GNUNET_assert (NULL != h);
-  if (h->reconnect_task != GNUNET_SCHEDULER_NO_TASK)
+  if (h->reconnect_task != NULL)
   {
     GNUNET_SCHEDULER_cancel (h->reconnect_task);
-    h->reconnect_task = GNUNET_SCHEDULER_NO_TASK;
+    h->reconnect_task = NULL;
+  }
+  if (NULL != h->egos)
+  {
+    GNUNET_CONTAINER_multihashmap_iterate (h->egos,
+					   &free_ego,
+					   h);
+    GNUNET_CONTAINER_multihashmap_destroy (h->egos);
+    h->egos = NULL;
   }
-  if (NULL != h->th)
+  while (NULL != (op = h->op_head))
   {
-    GNUNET_CLIENT_notify_transmit_ready_cancel (h->th);
-    h->th = NULL;
+    GNUNET_break (NULL == op->cont);
+    GNUNET_CONTAINER_DLL_remove (h->op_head,
+				 h->op_tail,
+				 op);
+    GNUNET_free (op);
   }
-  if (NULL != h->client)
+  if (NULL != h->mq)
   {
-    GNUNET_CLIENT_disconnect (h->client);
-    h->client = NULL;
+    GNUNET_MQ_destroy (h->mq);
+    h->mq = NULL;
   }
   GNUNET_free (h);
 }