-getting core, nse, testbed, ats-tool and peerinfo-tool to compile again (part of #3047)

18 files changed, 196 insertions, 202 deletions

diff --git a/src/ats-tool/gnunet-ats.c b/src/ats-tool/gnunet-ats.c
index b42b7f372..710931321 100644
--- a/src/ats-tool/gnunet-ats.c
+++ b/src/ats-tool/gnunet-ats.c
@@ -352,7 +352,9 @@ testservice_ats (void *cls,
 
   if (NULL != pid_str)
   {
-    if (GNUNET_OK != GNUNET_CRYPTO_hash_from_string (pid_str, &pid.hashPubKey))
+    if (GNUNET_OK != GNUNET_CRYPTO_ecc_public_sign_key_from_string (pid_str,
+                                                                    strlen (pid_str),
+                                                                    &pid.public_key))
     {
       FPRINTF (stderr, _("Failed to parse peer identity `%s'\n"), pid_str);
       return;
diff --git a/src/core/core_api.c b/src/core/core_api.c
index 959eb275a..8b9389bdf 100644
--- a/src/core/core_api.c
+++ b/src/core/core_api.c
@@ -277,7 +277,7 @@ struct GNUNET_CORE_Handle
    * Hash map listing all of the peers that we are currently
    * connected to.
    */
-  struct GNUNET_CONTAINER_MultiHashMap *peers;
+  struct GNUNET_CONTAINER_MultiPeerMap *peers;
 
   /**
    * Identity of this peer.
@@ -357,7 +357,8 @@ reconnect_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
  * @return #GNUNET_YES (continue)
  */
 static int
-disconnect_and_free_peer_entry (void *cls, const struct GNUNET_HashCode * key,
+disconnect_and_free_peer_entry (void *cls, 
+                                const struct GNUNET_PeerIdentity *key,
                                 void *value)
 {
   struct GNUNET_CORE_Handle *h = cls;
@@ -389,7 +390,7 @@ disconnect_and_free_peer_entry (void *cls, const struct GNUNET_HashCode * key,
   }
   /* done with 'voluntary' cleanups, now on to normal freeing */
   GNUNET_assert (GNUNET_YES ==
-                 GNUNET_CONTAINER_multihashmap_remove (h->peers, key, pr));
+                 GNUNET_CONTAINER_multipeermap_remove (h->peers, key, pr));
   GNUNET_assert (pr->ch == h);
   GNUNET_assert (GNUNET_SCHEDULER_NO_TASK == pr->timeout_task);
   GNUNET_assert (GNUNET_SCHEDULER_NO_TASK == pr->ntr_task);
@@ -435,7 +436,7 @@ reconnect_later (struct GNUNET_CORE_Handle *h)
       cm->cont (cm->cont_cls, GNUNET_NO);
     GNUNET_free (cm);
   }
-  GNUNET_CONTAINER_multihashmap_iterate (h->peers,
+  GNUNET_CONTAINER_multipeermap_iterate (h->peers,
                                          &disconnect_and_free_peer_entry, h);
   while (NULL != (pr = h->ready_peer_head))
     GNUNET_CONTAINER_DLL_remove (h->ready_peer_head, h->ready_peer_tail, pr);
@@ -790,14 +791,14 @@ main_notify_handler (void *cls, const struct GNUNET_MessageHeader *msg)
            "Successfully reconnected to core service.\n");
     }
     /* fake 'connect to self' */
-    pr = GNUNET_CONTAINER_multihashmap_get (h->peers, &h->me.hashPubKey);
+    pr = GNUNET_CONTAINER_multipeermap_get (h->peers, &h->me);
     GNUNET_assert (NULL == pr);
     pr = GNUNET_new (struct PeerRecord);
     pr->peer = h->me;
     pr->ch = h;
     GNUNET_assert (GNUNET_YES ==
-                   GNUNET_CONTAINER_multihashmap_put (h->peers,
-                                                      &h->me.hashPubKey, pr,
+                   GNUNET_CONTAINER_multipeermap_put (h->peers,
+                                                      &h->me, pr,
                                                       GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST));
     if (NULL != h->connects)
       h->connects (h->cls, &h->me);
@@ -826,7 +827,7 @@ main_notify_handler (void *cls, const struct GNUNET_MessageHeader *msg)
       GNUNET_break (0);
       return;
     }
-    pr = GNUNET_CONTAINER_multihashmap_get (h->peers, &cnm->peer.hashPubKey);
+    pr = GNUNET_CONTAINER_multipeermap_get (h->peers, &cnm->peer);
     if (NULL != pr)
     {
       GNUNET_break (0);
@@ -837,8 +838,8 @@ main_notify_handler (void *cls, const struct GNUNET_MessageHeader *msg)
     pr->peer = cnm->peer;
     pr->ch = h;
     GNUNET_assert (GNUNET_YES ==
-                   GNUNET_CONTAINER_multihashmap_put (h->peers,
-                                                      &cnm->peer.hashPubKey, pr,
+                   GNUNET_CONTAINER_multipeermap_put (h->peers,
+                                                      &cnm->peer, pr,
                                                       GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST));
     if (NULL != h->connects)
       h->connects (h->cls, &cnm->peer);
@@ -861,7 +862,7 @@ main_notify_handler (void *cls, const struct GNUNET_MessageHeader *msg)
     LOG (GNUNET_ERROR_TYPE_DEBUG,
          "Received notification about disconnect from `%s'.\n",
          GNUNET_i2s (&dnm->peer));
-    pr = GNUNET_CONTAINER_multihashmap_get (h->peers, &dnm->peer.hashPubKey);
+    pr = GNUNET_CONTAINER_multipeermap_get (h->peers, &dnm->peer);
     if (NULL == pr)
     {
       GNUNET_break (0);
@@ -870,7 +871,7 @@ main_notify_handler (void *cls, const struct GNUNET_MessageHeader *msg)
     }
     trigger = ((pr->prev != NULL) || (pr->next != NULL) ||
                (h->ready_peer_head == pr));
-    disconnect_and_free_peer_entry (h, &dnm->peer.hashPubKey, pr);
+    disconnect_and_free_peer_entry (h, &dnm->peer, pr);
     if (trigger)
       trigger_next_request (h, GNUNET_NO);
     break;
@@ -916,7 +917,7 @@ main_notify_handler (void *cls, const struct GNUNET_MessageHeader *msg)
         GNUNET_break_op (0);
         continue;
       }
-      pr = GNUNET_CONTAINER_multihashmap_get (h->peers, &ntm->peer.hashPubKey);
+      pr = GNUNET_CONTAINER_multipeermap_get (h->peers, &ntm->peer);
       if (NULL == pr)
       {
         GNUNET_break (0);
@@ -976,7 +977,7 @@ main_notify_handler (void *cls, const struct GNUNET_MessageHeader *msg)
       return;
     }
     smr = (const struct SendMessageReady *) msg;
-    pr = GNUNET_CONTAINER_multihashmap_get (h->peers, &smr->peer.hashPubKey);
+    pr = GNUNET_CONTAINER_multipeermap_get (h->peers, &smr->peer);
     if (NULL == pr)
     {
       GNUNET_break (0);
@@ -1157,7 +1158,7 @@ GNUNET_CORE_connect (const struct GNUNET_CONFIGURATION_Handle *cfg,
   h->handlers = handlers;
   h->hcnt = 0;
   h->currently_down = GNUNET_YES;
-  h->peers = GNUNET_CONTAINER_multihashmap_create (128, GNUNET_NO);
+  h->peers = GNUNET_CONTAINER_multipeermap_create (128, GNUNET_NO);
   if (NULL != handlers)
     while (handlers[h->hcnt].callback != NULL)
       h->hcnt++;
@@ -1205,7 +1206,7 @@ GNUNET_CORE_disconnect (struct GNUNET_CORE_Handle *handle)
     GNUNET_CLIENT_disconnect (handle->client);
     handle->client = NULL;
   }
-  GNUNET_CONTAINER_multihashmap_iterate (handle->peers,
+  GNUNET_CONTAINER_multipeermap_iterate (handle->peers,
                                          &disconnect_and_free_peer_entry,
                                          handle);
   if (handle->reconnect_task != GNUNET_SCHEDULER_NO_TASK)
@@ -1213,7 +1214,7 @@ GNUNET_CORE_disconnect (struct GNUNET_CORE_Handle *handle)
     GNUNET_SCHEDULER_cancel (handle->reconnect_task);
     handle->reconnect_task = GNUNET_SCHEDULER_NO_TASK;
   }
-  GNUNET_CONTAINER_multihashmap_destroy (handle->peers);
+  GNUNET_CONTAINER_multipeermap_destroy (handle->peers);
   handle->peers = NULL;
   GNUNET_break (handle->ready_peer_head == NULL);
   GNUNET_free (handle);
@@ -1287,7 +1288,7 @@ GNUNET_CORE_notify_transmit_ready (struct GNUNET_CORE_Handle *handle, int cork,
        "Asking core for transmission of %u bytes to `%s'\n",
        (unsigned int) notify_size,
        GNUNET_i2s (target));
-  pr = GNUNET_CONTAINER_multihashmap_get (handle->peers, &target->hashPubKey);
+  pr = GNUNET_CONTAINER_multipeermap_get (handle->peers, target);
   if (NULL == pr)
   {
     /* attempt to send to peer that is not connected */
@@ -1382,7 +1383,7 @@ GNUNET_CORE_is_peer_connected_sync (const struct GNUNET_CORE_Handle *h,
 {
   GNUNET_assert (NULL != h);
   GNUNET_assert (NULL != pid);
-  return GNUNET_CONTAINER_multihashmap_contains (h->peers, &pid->hashPubKey);
+  return GNUNET_CONTAINER_multipeermap_contains (h->peers, pid);
 }
 
 
diff --git a/src/core/gnunet-core.c b/src/core/gnunet-core.c
index 9bfd18ec9..cfdae33bf 100644
--- a/src/core/gnunet-core.c
+++ b/src/core/gnunet-core.c
@@ -75,12 +75,10 @@ static void
 connected_peer_callback (void *cls, 
                          const struct GNUNET_PeerIdentity *peer)
 {
-  struct GNUNET_CRYPTO_HashAsciiEncoded enc;
-
   if (NULL == peer)
     return;
-  GNUNET_CRYPTO_hash_to_enc (&peer->hashPubKey, &enc);
-  printf (_("Peer `%s'\n"), (const char *) &enc);
+  printf (_("Peer `%s'\n"),
+          GNUNET_i2s_full (peer));
 }
 
 
diff --git a/src/core/gnunet-service-core_clients.c b/src/core/gnunet-service-core_clients.c
index 7514da8a2..bcbb56ef3 100644
--- a/src/core/gnunet-service-core_clients.c
+++ b/src/core/gnunet-service-core_clients.c
@@ -73,12 +73,12 @@ struct GSC_Client
    * Map of peer identities to active transmission requests of this
    * client to the peer (of type 'struct GSC_ClientActiveRequest').
    */
-  struct GNUNET_CONTAINER_MultiHashMap *requests;
+  struct GNUNET_CONTAINER_MultiPeerMap *requests;
 
   /**
    * Map containing all peers that this client knows we're connected to.
    */
-  struct GNUNET_CONTAINER_MultiHashMap *connectmap;
+  struct GNUNET_CONTAINER_MultiPeerMap *connectmap;
 
   /**
    * Options for messages this client cares about,
@@ -247,8 +247,8 @@ send_to_all_clients (const struct GNUNET_PeerIdentity *partner,
     GNUNET_assert ( (0 == (c->options & GNUNET_CORE_OPTION_SEND_FULL_INBOUND)) ||
                     (GNUNET_YES != tm) ||
                     (GNUNET_YES ==
-                     GNUNET_CONTAINER_multihashmap_contains (c->connectmap,
-                                                             &partner->hashPubKey)) );
+                     GNUNET_CONTAINER_multipeermap_contains (c->connectmap,
+                                                             partner)) );
     send_to_client (c, msg, can_drop);
   }
 }
@@ -298,10 +298,10 @@ handle_client_init (void *cls, struct GNUNET_SERVER_Client *client,
   c->options = ntohl (im->options);
   all_client_options |= c->options;
   c->types = (const uint16_t *) &c[1];
-  c->connectmap = GNUNET_CONTAINER_multihashmap_create (16, GNUNET_NO);
+  c->connectmap = GNUNET_CONTAINER_multipeermap_create (16, GNUNET_NO);
   GNUNET_assert (GNUNET_YES ==
-                 GNUNET_CONTAINER_multihashmap_put (c->connectmap,
-                                                    &GSC_my_identity.hashPubKey,
+                 GNUNET_CONTAINER_multipeermap_put (c->connectmap,
+                                                    &GSC_my_identity,
                                                     NULL,
                                                     GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
   wtypes = (uint16_t *) & c[1];
@@ -349,7 +349,7 @@ handle_client_send_request (void *cls, struct GNUNET_SERVER_Client *client,
     return;
   }
   if (c->requests == NULL)
-    c->requests = GNUNET_CONTAINER_multihashmap_create (16, GNUNET_NO);
+    c->requests = GNUNET_CONTAINER_multipeermap_create (16, GNUNET_NO);
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "Client asked for transmission to `%s'\n",
               GNUNET_i2s (&req->peer));
@@ -359,8 +359,8 @@ handle_client_send_request (void *cls, struct GNUNET_SERVER_Client *client,
                sizeof (struct GNUNET_PeerIdentity)));
   if ((!is_loopback) &&
       (GNUNET_YES !=
-       GNUNET_CONTAINER_multihashmap_contains (c->connectmap,
-                                               &req->peer.hashPubKey)))
+       GNUNET_CONTAINER_multipeermap_contains (c->connectmap,
+                                               &req->peer)))
   {
     /* neighbour must have disconnected since request was issued,
      * ignore (client will realize it once it processes the
@@ -373,14 +373,14 @@ handle_client_send_request (void *cls, struct GNUNET_SERVER_Client *client,
     return;
   }
 
-  car = GNUNET_CONTAINER_multihashmap_get (c->requests, &req->peer.hashPubKey);
+  car = GNUNET_CONTAINER_multipeermap_get (c->requests, &req->peer);
   if (car == NULL)
   {
     /* create new entry */
     car = GNUNET_malloc (sizeof (struct GSC_ClientActiveRequest));
     GNUNET_assert (GNUNET_OK ==
-                   GNUNET_CONTAINER_multihashmap_put (c->requests,
-                                                      &req->peer.hashPubKey,
+                   GNUNET_CONTAINER_multipeermap_put (c->requests,
+                                                      &req->peer,
                                                       car,
                                                       GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST));
     car->client_handle = c;
@@ -462,7 +462,7 @@ handle_client_send (void *cls, struct GNUNET_SERVER_Client *client,
     return;
   }
   tc.car =
-      GNUNET_CONTAINER_multihashmap_get (c->requests, &sm->peer.hashPubKey);
+      GNUNET_CONTAINER_multipeermap_get (c->requests, &sm->peer);
   if (NULL == tc.car)
   {
     /* Must have been that we first approved the request, then got disconnected
@@ -478,8 +478,8 @@ handle_client_send (void *cls, struct GNUNET_SERVER_Client *client,
     return;
   }
   GNUNET_assert (GNUNET_YES ==
-                 GNUNET_CONTAINER_multihashmap_remove (c->requests,
-                                                       &sm->peer.hashPubKey,
+                 GNUNET_CONTAINER_multipeermap_remove (c->requests,
+                                                       &sm->peer,
                                                        tc.car));
   tc.cork = ntohl (sm->cork);
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
@@ -561,18 +561,19 @@ client_tokenizer_callback (void *cls, void *client,
  * @param cls NULL
  * @param key identity of peer for which this is an active request
  * @param value the 'struct GSC_ClientActiveRequest' to free
- * @return GNUNET_YES (continue iteration)
+ * @return #GNUNET_YES (continue iteration)
  */
 static int
-destroy_active_client_request (void *cls, const struct GNUNET_HashCode * key,
+destroy_active_client_request (void *cls, 
+                               const struct GNUNET_PeerIdentity *key,
                                void *value)
 {
   struct GSC_ClientActiveRequest *car = value;
 
   GNUNET_assert (GNUNET_YES ==
-                 GNUNET_CONTAINER_multihashmap_remove (car->
+                 GNUNET_CONTAINER_multipeermap_remove (car->
                                                        client_handle->requests,
-                                                       &car->target.hashPubKey,
+                                                       &car->target,
                                                        car));
   GSC_SESSIONS_dequeue_request (car);
   GNUNET_free (car);
@@ -601,12 +602,12 @@ handle_client_disconnect (void *cls, struct GNUNET_SERVER_Client *client)
   GNUNET_CONTAINER_DLL_remove (client_head, client_tail, c);
   if (c->requests != NULL)
   {
-    GNUNET_CONTAINER_multihashmap_iterate (c->requests,
+    GNUNET_CONTAINER_multipeermap_iterate (c->requests,
                                            &destroy_active_client_request,
                                            NULL);
-    GNUNET_CONTAINER_multihashmap_destroy (c->requests);
+    GNUNET_CONTAINER_multipeermap_destroy (c->requests);
   }
-  GNUNET_CONTAINER_multihashmap_destroy (c->connectmap);
+  GNUNET_CONTAINER_multipeermap_destroy (c->connectmap);
   c->connectmap = NULL;
   GSC_TYPEMAP_remove (c->types, c->tcnt);
   GNUNET_free (c);
@@ -633,8 +634,8 @@ GSC_CLIENTS_solicit_request (struct GSC_ClientActiveRequest *car)
 
   c = car->client_handle;
   if (GNUNET_YES !=
-      GNUNET_CONTAINER_multihashmap_contains (c->connectmap,
-                                              &car->target.hashPubKey))
+      GNUNET_CONTAINER_multipeermap_contains (c->connectmap,
+                                              &car->target))
   {
     /* connection has gone down since, drop request */
     GNUNET_assert (0 !=
@@ -665,9 +666,9 @@ void
 GSC_CLIENTS_reject_request (struct GSC_ClientActiveRequest *car)
 {
   GNUNET_assert (GNUNET_YES ==
-                 GNUNET_CONTAINER_multihashmap_remove (car->
+                 GNUNET_CONTAINER_multipeermap_remove (car->
                                                        client_handle->requests,
-                                                       &car->target.hashPubKey,
+                                                       &car->target,
                                                        car));
   GNUNET_free (car);
 }
@@ -702,19 +703,19 @@ GSC_CLIENTS_notify_client_about_neighbour (struct GSC_Client *client,
   if (old_match == new_match)
   {
     GNUNET_assert (old_match ==
-                   GNUNET_CONTAINER_multihashmap_contains (client->connectmap,
-                                                           &neighbour->hashPubKey));
+                   GNUNET_CONTAINER_multipeermap_contains (client->connectmap,
+                                                           neighbour));
     return;                     /* no change */
   }
   if (old_match == GNUNET_NO)
   {
     /* send connect */
     GNUNET_assert (GNUNET_NO ==
-                   GNUNET_CONTAINER_multihashmap_contains (client->connectmap,
-                                                           &neighbour->hashPubKey));
+                   GNUNET_CONTAINER_multipeermap_contains (client->connectmap,
+                                                           neighbour));
     GNUNET_assert (GNUNET_YES ==
-                   GNUNET_CONTAINER_multihashmap_put (client->connectmap,
-                                                      &neighbour->hashPubKey,
+                   GNUNET_CONTAINER_multipeermap_put (client->connectmap,
+                                                      neighbour,
                                                       NULL,
                                                       GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
     size = sizeof (struct ConnectNotifyMessage);
@@ -731,11 +732,11 @@ GSC_CLIENTS_notify_client_about_neighbour (struct GSC_Client *client,
   {
     /* send disconnect */
     GNUNET_assert (GNUNET_YES ==
-                   GNUNET_CONTAINER_multihashmap_contains (client->connectmap,
-                                                           &neighbour->hashPubKey));
+                   GNUNET_CONTAINER_multipeermap_contains (client->connectmap,
+                                                           neighbour));
     GNUNET_assert (GNUNET_YES ==
-                   GNUNET_CONTAINER_multihashmap_remove (client->connectmap,
-                                                         &neighbour->hashPubKey,
+                   GNUNET_CONTAINER_multipeermap_remove (client->connectmap,
+                                                         neighbour,
                                                          NULL));
     dcm.header.size = htons (sizeof (struct DisconnectNotifyMessage));
     dcm.header.type = htons (GNUNET_MESSAGE_TYPE_CORE_NOTIFY_DISCONNECT);
diff --git a/src/core/gnunet-service-core_kx.c b/src/core/gnunet-service-core_kx.c
index 675ac83a6..bf3c5cdaf 100644
--- a/src/core/gnunet-service-core_kx.c
+++ b/src/core/gnunet-service-core_kx.c
@@ -116,7 +116,7 @@ struct EphemeralKeyMessage
   /**
    * Public key of the signing peer (persistent version, not the ephemeral public key).
    */
-  struct GNUNET_CRYPTO_EccPublicSignKey origin_public_key;
+  struct GNUNET_PeerIdentity origin_identity;
 
 };
 
@@ -390,11 +390,6 @@ static struct GNUNET_CRYPTO_EccPrivateKey *my_ephemeral_key;
 static struct EphemeralKeyMessage current_ekm;
 
 /**
- * Our public key.
- */
-static struct GNUNET_CRYPTO_EccPublicSignKey my_public_key;
-
-/**
  * Our message stream tokenizer (for encrypted payload).
  */
 static struct GNUNET_SERVER_MessageStreamTokenizer *mst;
@@ -453,9 +448,9 @@ derive_iv (struct GNUNET_CRYPTO_SymmetricInitializationVector *iv,
   static const char ctx[] = "initialization vector";
 
   GNUNET_CRYPTO_symmetric_derive_iv (iv, skey, &seed, sizeof (seed),
-                               &identity->hashPubKey.bits,
-                               sizeof (identity->hashPubKey.bits), ctx,
-                               sizeof (ctx), NULL);
+                                     identity,
+                                     sizeof (struct GNUNET_PeerIdentity), ctx,
+                                     sizeof (ctx), NULL);
 }
 
 
@@ -476,9 +471,11 @@ derive_pong_iv (struct GNUNET_CRYPTO_SymmetricInitializationVector *iv,
   static const char ctx[] = "pong initialization vector";
 
   GNUNET_CRYPTO_symmetric_derive_iv (iv, skey, &seed, sizeof (seed),
-                               &identity->hashPubKey.bits,
-                               sizeof (identity->hashPubKey.bits), &challenge,
-                               sizeof (challenge), ctx, sizeof (ctx), NULL);
+                                     identity,
+                                     sizeof (struct GNUNET_PeerIdentity),
+                                     &challenge, sizeof (challenge), 
+                                     ctx, sizeof (ctx), 
+                                     NULL);
 }
 
 
@@ -661,6 +658,8 @@ struct GSC_KeyExchangeInfo *
 GSC_KX_start (const struct GNUNET_PeerIdentity *pid)
 {
   struct GSC_KeyExchangeInfo *kx;
+  struct GNUNET_HashCode h1;
+  struct GNUNET_HashCode h2;
 
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, 
               "Initiating key exchange with `%s'\n",
@@ -674,8 +673,11 @@ GSC_KX_start (const struct GNUNET_PeerIdentity *pid)
   GNUNET_CONTAINER_DLL_insert (kx_head,
                                kx_tail,
                                kx);
-  if (0 < GNUNET_CRYPTO_hash_cmp (&pid->hashPubKey,
-                                  &GSC_my_identity.hashPubKey))
+  GNUNET_CRYPTO_hash (pid, sizeof (struct GNUNET_PeerIdentity), &h1);
+  GNUNET_CRYPTO_hash (&GSC_my_identity, sizeof (struct GNUNET_PeerIdentity), &h2);
+                      
+  if (0 < GNUNET_CRYPTO_hash_cmp (&h1, 
+                                  &h2))
   {
     /* peer with "lower" identity starts KX, otherwise we typically end up
        with both peers starting the exchange and transmit the 'set key' 
@@ -742,7 +744,6 @@ GSC_KX_handle_ephemeral_key (struct GSC_KeyExchangeInfo *kx,
   struct GNUNET_TIME_Absolute start_t;
   struct GNUNET_TIME_Absolute end_t;
   struct GNUNET_TIME_Absolute now;
-  struct GNUNET_PeerIdentity signer_id;
   enum KxStateMachine sender_status;  
   uint16_t size;
   struct GNUNET_HashCode key_material;
@@ -772,11 +773,9 @@ GSC_KX_handle_ephemeral_key (struct GSC_KeyExchangeInfo *kx,
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "Core service receives `%s' request from `%4s'.\n", "EPHEMERAL_KEY",
               GNUNET_i2s (&kx->peer));
-  GNUNET_CRYPTO_hash (&m->origin_public_key,
-                      sizeof (struct GNUNET_CRYPTO_EccPublicSignKey),
-                      &signer_id.hashPubKey);
   if (0 !=
-      memcmp (&signer_id, &kx->peer,
+      memcmp (&m->origin_identity,
+              &kx->peer.public_key,
               sizeof (struct GNUNET_PeerIdentity)))
   {    
     GNUNET_break_op (0);
@@ -791,7 +790,7 @@ GSC_KX_handle_ephemeral_key (struct GSC_KeyExchangeInfo *kx,
       (GNUNET_OK !=
        GNUNET_CRYPTO_ecc_verify (GNUNET_SIGNATURE_PURPOSE_SET_ECC_KEY,
                                  &m->purpose,
-                                 &m->signature, &m->origin_public_key)))
+                                 &m->signature, &m->origin_identity.public_key)))
   {
     /* invalid signature */
     GNUNET_break_op (0);
@@ -1496,7 +1495,7 @@ sign_ephemeral_key ()
   }
   GNUNET_CRYPTO_ecc_key_get_public_for_encryption (my_ephemeral_key,
                                                    &current_ekm.ephemeral_key);
-  current_ekm.origin_public_key = my_public_key;
+  current_ekm.origin_identity = GSC_my_identity;
   GNUNET_assert (GNUNET_OK ==
                  GNUNET_CRYPTO_ecc_sign (my_private_key,
                                          &current_ekm.purpose,
@@ -1543,9 +1542,8 @@ GSC_KX_init (struct GNUNET_CRYPTO_EccPrivateKey *pk)
 {
   GNUNET_assert (NULL != pk);
   my_private_key = pk;
-  GNUNET_CRYPTO_ecc_key_get_public_for_signature (my_private_key, &my_public_key);
-  GNUNET_CRYPTO_hash (&my_public_key, sizeof (my_public_key),
-                      &GSC_my_identity.hashPubKey);
+  GNUNET_CRYPTO_ecc_key_get_public_for_signature (my_private_key, 
+                                                  &GSC_my_identity.public_key);
   if (GNUNET_YES ==
       GNUNET_CONFIGURATION_get_value_yesno (GSC_cfg,
                                             "core",
diff --git a/src/core/gnunet-service-core_neighbours.c b/src/core/gnunet-service-core_neighbours.c
index 3841986ac..d82d119d7 100644
--- a/src/core/gnunet-service-core_neighbours.c
+++ b/src/core/gnunet-service-core_neighbours.c
@@ -111,7 +111,7 @@ struct Neighbour
 /**
  * Map of peer identities to 'struct Neighbour'.
  */
-static struct GNUNET_CONTAINER_MultiHashMap *neighbours;
+static struct GNUNET_CONTAINER_MultiPeerMap *neighbours;
 
 /**
  * Transport service.
@@ -131,7 +131,7 @@ find_neighbour (const struct GNUNET_PeerIdentity *peer)
 {
   if (NULL == neighbours)
     return NULL;
-  return GNUNET_CONTAINER_multihashmap_get (neighbours, &peer->hashPubKey);
+  return GNUNET_CONTAINER_multipeermap_get (neighbours, peer);
 }
 
 
@@ -173,11 +173,11 @@ free_neighbour (struct Neighbour *n)
     n->retry_plaintext_task = GNUNET_SCHEDULER_NO_TASK;
   }
   GNUNET_assert (GNUNET_OK ==
-                 GNUNET_CONTAINER_multihashmap_remove (neighbours,
-                                                       &n->peer.hashPubKey, n));
+                 GNUNET_CONTAINER_multipeermap_remove (neighbours,
+                                                       &n->peer, n));
   GNUNET_STATISTICS_set (GSC_stats,
                          gettext_noop ("# neighbour entries allocated"),
-                         GNUNET_CONTAINER_multihashmap_size (neighbours),
+                         GNUNET_CONTAINER_multipeermap_size (neighbours),
                          GNUNET_NO);
   GNUNET_free (n);
 }
@@ -321,12 +321,12 @@ handle_transport_notify_connect (void *cls,
   n = GNUNET_malloc (sizeof (struct Neighbour));
   n->peer = *peer;
   GNUNET_assert (GNUNET_OK ==
-                 GNUNET_CONTAINER_multihashmap_put (neighbours,
-                                                    &n->peer.hashPubKey, n,
+                 GNUNET_CONTAINER_multipeermap_put (neighbours,
+                                                    &n->peer, n,
                                                     GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
   GNUNET_STATISTICS_set (GSC_stats,
                          gettext_noop ("# neighbour entries allocated"),
-                         GNUNET_CONTAINER_multihashmap_size (neighbours),
+                         GNUNET_CONTAINER_multipeermap_size (neighbours),
                          GNUNET_NO);
   n->kxinfo = GSC_KX_start (peer);
 }
@@ -454,7 +454,7 @@ GSC_NEIGHBOURS_transmit (const struct GNUNET_PeerIdentity *target,
 int
 GSC_NEIGHBOURS_init ()
 {
-  neighbours = GNUNET_CONTAINER_multihashmap_create (128, GNUNET_NO);
+  neighbours = GNUNET_CONTAINER_multipeermap_create (128, GNUNET_NO);
   transport =
       GNUNET_TRANSPORT_connect (GSC_cfg, &GSC_my_identity, NULL,
                                 &handle_transport_receive,
@@ -462,7 +462,7 @@ GSC_NEIGHBOURS_init ()
                                 &handle_transport_notify_disconnect);
   if (NULL == transport)
   {
-    GNUNET_CONTAINER_multihashmap_destroy (neighbours);
+    GNUNET_CONTAINER_multipeermap_destroy (neighbours);
     neighbours = NULL;
     return GNUNET_SYSERR;
   }
@@ -479,7 +479,9 @@ GSC_NEIGHBOURS_init ()
  * @return GNUNET_OK (continue to iterate)
  */
 static int
-free_neighbour_helper (void *cls, const struct GNUNET_HashCode * key, void *value)
+free_neighbour_helper (void *cls, 
+                       const struct GNUNET_PeerIdentity * key, 
+                       void *value)
 {
   struct Neighbour *n = value;
 
@@ -503,9 +505,9 @@ GSC_NEIGHBOURS_done ()
   }
   if (NULL != neighbours)
   {
-    GNUNET_CONTAINER_multihashmap_iterate (neighbours, &free_neighbour_helper,
+    GNUNET_CONTAINER_multipeermap_iterate (neighbours, &free_neighbour_helper,
                                            NULL);
-    GNUNET_CONTAINER_multihashmap_destroy (neighbours);
+    GNUNET_CONTAINER_multipeermap_destroy (neighbours);
     neighbours = NULL;
   }
 }
diff --git a/src/core/gnunet-service-core_sessions.c b/src/core/gnunet-service-core_sessions.c
index f1a53bee8..6c66086bd 100644
--- a/src/core/gnunet-service-core_sessions.c
+++ b/src/core/gnunet-service-core_sessions.c
@@ -147,7 +147,7 @@ struct Session
 /**
  * Map of peer identities to 'struct Session'.
  */
-static struct GNUNET_CONTAINER_MultiHashMap *sessions;
+static struct GNUNET_CONTAINER_MultiPeerMap *sessions;
 
 
 /**
@@ -160,7 +160,7 @@ static struct GNUNET_CONTAINER_MultiHashMap *sessions;
 static struct Session *
 find_session (const struct GNUNET_PeerIdentity *peer)
 {
-  return GNUNET_CONTAINER_multihashmap_get (sessions, &peer->hashPubKey);
+  return GNUNET_CONTAINER_multipeermap_get (sessions, peer);
 }
 
 
@@ -202,12 +202,11 @@ GSC_SESSIONS_end (const struct GNUNET_PeerIdentity *pid)
   GSC_CLIENTS_notify_clients_about_neighbour (&session->peer, 
                                               session->tmap, NULL);
   GNUNET_assert (GNUNET_YES ==
-                 GNUNET_CONTAINER_multihashmap_remove (sessions,
-                                                       &session->
-                                                       peer.hashPubKey,
+                 GNUNET_CONTAINER_multipeermap_remove (sessions,
+                                                       &session->peer,
                                                        session));
   GNUNET_STATISTICS_set (GSC_stats, gettext_noop ("# peers connected"),
-                         GNUNET_CONTAINER_multihashmap_size (sessions),
+                         GNUNET_CONTAINER_multipeermap_size (sessions),
                          GNUNET_NO);
   GSC_TYPEMAP_destroy (session->tmap);
   session->tmap = NULL;
@@ -273,11 +272,11 @@ GSC_SESSIONS_create (const struct GNUNET_PeerIdentity *peer,
   session->typemap_task =
       GNUNET_SCHEDULER_add_now (&transmit_typemap_task, session);
   GNUNET_assert (GNUNET_OK ==
-                 GNUNET_CONTAINER_multihashmap_put (sessions, &peer->hashPubKey,
+                 GNUNET_CONTAINER_multipeermap_put (sessions, peer,
                                                     session,
                                                     GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
   GNUNET_STATISTICS_set (GSC_stats, gettext_noop ("# peers connected"),
-                         GNUNET_CONTAINER_multihashmap_size (sessions),
+                         GNUNET_CONTAINER_multipeermap_size (sessions),
                          GNUNET_NO);
   GSC_CLIENTS_notify_clients_about_neighbour (peer,
                                               NULL, session->tmap);
@@ -293,7 +292,7 @@ GSC_SESSIONS_create (const struct GNUNET_PeerIdentity *peer,
  * @return GNUNET_OK (continue to iterate)
  */
 static int
-notify_client_about_session (void *cls, const struct GNUNET_HashCode * key,
+notify_client_about_session (void *cls, const struct GNUNET_PeerIdentity * key,
                              void *value)
 {
   struct GSC_Client *client = cls;
@@ -315,7 +314,7 @@ void
 GSC_SESSIONS_notify_client_about_sessions (struct GSC_Client *client)
 {
   /* notify new client about existing sessions */
-  GNUNET_CONTAINER_multihashmap_iterate (sessions, &notify_client_about_session,
+  GNUNET_CONTAINER_multipeermap_iterate (sessions, &notify_client_about_session,
                                          client);
 }
 
@@ -559,7 +558,7 @@ try_transmission (struct Session *session)
  * @return always GNUNET_OK
  */
 static int
-do_send_message (void *cls, const struct GNUNET_HashCode * key, void *value)
+do_send_message (void *cls, const struct GNUNET_PeerIdentity * key, void *value)
 {
   const struct GNUNET_MessageHeader *hdr = cls;
   struct Session *session = value;
@@ -586,7 +585,7 @@ GSC_SESSIONS_broadcast (const struct GNUNET_MessageHeader *msg)
 {
   if (NULL == sessions)
     return;
-  GNUNET_CONTAINER_multihashmap_iterate (sessions, &do_send_message,
+  GNUNET_CONTAINER_multipeermap_iterate (sessions, &do_send_message,
                                          (void *) msg);
 }
 
@@ -652,7 +651,7 @@ GSC_SESSIONS_transmit (struct GSC_ClientActiveRequest *car,
  */
 #include "core.h"
 static int
-queue_connect_message (void *cls, const struct GNUNET_HashCode * key, void *value)
+queue_connect_message (void *cls, const struct GNUNET_PeerIdentity * key, void *value)
 {
   struct GNUNET_SERVER_TransmitContext *tc = cls;
   struct Session *session = value;
@@ -687,7 +686,7 @@ GSC_SESSIONS_handle_client_iterate_peers (void *cls,
   struct GNUNET_SERVER_TransmitContext *tc;
 
   tc = GNUNET_SERVER_transmit_context_create (client);
-  GNUNET_CONTAINER_multihashmap_iterate (sessions, &queue_connect_message, tc);
+  GNUNET_CONTAINER_multipeermap_iterate (sessions, &queue_connect_message, tc);
   done_msg.size = htons (sizeof (struct GNUNET_MessageHeader));
   done_msg.type = htons (GNUNET_MESSAGE_TYPE_CORE_ITERATE_PEERS_END);
   GNUNET_SERVER_transmit_context_append_message (tc, &done_msg);
@@ -760,7 +759,7 @@ GSC_SESSIONS_add_to_typemap (const struct GNUNET_PeerIdentity *peer,
 void
 GSC_SESSIONS_init ()
 {
-  sessions = GNUNET_CONTAINER_multihashmap_create (128, GNUNET_NO);
+  sessions = GNUNET_CONTAINER_multipeermap_create (128, GNUNET_NO);
 }
 
 
@@ -773,7 +772,7 @@ GSC_SESSIONS_init ()
  * @return GNUNET_OK (continue to iterate)
  */
 static int
-free_session_helper (void *cls, const struct GNUNET_HashCode * key, void *value)
+free_session_helper (void *cls, const struct GNUNET_PeerIdentity * key, void *value)
 {
   struct Session *session = value;
 
@@ -790,8 +789,8 @@ GSC_SESSIONS_done ()
 {
   if (NULL != sessions)
   {
-    GNUNET_CONTAINER_multihashmap_iterate (sessions, &free_session_helper, NULL);
-    GNUNET_CONTAINER_multihashmap_destroy (sessions);
+    GNUNET_CONTAINER_multipeermap_iterate (sessions, &free_session_helper, NULL);
+    GNUNET_CONTAINER_multipeermap_destroy (sessions);
     sessions = NULL;
   }
 }
diff --git a/src/dht/gnunet-service-dht_hello.c b/src/dht/gnunet-service-dht_hello.c
index 2ce7f1925..d3415d11d 100644
--- a/src/dht/gnunet-service-dht_hello.c
+++ b/src/dht/gnunet-service-dht_hello.c
@@ -40,7 +40,7 @@ static struct GNUNET_PEERINFO_NotifyContext *pnc;
 /**
  * Hash map of peers to HELLOs.
  */
-static struct GNUNET_CONTAINER_MultiHashMap *peer_to_hello;
+static struct GNUNET_CONTAINER_MultiPeerMap *peer_to_hello;
 
 
 /**
@@ -54,7 +54,7 @@ GDS_HELLO_get (const struct GNUNET_PeerIdentity *peer)
 {
   if (NULL == peer_to_hello)
     return NULL;
-  return GNUNET_CONTAINER_multihashmap_get (peer_to_hello, &peer->hashPubKey);
+  return GNUNET_CONTAINER_multipeermap_get (peer_to_hello, peer);
 }
 
 
@@ -81,13 +81,13 @@ process_hello (void *cls, const struct GNUNET_PeerIdentity *peer,
   GNUNET_STATISTICS_update (GDS_stats,
                             gettext_noop ("# HELLOs obtained from peerinfo"), 1,
                             GNUNET_NO);
-  hm = GNUNET_CONTAINER_multihashmap_get (peer_to_hello, &peer->hashPubKey);
+  hm = GNUNET_CONTAINER_multipeermap_get (peer_to_hello, peer);
   GNUNET_free_non_null (hm);
   hm = GNUNET_malloc (GNUNET_HELLO_size (hello));
   memcpy (hm, hello, GNUNET_HELLO_size (hello));
   GNUNET_assert (GNUNET_SYSERR !=
-                 GNUNET_CONTAINER_multihashmap_put (peer_to_hello,
-                                                    &peer->hashPubKey, hm,
+                 GNUNET_CONTAINER_multipeermap_put (peer_to_hello,
+                                                    peer, hm,
                                                     GNUNET_CONTAINER_MULTIHASHMAPOPTION_REPLACE));
 }
 
@@ -99,7 +99,7 @@ void
 GDS_HELLO_init ()
 {
   pnc = GNUNET_PEERINFO_notify (GDS_cfg, GNUNET_NO, &process_hello, NULL);
-  peer_to_hello = GNUNET_CONTAINER_multihashmap_create (256, GNUNET_NO);
+  peer_to_hello = GNUNET_CONTAINER_multipeermap_create (256, GNUNET_NO);
 }
 
 
@@ -107,7 +107,9 @@ GDS_HELLO_init ()
  * Free memory occopied by the HELLO.
  */
 static int
-free_hello (void *cls, const struct GNUNET_HashCode * key, void *hello)
+free_hello (void *cls, 
+            const struct GNUNET_PeerIdentity *key, 
+            void *hello)
 {
   GNUNET_free (hello);
   return GNUNET_OK;
@@ -127,8 +129,8 @@ GDS_HELLO_done ()
   }
   if (NULL != peer_to_hello)
   {
-    GNUNET_CONTAINER_multihashmap_iterate (peer_to_hello, &free_hello, NULL);
-    GNUNET_CONTAINER_multihashmap_destroy (peer_to_hello);
+    GNUNET_CONTAINER_multipeermap_iterate (peer_to_hello, &free_hello, NULL);
+    GNUNET_CONTAINER_multipeermap_destroy (peer_to_hello);
   }
 }
 
diff --git a/src/dht/gnunet-service-dht_neighbours.c b/src/dht/gnunet-service-dht_neighbours.c
index 11ba71aef..62c29e421 100644
--- a/src/dht/gnunet-service-dht_neighbours.c
+++ b/src/dht/gnunet-service-dht_neighbours.c
@@ -26,8 +26,8 @@
  */
 
 #include "platform.h"
-#include "gnunet_block_lib.h"
 #include "gnunet_util_lib.h"
+#include "gnunet_block_lib.h"
 #include "gnunet_hello_lib.h"
 #include "gnunet_constants.h"
 #include "gnunet_protocols.h"
diff --git a/src/dht/plugin_block_dht.c b/src/dht/plugin_block_dht.c
index ac4732cff..a21167fb0 100644
--- a/src/dht/plugin_block_dht.c
+++ b/src/dht/plugin_block_dht.c
@@ -42,11 +42,11 @@
  * @param type block type
  * @param query original query (hash)
  * @param bf pointer to bloom filter associated with query; possibly updated (!)
- * @param bf_mutator mutation value for bf
+ * @param bf_mutator mutation value for @a bf
  * @param xquery extended query data (can be NULL, depending on type)
- * @param xquery_size number of bytes in xquery
+ * @param xquery_size number of bytes in @a xquery
  * @param reply_block response to validate
- * @param reply_block_size number of bytes in reply block
+ * @param reply_block_size number of bytes in @a reply_block
  * @return characterization of result
  */
 static enum GNUNET_BLOCK_EvaluationResult
@@ -61,6 +61,7 @@ block_plugin_dht_evaluate (void *cls, enum GNUNET_BLOCK_Type type,
   const struct GNUNET_HELLO_Message *hello;
   struct GNUNET_PeerIdentity pid;
   const struct GNUNET_MessageHeader *msg;
+  struct GNUNET_HashCode phash;
 
   if (type != GNUNET_BLOCK_TYPE_DHT_HELLO)
     return GNUNET_BLOCK_EVALUATION_TYPE_NOT_SUPPORTED;
@@ -90,7 +91,8 @@ block_plugin_dht_evaluate (void *cls, enum GNUNET_BLOCK_Type type,
   }
   if (NULL != bf)
   {
-    GNUNET_BLOCK_mingle_hash (&pid.hashPubKey, bf_mutator, &mhash);
+    GNUNET_CRYPTO_hash (&pid, sizeof (pid), &phash);
+    GNUNET_BLOCK_mingle_hash (&phash, bf_mutator, &mhash);
     if (NULL != *bf)
     {
       if (GNUNET_YES == GNUNET_CONTAINER_bloomfilter_test (*bf, &mhash))
@@ -114,9 +116,9 @@ block_plugin_dht_evaluate (void *cls, enum GNUNET_BLOCK_Type type,
  * @param cls closure
  * @param type block type
  * @param block block to get the key for
- * @param block_size number of bytes in block
+ * @param block_size number of bytes @a block
  * @param key set to the key (query) for the given block
- * @return GNUNET_OK on success, GNUNET_SYSERR if type not supported
+ * @return #GNUNET_OK on success, #GNUNET_SYSERR if type not supported
  *         (or if extracting a key from a block of this type does not work)
  */
 static int
diff --git a/src/include/gnunet_nse_service.h b/src/include/gnunet_nse_service.h
index edec078ba..d52315ea9 100644
--- a/src/include/gnunet_nse_service.h
+++ b/src/include/gnunet_nse_service.h
@@ -39,9 +39,7 @@ extern "C"
 #endif
 #endif
 
-#include "gnunet_common.h"
-#include "gnunet_configuration_lib.h"
-#include "gnunet_scheduler_lib.h"
+#include "gnunet_util_lib.h"
 
 /**
  * Version of the network size estimation API.
diff --git a/src/nse/gnunet-service-nse.c b/src/nse/gnunet-service-nse.c
index 98ace893e..2453c7e11 100644
--- a/src/nse/gnunet-service-nse.c
+++ b/src/nse/gnunet-service-nse.c
@@ -189,7 +189,7 @@ struct GNUNET_NSE_FloodMessage
   /**
    * Public key of the originator.
    */
-  struct GNUNET_CRYPTO_EccPublicSignKey pkey;
+  struct GNUNET_PeerIdentity origin;
 
   /**
    * Proof of work, causing leading zeros when hashed with pkey.
@@ -221,7 +221,7 @@ static struct GNUNET_CORE_Handle *coreAPI;
 /**
  * Map of all connected peers.
  */
-static struct GNUNET_CONTAINER_MultiHashMap *peers;
+static struct GNUNET_CONTAINER_MultiPeerMap *peers;
 
 /**
  * The current network size estimate.  Number of bits matching on
@@ -286,11 +286,6 @@ static struct GNUNET_TIME_Absolute next_timestamp;
 static struct GNUNET_TIME_Absolute current_timestamp;
 
 /**
- * The public key of this peer.
- */
-static struct GNUNET_CRYPTO_EccPublicSignKey my_public_key;
-
-/**
  * The private key of this peer.
  */
 static struct GNUNET_CRYPTO_EccPrivateKey *my_private_key;
@@ -392,7 +387,7 @@ setup_estimate_message (struct GNUNET_NSE_ClientMessage *em)
   em->reserved = htonl (0);
   em->timestamp = GNUNET_TIME_absolute_hton (GNUNET_TIME_absolute_get ());
   double se = mean - 0.332747;
-  nsize = log2 (GNUNET_CONTAINER_multihashmap_size (peers) + 1);
+  nsize = log2 (GNUNET_CONTAINER_multipeermap_size (peers) + 1);
   em->size_estimate = GNUNET_hton_double (GNUNET_MAX (se, nsize));
   em->std_deviation = GNUNET_hton_double (std_dev);
   GNUNET_STATISTICS_set (stats, "# nodes in the network (estimate)",
@@ -510,10 +505,12 @@ get_matching_bits (struct GNUNET_TIME_Absolute timestamp,
                    const struct GNUNET_PeerIdentity *id)
 {
   struct GNUNET_HashCode timestamp_hash;
+  struct GNUNET_HashCode pid_hash;
 
   GNUNET_CRYPTO_hash (&timestamp.abs_value_us, sizeof (timestamp.abs_value_us),
                       &timestamp_hash);
-  return GNUNET_CRYPTO_hash_matching_bits (&timestamp_hash, &id->hashPubKey);
+  GNUNET_CRYPTO_hash (id, sizeof (struct GNUNET_PeerIdentity), &pid_hash);
+  return GNUNET_CRYPTO_hash_matching_bits (&timestamp_hash, &pid_hash);
 }
 
 
@@ -716,7 +713,7 @@ setup_flood_message (unsigned int slot,
              sizeof (struct GNUNET_CRYPTO_EccSignature));
   fm->matching_bits = htonl (matching_bits);
   fm->timestamp = GNUNET_TIME_absolute_hton (ts);
-  fm->pkey = my_public_key;
+  fm->origin = my_identity;
   fm->proof_of_work = my_proof;
   if (nse_work_required > 0)
     GNUNET_assert (GNUNET_OK ==
@@ -738,7 +735,7 @@ setup_flood_message (unsigned int slot,
  */
 static int
 schedule_current_round (void *cls, 
-                        const struct GNUNET_HashCode * key, 
+                        const struct GNUNET_PeerIdentity * key, 
                         void *value)
 {
   struct NSEPeerEntry *peer_entry = value;
@@ -817,7 +814,7 @@ update_flood_message (void *cls,
   for (i = 0; i < HISTORY_SIZE; i++)
     hop_count_max =
         GNUNET_MAX (ntohl (size_estimate_messages[i].hop_count), hop_count_max);
-  GNUNET_CONTAINER_multihashmap_iterate (peers, &schedule_current_round, NULL);
+  GNUNET_CONTAINER_multipeermap_iterate (peers, &schedule_current_round, NULL);
   flood_task =
       GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_absolute_get_remaining
                                     (next_timestamp), &update_flood_message,
@@ -907,8 +904,8 @@ find_proof (void *cls,
   unsigned int i;
 
   proof_task = GNUNET_SCHEDULER_NO_TASK;
-  memcpy (&buf[sizeof (uint64_t)], &my_public_key,
-          sizeof (struct GNUNET_CRYPTO_EccPublicSignKey));
+  memcpy (&buf[sizeof (uint64_t)], &my_identity,
+          sizeof (struct GNUNET_PeerIdentity));
   i = 0;
   counter = my_proof;
   while ((counter != UINT64_MAX) && (i < ROUND_SIZE))
@@ -959,7 +956,7 @@ static int
 verify_message_crypto (const struct GNUNET_NSE_FloodMessage *incoming_flood)
 {
   if (GNUNET_YES !=
-      check_proof_of_work (&incoming_flood->pkey,
+      check_proof_of_work (&incoming_flood->origin.public_key,
                            incoming_flood->proof_of_work))
   {
     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Proof of work invalid: %llu!\n",
@@ -973,7 +970,7 @@ verify_message_crypto (const struct GNUNET_NSE_FloodMessage *incoming_flood)
        GNUNET_CRYPTO_ecc_verify (GNUNET_SIGNATURE_PURPOSE_NSE_SEND,
                                  &incoming_flood->purpose,
                                  &incoming_flood->signature,
-                                 &incoming_flood->pkey)))
+                                 &incoming_flood->origin.public_key)))
   {
     GNUNET_break_op (0);
     return GNUNET_NO;
@@ -993,7 +990,7 @@ verify_message_crypto (const struct GNUNET_NSE_FloodMessage *incoming_flood)
  */
 static int
 update_flood_times (void *cls, 
-                    const struct GNUNET_HashCode *key, 
+                    const struct GNUNET_PeerIdentity *key, 
                     void *value)
 {
   struct NSEPeerEntry *exclude = cls;
@@ -1062,11 +1059,14 @@ handle_p2p_size_estimate (void *cls,
     char pred[5];
     struct GNUNET_PeerIdentity os;
 
-    GNUNET_CRYPTO_hash (&incoming_flood->pkey,
-                        sizeof (struct GNUNET_CRYPTO_EccPublicSignKey),
-                        &os.hashPubKey);
-    GNUNET_snprintf (origin, sizeof (origin), "%s", GNUNET_i2s (&os));
-    GNUNET_snprintf (pred, sizeof (pred), "%s", GNUNET_i2s (peer));
+    GNUNET_snprintf (origin, 
+                     sizeof (origin), 
+                     "%4s", 
+                     GNUNET_i2s (&incoming_flood->origin));
+    GNUNET_snprintf (pred, 
+                     sizeof (pred), 
+                     "%4s",
+                     GNUNET_i2s (peer));
     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                 "Flood at %s from `%s' via `%s' at `%s' with bits %u\n",
                 GNUNET_STRINGS_absolute_time_to_string (GNUNET_TIME_absolute_ntoh (incoming_flood->timestamp)),
@@ -1075,7 +1075,7 @@ handle_p2p_size_estimate (void *cls,
   }
 #endif
 
-  peer_entry = GNUNET_CONTAINER_multihashmap_get (peers, &peer->hashPubKey);
+  peer_entry = GNUNET_CONTAINER_multipeermap_get (peers, peer);
   if (NULL == peer_entry)
   {
     GNUNET_break (0);
@@ -1117,7 +1117,8 @@ handle_p2p_size_estimate (void *cls,
   {
     /* send to self, update our own estimate IF this also comes from us! */
     if (0 ==
-        memcmp (&incoming_flood->pkey, &my_public_key, sizeof (my_public_key)))
+        memcmp (&incoming_flood->origin, 
+                &my_identity, sizeof (my_identity)))
       update_network_size_estimate ();
     return GNUNET_OK;
   }
@@ -1205,7 +1206,7 @@ handle_p2p_size_estimate (void *cls,
   update_network_size_estimate ();
 
   /* flood to rest */
-  GNUNET_CONTAINER_multihashmap_iterate (peers, &update_flood_times,
+  GNUNET_CONTAINER_multipeermap_iterate (peers, &update_flood_times,
                                          peer_entry);
   return GNUNET_OK;
 }
@@ -1230,7 +1231,7 @@ handle_core_connect (void *cls,
   peer_entry = GNUNET_new (struct NSEPeerEntry);
   peer_entry->id = *peer;
   GNUNET_assert (GNUNET_OK ==
-                 GNUNET_CONTAINER_multihashmap_put (peers, &peer->hashPubKey,
+                 GNUNET_CONTAINER_multipeermap_put (peers, peer,
                                                     peer_entry,
                                                     GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
   peer_entry->transmit_task =
@@ -1256,14 +1257,14 @@ handle_core_disconnect (void *cls,
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "Peer `%s' disconnected from us\n",
               GNUNET_i2s (peer));
-  pos = GNUNET_CONTAINER_multihashmap_get (peers, &peer->hashPubKey);
+  pos = GNUNET_CONTAINER_multipeermap_get (peers, peer);
   if (NULL == pos)
   {
     GNUNET_break (0);
     return;
   }
   GNUNET_assert (GNUNET_YES ==
-                 GNUNET_CONTAINER_multihashmap_remove (peers, &peer->hashPubKey,
+                 GNUNET_CONTAINER_multipeermap_remove (peers, peer,
                                                        pos));
   if (pos->transmit_task != GNUNET_SCHEDULER_NO_TASK) {
     GNUNET_SCHEDULER_cancel (pos->transmit_task);
@@ -1335,7 +1336,7 @@ shutdown_task (void *cls,
   }
   if (NULL != peers)
   {
-    GNUNET_CONTAINER_multihashmap_destroy (peers);
+    GNUNET_CONTAINER_multipeermap_destroy (peers);
     peers = NULL;
   }
   if (NULL != my_private_key)
@@ -1381,7 +1382,7 @@ core_init (void *cls,
       GNUNET_TIME_absolute_add (current_timestamp, gnunet_nse_interval);
   estimate_index = HISTORY_SIZE - 1;
   estimate_count = 0;
-  if (GNUNET_YES == check_proof_of_work (&my_public_key, my_proof))
+  if (GNUNET_YES == check_proof_of_work (&my_identity.public_key, my_proof))
   {
     int idx = (estimate_index + HISTORY_SIZE - 1) % HISTORY_SIZE;
     prev_time.abs_value_us =
@@ -1476,9 +1477,8 @@ run (void *cls,
   pk = GNUNET_CRYPTO_ecc_key_create_from_configuration (cfg);
   GNUNET_assert (NULL != pk);
   my_private_key = pk;
-  GNUNET_CRYPTO_ecc_key_get_public_for_signature (my_private_key, &my_public_key);
-  GNUNET_CRYPTO_hash (&my_public_key, sizeof (my_public_key),
-                      &my_identity.hashPubKey);
+  GNUNET_CRYPTO_ecc_key_get_public_for_signature (my_private_key, 
+                                                  &my_identity.public_key);
   if (GNUNET_OK !=
       GNUNET_CONFIGURATION_get_value_filename (cfg, "NSE", "PROOFFILE", &proof))
   {
@@ -1499,7 +1499,7 @@ run (void *cls,
       GNUNET_SCHEDULER_add_with_priority (GNUNET_SCHEDULER_PRIORITY_IDLE,
                                           &find_proof, NULL);
 
-  peers = GNUNET_CONTAINER_multihashmap_create (128, GNUNET_NO);
+  peers = GNUNET_CONTAINER_multipeermap_create (128, GNUNET_NO);
   GNUNET_SERVER_add_handlers (srv, handlers);
   nc = GNUNET_SERVER_notification_context_create (srv, 1);
   /* Connect to core service and register core handlers */
diff --git a/src/peerinfo-tool/gnunet-peerinfo.c b/src/peerinfo-tool/gnunet-peerinfo.c
index 8963637c9..af7a8f757 100644
--- a/src/peerinfo-tool/gnunet-peerinfo.c
+++ b/src/peerinfo-tool/gnunet-peerinfo.c
@@ -190,11 +190,6 @@ static struct GNUNET_PEERINFO_IteratorContext *pic;
 static struct GNUNET_PeerIdentity my_peer_identity;
 
 /**
- * My public key.
- */
-static struct GNUNET_CRYPTO_EccPublicSignKey my_public_key;
-
-/**
  * Head of list of print contexts.
  */
 static struct PrintContext *pc_head;
@@ -232,13 +227,11 @@ state_machine (void *cls,
 static void
 dump_pc (struct PrintContext *pc)
 {
-  struct GNUNET_CRYPTO_HashAsciiEncoded enc;
   unsigned int i;
 
-  GNUNET_CRYPTO_hash_to_enc (&pc->peer.hashPubKey, &enc);
   printf (_("%sPeer `%s'\n"),
-        (GNUNET_YES == pc->friend_only) ? "F2F: " : "",
-          (const char *) &enc);
+          (GNUNET_YES == pc->friend_only) ? "F2F: " : "",
+          GNUNET_i2s_full (&pc->peer));
   for (i = 0; i < pc->num_addresses; i++)
   {
     if (NULL != pc->address_list[i].result)
@@ -345,7 +338,6 @@ static void
 print_peer_info (void *cls, const struct GNUNET_PeerIdentity *peer,
                  const struct GNUNET_HELLO_Message *hello, const char *err_msg)
 {
-  struct GNUNET_CRYPTO_HashAsciiEncoded enc;
   struct PrintContext *pc;
   int friend_only;
 
@@ -367,10 +359,9 @@ print_peer_info (void *cls, const struct GNUNET_PeerIdentity *peer,
         friend_only = GNUNET_HELLO_is_friend_only (hello);
   if ((GNUNET_YES == be_quiet) || (NULL == hello))
   {
-    GNUNET_CRYPTO_hash_to_enc (&peer->hashPubKey, &enc);
     printf ("%s%s\n",
-                (GNUNET_YES == friend_only) ? "F2F: " : "",
-                (const char *) &enc);
+            (GNUNET_YES == friend_only) ? "F2F: " : "",
+            GNUNET_i2s_full (peer));
     return;
   }
   pc = GNUNET_malloc (sizeof (struct PrintContext));
@@ -546,7 +537,8 @@ parse_hello_uri (const char *put_uri)
 {
   struct GNUNET_HELLO_Message *hello = NULL;
 
-  int ret = GNUNET_HELLO_parse_uri(put_uri, &my_public_key, &hello, &GPI_plugins_find);
+  int ret = GNUNET_HELLO_parse_uri(put_uri, &my_peer_identity.public_key, 
+                                   &hello, &GPI_plugins_find);
 
   if (NULL != hello) {
     /* WARNING: this adds the address from URI WITHOUT verification! */
@@ -677,9 +669,9 @@ run (void *cls, char *const *args, const char *cfgfile,
       return;
     }
     GNUNET_free (fn);
-    GNUNET_CRYPTO_ecc_key_get_public_for_signature (priv, &my_public_key);
+    GNUNET_CRYPTO_ecc_key_get_public_for_signature (priv, 
+                                                    &my_peer_identity.public_key);
     GNUNET_free (priv);
-    GNUNET_CRYPTO_hash (&my_public_key, sizeof (my_public_key), &my_peer_identity.hashPubKey);
   }
 
   tt = GNUNET_SCHEDULER_add_now (&state_machine, NULL);
@@ -725,14 +717,14 @@ state_machine (void *cls,
   }
   else if (GNUNET_YES == get_self)
   {
-    struct GNUNET_CRYPTO_HashAsciiEncoded enc;
     get_self = GNUNET_NO;
-    GNUNET_CRYPTO_hash_to_enc (&my_peer_identity.hashPubKey, &enc);
     if (be_quiet)
-      printf ("%s\n", (char *) &enc);
+      printf ("%s\n", 
+              GNUNET_i2s_full (&my_peer_identity));
     else
-      printf (_("I am peer `%s'.\n"), (const char *) &enc);
-        tt = GNUNET_SCHEDULER_add_now (&state_machine, NULL);
+      printf (_("I am peer `%s'.\n"),
+              GNUNET_i2s_full (&my_peer_identity));
+    tt = GNUNET_SCHEDULER_add_now (&state_machine, NULL);
   }
   else if (GNUNET_YES == get_uri)
   {
diff --git a/src/testbed/gnunet-daemon-testbed-blacklist.c b/src/testbed/gnunet-daemon-testbed-blacklist.c
index 264397735..d14944362 100644
--- a/src/testbed/gnunet-daemon-testbed-blacklist.c
+++ b/src/testbed/gnunet-daemon-testbed-blacklist.c
@@ -56,7 +56,7 @@
 /**
  * The map to store the peer identities to allow/deny
  */
-static struct GNUNET_CONTAINER_MultiHashMap *map;
+static struct GNUNET_CONTAINER_MultiPeerMap *map;
 
 /**
  * The array of peer identities we read from whitelist/blacklist
@@ -92,9 +92,9 @@ static int mode;
  *         #GNUNET_NO if not.
  */
 static int
-iterator (void *cls, const struct GNUNET_HashCode *key, void *value)
+iterator (void *cls, const struct GNUNET_PeerIdentity *key, void *value)
 {
-  GNUNET_assert (GNUNET_YES == GNUNET_CONTAINER_multihashmap_remove (map, key,
+  GNUNET_assert (GNUNET_YES == GNUNET_CONTAINER_multipeermap_remove (map, key,
                                                                      value));
   return GNUNET_YES;
 }
@@ -108,10 +108,10 @@ cleanup_map ()
 {
   if (NULL != map)
   {
-    GNUNET_assert (GNUNET_SYSERR != GNUNET_CONTAINER_multihashmap_iterate (map,
+    GNUNET_assert (GNUNET_SYSERR != GNUNET_CONTAINER_multipeermap_iterate (map,
                                                                            &iterator,
                                                                            NULL));
-    GNUNET_CONTAINER_multihashmap_destroy (map);
+    GNUNET_CONTAINER_multipeermap_destroy (map);
     map = NULL;
   }
 }
@@ -145,7 +145,7 @@ check_access (void *cls, const struct GNUNET_PeerIdentity * pid)
   int contains;
  
   if (NULL != map)
-    contains = GNUNET_CONTAINER_multihashmap_contains (map, &(pid->hashPubKey));
+    contains = GNUNET_CONTAINER_multipeermap_contains (map, pid);
   else
     contains = GNUNET_NO;
   if (ACCESS_DENY == mode)
@@ -178,13 +178,13 @@ setup_ac (const char *fname, const struct GNUNET_CONFIGURATION_Handle *cfg)
   npeers = fsize / sizeof (struct GNUNET_PeerIdentity);
   if (0 != npeers)
   {
-    map = GNUNET_CONTAINER_multihashmap_create (npeers, GNUNET_YES);
+    map = GNUNET_CONTAINER_multipeermap_create (npeers, GNUNET_YES);
     ilist = GNUNET_malloc_large (fsize);
     GNUNET_assert (fsize == GNUNET_DISK_fn_read (fname, ilist, fsize));
   }
   for (cnt = 0; cnt < npeers; cnt++)
   {
-    if (GNUNET_SYSERR == GNUNET_CONTAINER_multihashmap_put (map, &(ilist[cnt].hashPubKey),
+    if (GNUNET_SYSERR == GNUNET_CONTAINER_multipeermap_put (map, &ilist[cnt],
                                                             &ilist[cnt],
                                                             GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY))
     {
diff --git a/src/testbed/gnunet-service-testbed_meminfo.c b/src/testbed/gnunet-service-testbed_meminfo.c
index a875050ac..3914a324d 100644
--- a/src/testbed/gnunet-service-testbed_meminfo.c
+++ b/src/testbed/gnunet-service-testbed_meminfo.c
@@ -19,7 +19,7 @@
 */
 
 #include "platform.h"
-#include "gnunet_common.h"
+#include "gnunet_util_lib.h"
 
 /*
  * File for parsing top-level /proc entities.
diff --git a/src/testbed/gnunet-testbed-profiler.c b/src/testbed/gnunet-testbed-profiler.c
index 0b36fed9f..8d85280fe 100644
--- a/src/testbed/gnunet-testbed-profiler.c
+++ b/src/testbed/gnunet-testbed-profiler.c
@@ -25,7 +25,6 @@
  */
 
 #include "platform.h"
-#include "gnunet_common.h"
 #include "gnunet_util_lib.h"
 #include "gnunet_testbed_service.h"
 #include "testbed_api_hosts.h"
diff --git a/src/testbed/testbed.h b/src/testbed/testbed.h
index e6330ea89..f781eea0d 100644
--- a/src/testbed/testbed.h
+++ b/src/testbed/testbed.h
@@ -657,7 +657,7 @@ struct GNUNET_TESTBED_PeerConfigurationInformationMessage
   /**
    * Identity of the peer.
    */
-  struct GNUNET_PeerIdentity peer_identity GNUNET_PACKED;
+  struct GNUNET_PeerIdentity peer_identity;
 
   /**
    * The size of configuration when uncompressed
diff --git a/src/testbed/testbed_api.h b/src/testbed/testbed_api.h
index f09bb61b9..3b6678c56 100644
--- a/src/testbed/testbed_api.h
+++ b/src/testbed/testbed_api.h
@@ -27,7 +27,7 @@
 #ifndef TESTBED_API_H
 #define TESTBED_API_H
 
-#include "gnunet_scheduler_lib.h"
+#include "gnunet_util_lib.h"
 #include "gnunet_testbed_service.h"
 #include "testbed.h"
 #include "testbed_helper.h"