-chaning multihashmap API to allow option for avoiding key allocation

53 files changed, 150 insertions, 115 deletions

diff --git a/src/ats/gnunet-service-ats_addresses.c b/src/ats/gnunet-service-ats_addresses.c
index 72176fc76..075324762 100644
--- a/src/ats/gnunet-service-ats_addresses.c
+++ b/src/ats/gnunet-service-ats_addresses.c
@@ -929,7 +929,7 @@ GAS_addresses_init (const struct GNUNET_CONFIGURATION_Handle *cfg,
 
   running = GNUNET_NO;
 
-  addresses = GNUNET_CONTAINER_multihashmap_create (128);
+  addresses = GNUNET_CONTAINER_multihashmap_create (128, GNUNET_NO);
   GNUNET_assert (NULL != addresses);
 
   if (GNUNET_OK == GNUNET_CONFIGURATION_get_value_string(cfg, "ats", "WAN_QUOTA_IN", &quota_wan_in_str))
diff --git a/src/ats/gnunet-service-ats_reservations.c b/src/ats/gnunet-service-ats_reservations.c
index daacbbec0..3354c4e41 100644
--- a/src/ats/gnunet-service-ats_reservations.c
+++ b/src/ats/gnunet-service-ats_reservations.c
@@ -122,7 +122,7 @@ GAS_reservations_set_bandwidth (const struct GNUNET_PeerIdentity *peer,
 void
 GAS_reservations_init ()
 {
-  trackers = GNUNET_CONTAINER_multihashmap_create (128);
+  trackers = GNUNET_CONTAINER_multihashmap_create (128, GNUNET_NO);
 }
 
 
diff --git a/src/ats/perf_ats_mlp.c b/src/ats/perf_ats_mlp.c
index c8ecda685..51f910256 100644
--- a/src/ats/perf_ats_mlp.c
+++ b/src/ats/perf_ats_mlp.c
@@ -213,7 +213,7 @@ check (void *cls, char *const *args, const char *cfgfile,
   p = GNUNET_malloc (peers * sizeof (struct ATS_Peer));
   a = GNUNET_malloc (peers * addresses * sizeof (struct ATS_Address));
 
-  amap = GNUNET_CONTAINER_multihashmap_create(addresses * peers);
+  amap = GNUNET_CONTAINER_multihashmap_create(addresses * peers, GNUNET_NO);
 
   mlp->auto_solve = GNUNET_NO;
   if (start == 0)
diff --git a/src/ats/test_ats_mlp.c b/src/ats/test_ats_mlp.c
index c4672103d..3e449dbd2 100644
--- a/src/ats/test_ats_mlp.c
+++ b/src/ats/test_ats_mlp.c
@@ -76,7 +76,7 @@ check (void *cls, char *const *args, const char *cfgfile,
 
   stats = GNUNET_STATISTICS_create("ats", cfg);
 
-  addresses = GNUNET_CONTAINER_multihashmap_create (10);
+  addresses = GNUNET_CONTAINER_multihashmap_create (10, GNUNET_NO);
 
   mlp = GAS_mlp_init (cfg, NULL, MLP_MAX_EXEC_DURATION, MLP_MAX_ITERATIONS);
   mlp->auto_solve = GNUNET_NO;
diff --git a/src/ats/test_ats_mlp_averaging.c b/src/ats/test_ats_mlp_averaging.c
index bf219df22..2f70137df 100644
--- a/src/ats/test_ats_mlp_averaging.c
+++ b/src/ats/test_ats_mlp_averaging.c
@@ -77,7 +77,7 @@ check (void *cls, char *const *args, const char *cfgfile,
 
   stats = GNUNET_STATISTICS_create("ats", cfg);
 
-  addresses = GNUNET_CONTAINER_multihashmap_create (10);
+  addresses = GNUNET_CONTAINER_multihashmap_create (10, GNUNET_NO);
 
   mlp = GAS_mlp_init (cfg, NULL, MLP_MAX_EXEC_DURATION, MLP_MAX_ITERATIONS);
   mlp->auto_solve = GNUNET_NO;
diff --git a/src/chat/gnunet-service-chat.c b/src/chat/gnunet-service-chat.c
index 580851557..ec988e8fd 100644
--- a/src/chat/gnunet-service-chat.c
+++ b/src/chat/gnunet-service-chat.c
@@ -1706,7 +1706,7 @@ run (void *cls, struct GNUNET_SERVER_Handle *server,
   cfg = c;
   nc = GNUNET_SERVER_notification_context_create (server, 16);
   connected_peers =
-      GNUNET_CONTAINER_multihashmap_create (EXPECTED_NEIGHBOUR_COUNT);
+    GNUNET_CONTAINER_multihashmap_create (EXPECTED_NEIGHBOUR_COUNT, GNUNET_NO);
   GNUNET_SERVER_add_handlers (server, handlers);
   core =
       GNUNET_CORE_connect (cfg, NULL, &core_init,
diff --git a/src/core/core_api.c b/src/core/core_api.c
index 46105a466..4d1a5493f 100644
--- a/src/core/core_api.c
+++ b/src/core/core_api.c
@@ -1173,7 +1173,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);
+  h->peers = GNUNET_CONTAINER_multihashmap_create (128, GNUNET_NO);
   h->retry_backoff = GNUNET_TIME_UNIT_MILLISECONDS;
   if (NULL != handlers)
     while (handlers[h->hcnt].callback != NULL)
diff --git a/src/core/gnunet-service-core_clients.c b/src/core/gnunet-service-core_clients.c
index 91f1ae65a..56ebcc423 100644
--- a/src/core/gnunet-service-core_clients.c
+++ b/src/core/gnunet-service-core_clients.c
@@ -298,7 +298,7 @@ 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);
+  c->connectmap = GNUNET_CONTAINER_multihashmap_create (16, GNUNET_NO);
   GNUNET_assert (GNUNET_YES ==
                  GNUNET_CONTAINER_multihashmap_put (c->connectmap,
                                                     &GSC_my_identity.hashPubKey,
@@ -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);
+    c->requests = GNUNET_CONTAINER_multihashmap_create (16, GNUNET_NO);
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "Client asked for transmission to `%s'\n",
               GNUNET_i2s (&req->peer));
diff --git a/src/core/gnunet-service-core_neighbours.c b/src/core/gnunet-service-core_neighbours.c
index 3b1357425..aa77fe47e 100644
--- a/src/core/gnunet-service-core_neighbours.c
+++ b/src/core/gnunet-service-core_neighbours.c
@@ -464,7 +464,7 @@ GSC_NEIGHBOURS_transmit (const struct GNUNET_PeerIdentity *target,
 int
 GSC_NEIGHBOURS_init ()
 {
-  neighbours = GNUNET_CONTAINER_multihashmap_create (128);
+  neighbours = GNUNET_CONTAINER_multihashmap_create (128, GNUNET_NO);
   transport =
       GNUNET_TRANSPORT_connect (GSC_cfg, &GSC_my_identity, NULL,
                                 &handle_transport_receive,
diff --git a/src/core/gnunet-service-core_sessions.c b/src/core/gnunet-service-core_sessions.c
index 87fa91189..3a603bc81 100644
--- a/src/core/gnunet-service-core_sessions.c
+++ b/src/core/gnunet-service-core_sessions.c
@@ -782,7 +782,7 @@ GSC_SESSIONS_add_to_typemap (const struct GNUNET_PeerIdentity *peer,
 void
 GSC_SESSIONS_init ()
 {
-  sessions = GNUNET_CONTAINER_multihashmap_create (128);
+  sessions = GNUNET_CONTAINER_multihashmap_create (128, GNUNET_NO);
 }
 
 
diff --git a/src/dht/dht_api.c b/src/dht/dht_api.c
index 46436755b..023ffe60d 100644
--- a/src/dht/dht_api.c
+++ b/src/dht/dht_api.c
@@ -915,7 +915,7 @@ GNUNET_DHT_connect (const struct GNUNET_CONFIGURATION_Handle *cfg,
   handle->cfg = cfg;
   handle->uid_gen =
       GNUNET_CRYPTO_random_u64 (GNUNET_CRYPTO_QUALITY_WEAK, UINT64_MAX);
-  handle->active_requests = GNUNET_CONTAINER_multihashmap_create (ht_len);
+  handle->active_requests = GNUNET_CONTAINER_multihashmap_create (ht_len, GNUNET_NO);
   if (GNUNET_NO == try_connect (handle))
   {
     GNUNET_DHT_disconnect (handle);
diff --git a/src/dht/gnunet-service-dht_clients.c b/src/dht/gnunet-service-dht_clients.c
index a67155b89..314cae7c9 100644
--- a/src/dht/gnunet-service-dht_clients.c
+++ b/src/dht/gnunet-service-dht_clients.c
@@ -1351,7 +1351,7 @@ GDS_CLIENTS_init (struct GNUNET_SERVER_Handle *server)
      sizeof (struct GNUNET_DHT_MonitorStartStopMessage)},
     {NULL, NULL, 0, 0}
   };
-  forward_map = GNUNET_CONTAINER_multihashmap_create (1024);
+  forward_map = GNUNET_CONTAINER_multihashmap_create (1024, GNUNET_NO);
   retry_heap = GNUNET_CONTAINER_heap_create (GNUNET_CONTAINER_HEAP_ORDER_MIN);
   GNUNET_SERVER_add_handlers (server, plugin_handlers);
   GNUNET_SERVER_disconnect_notify (server, &handle_client_disconnect, NULL);
diff --git a/src/dht/gnunet-service-dht_hello.c b/src/dht/gnunet-service-dht_hello.c
index b4c5150c9..19da79e23 100644
--- a/src/dht/gnunet-service-dht_hello.c
+++ b/src/dht/gnunet-service-dht_hello.c
@@ -99,7 +99,7 @@ void
 GDS_HELLO_init ()
 {
   pnc = GNUNET_PEERINFO_notify (GDS_cfg, &process_hello, NULL);
-  peer_to_hello = GNUNET_CONTAINER_multihashmap_create (256);
+  peer_to_hello = GNUNET_CONTAINER_multihashmap_create (256, GNUNET_NO);
 }
 
 
diff --git a/src/dht/gnunet-service-dht_neighbours.c b/src/dht/gnunet-service-dht_neighbours.c
index 7401eb8ac..198b64f53 100644
--- a/src/dht/gnunet-service-dht_neighbours.c
+++ b/src/dht/gnunet-service-dht_neighbours.c
@@ -2018,7 +2018,7 @@ GDS_NEIGHBOURS_init ()
                            GNUNET_NO, core_handlers);
   if (coreAPI == NULL)
     return GNUNET_SYSERR;
-  all_known_peers = GNUNET_CONTAINER_multihashmap_create (256);
+  all_known_peers = GNUNET_CONTAINER_multihashmap_create (256, GNUNET_NO);
   return GNUNET_OK;
 }
 
diff --git a/src/dht/gnunet-service-dht_routing.c b/src/dht/gnunet-service-dht_routing.c
index 796991b5b..4c2e69b36 100644
--- a/src/dht/gnunet-service-dht_routing.c
+++ b/src/dht/gnunet-service-dht_routing.c
@@ -429,7 +429,7 @@ void
 GDS_ROUTING_init ()
 {
   recent_heap = GNUNET_CONTAINER_heap_create (GNUNET_CONTAINER_HEAP_ORDER_MIN);
-  recent_map = GNUNET_CONTAINER_multihashmap_create (DHT_MAX_RECENT * 4 / 3);
+  recent_map = GNUNET_CONTAINER_multihashmap_create (DHT_MAX_RECENT * 4 / 3, GNUNET_NO);
 }
 
 
diff --git a/src/dv/dv_api.c b/src/dv/dv_api.c
index 131503e6e..8f866e2e5 100644
--- a/src/dv/dv_api.c
+++ b/src/dv/dv_api.c
@@ -587,7 +587,7 @@ GNUNET_DV_connect (const struct GNUNET_CONFIGURATION_Handle *cfg,
                                        GNUNET_YES, &transmit_start,
                                        start_context);
 
-  handle->send_callbacks = GNUNET_CONTAINER_multihashmap_create (100);
+  handle->send_callbacks = GNUNET_CONTAINER_multihashmap_create (100, GNUNET_NO);
 
   return handle;
 }
diff --git a/src/dv/gnunet-service-dv.c b/src/dv/gnunet-service-dv.c
index 5c0b6f5fa..ca881aa91 100644
--- a/src/dv/gnunet-service-dv.c
+++ b/src/dv/gnunet-service-dv.c
@@ -3290,9 +3290,9 @@ run (void *cls, struct GNUNET_SERVER_Handle *server,
   neighbor_max_heap =
       GNUNET_CONTAINER_heap_create (GNUNET_CONTAINER_HEAP_ORDER_MAX);
 
-  direct_neighbors = GNUNET_CONTAINER_multihashmap_create (max_hosts);
+  direct_neighbors = GNUNET_CONTAINER_multihashmap_create (max_hosts, GNUNET_NO);
   extended_neighbors =
-      GNUNET_CONTAINER_multihashmap_create (max_table_size * 3);
+    GNUNET_CONTAINER_multihashmap_create (max_table_size * 3, GNUNET_NO);
 
   GNUNET_SERVER_add_handlers (server, plugin_handlers);
   coreAPI = GNUNET_CORE_connect (cfg, NULL,  /* FIXME: anything we want to pass around? */
diff --git a/src/dv/test_transport_api_dv.c b/src/dv/test_transport_api_dv.c
index 769694f90..c78d5072d 100644
--- a/src/dv/test_transport_api_dv.c
+++ b/src/dv/test_transport_api_dv.c
@@ -1180,7 +1180,7 @@ run (void *cls, char *const *args, const char *cfgfile,
                                     (GNUNET_TIME_UNIT_MINUTES, 5), &end_badly,
                                     "didn't start all daemons in reasonable amount of time!!!");
 
-  peer_daemon_hash = GNUNET_CONTAINER_multihashmap_create (peers_left);
+  peer_daemon_hash = GNUNET_CONTAINER_multihashmap_create (peers_left, GNUNET_NO);
   pg = GNUNET_TESTING_daemons_start (cfg, peers_left,   /* Total number of peers */
                                      peers_left,        /* Number of outstanding connections */
                                      peers_left,        /* Number of parallel ssh connections, or peers being started at once */
diff --git a/src/exit/gnunet-daemon-exit.c b/src/exit/gnunet-daemon-exit.c
index 79c1f8435..4359db33c 100644
--- a/src/exit/gnunet-daemon-exit.c
+++ b/src/exit/gnunet-daemon-exit.c
@@ -3194,11 +3194,11 @@ run (void *cls, char *const *args GNUNET_UNUSED,
   }
   exit_argv[7] = NULL;
 
-  udp_services = GNUNET_CONTAINER_multihashmap_create (65536);
-  tcp_services = GNUNET_CONTAINER_multihashmap_create (65536);
+  udp_services = GNUNET_CONTAINER_multihashmap_create (65536, GNUNET_NO);
+  tcp_services = GNUNET_CONTAINER_multihashmap_create (65536, GNUNET_NO);
   GNUNET_CONFIGURATION_iterate_sections (cfg, &read_service_conf, NULL);
 
-  connections_map = GNUNET_CONTAINER_multihashmap_create (65536);
+  connections_map = GNUNET_CONTAINER_multihashmap_create (65536, GNUNET_NO);
   connections_heap = GNUNET_CONTAINER_heap_create (GNUNET_CONTAINER_HEAP_ORDER_MIN);
   mesh_handle 
     = GNUNET_MESH_connect (cfg, NULL, 
diff --git a/src/fs/fs_api.c b/src/fs/fs_api.c
index c99131d94..059c70ba6 100644
--- a/src/fs/fs_api.c
+++ b/src/fs/fs_api.c
@@ -2681,7 +2681,7 @@ deserialize_download (struct GNUNET_FS_Handle *h,
   }
   dc->options = (enum GNUNET_FS_DownloadOptions) options;
   dc->active =
-      GNUNET_CONTAINER_multihashmap_create (1 + 2 * (dc->length / DBLOCK_SIZE));
+    GNUNET_CONTAINER_multihashmap_create (1 + 2 * (dc->length / DBLOCK_SIZE), GNUNET_NO);
   dc->has_finished = (int) status;
   dc->treedepth =
       GNUNET_FS_compute_depth (GNUNET_FS_uri_chk_get_file_size (dc->uri));
@@ -2804,7 +2804,7 @@ deserialize_search (struct GNUNET_FS_Handle *h,
     goto cleanup;
   }
   sc->options = (enum GNUNET_FS_SearchOptions) options;
-  sc->master_result_map = GNUNET_CONTAINER_multihashmap_create (16);
+  sc->master_result_map = GNUNET_CONTAINER_multihashmap_create (16, GNUNET_NO);
   dn = get_serialization_file_name_in_dir (h,
                                            (sc->psearch_result ==
                                             NULL) ?
diff --git a/src/fs/fs_download.c b/src/fs/fs_download.c
index e9839cc2d..ecb5c5f8a 100644
--- a/src/fs/fs_download.c
+++ b/src/fs/fs_download.c
@@ -2101,7 +2101,7 @@ create_download_context (struct GNUNET_FS_Handle *h,
   dc->anonymity = anonymity;
   dc->options = options;
   dc->active =
-      GNUNET_CONTAINER_multihashmap_create (1 + 2 * (length / DBLOCK_SIZE));
+    GNUNET_CONTAINER_multihashmap_create (1 + 2 * (length / DBLOCK_SIZE), GNUNET_NO);
   dc->treedepth =
       GNUNET_FS_compute_depth (GNUNET_FS_uri_chk_get_file_size (dc->uri));
   if ((NULL == filename) && (is_recursive_download (dc)))
diff --git a/src/fs/fs_namespace.c b/src/fs/fs_namespace.c
index af1200dc4..eaff8a6d2 100644
--- a/src/fs/fs_namespace.c
+++ b/src/fs/fs_namespace.c
@@ -853,7 +853,8 @@ GNUNET_FS_namespace_list_updateable (struct GNUNET_FS_Namespace *ns,
     ns->update_map =
         GNUNET_CONTAINER_multihashmap_create (2 +
                                               3 * ns->update_node_count /
-                                              4);
+                                              4,
+                                              GNUNET_NO);
     for (i = 0; i < ns->update_node_count; i++)
     {
       nsn = ns->update_nodes[i];
diff --git a/src/fs/fs_search.c b/src/fs/fs_search.c
index a5b2d3643..370fd2f5c 100644
--- a/src/fs/fs_search.c
+++ b/src/fs/fs_search.c
@@ -1202,7 +1202,7 @@ search_start (struct GNUNET_FS_Handle *h, const struct GNUNET_FS_Uri *uri,
     sc->psearch_result = psearch;
     psearch->update_search = sc;
   }
-  sc->master_result_map = GNUNET_CONTAINER_multihashmap_create (16);
+  sc->master_result_map = GNUNET_CONTAINER_multihashmap_create (16, GNUNET_NO);
   sc->client_info = cctx;
   if (GNUNET_OK != GNUNET_FS_search_start_searching_ (sc))
   {
@@ -1256,7 +1256,7 @@ GNUNET_FS_search_start_searching_ (struct GNUNET_FS_SearchContext *sc)
       sc->requests[i].mandatory = (sc->uri->data.ksk.keywords[i][0] == '+');
       if (sc->requests[i].mandatory)
         sc->mandatory_count++;
-      sc->requests[i].results = GNUNET_CONTAINER_multihashmap_create (4);
+      sc->requests[i].results = GNUNET_CONTAINER_multihashmap_create (4, GNUNET_NO);
       GNUNET_CRYPTO_hash (keyword, strlen (keyword), &sc->requests[i].key);
     }
   }
diff --git a/src/fs/fs_sharetree.c b/src/fs/fs_sharetree.c
index f75571c46..5e96390ce 100644
--- a/src/fs/fs_sharetree.c
+++ b/src/fs/fs_sharetree.c
@@ -415,8 +415,8 @@ GNUNET_FS_share_tree_trim (struct GNUNET_FS_ShareTreeItem *toplevel)
 
   if (toplevel == NULL)
     return;  
-  tc.keywordcounter = GNUNET_CONTAINER_multihashmap_create (1024);
-  tc.metacounter = GNUNET_CONTAINER_multihashmap_create (1024);
+  tc.keywordcounter = GNUNET_CONTAINER_multihashmap_create (1024, GNUNET_NO);
+  tc.metacounter = GNUNET_CONTAINER_multihashmap_create (1024, GNUNET_NO);
   share_tree_trim (&tc, toplevel);
   GNUNET_CONTAINER_multihashmap_destroy (tc.keywordcounter);
   GNUNET_CONTAINER_multihashmap_destroy (tc.metacounter);
diff --git a/src/fs/gnunet-auto-share.c b/src/fs/gnunet-auto-share.c
index 1a6e74b8c..886e0ba69 100644
--- a/src/fs/gnunet-auto-share.c
+++ b/src/fs/gnunet-auto-share.c
@@ -690,7 +690,7 @@ run (void *cls, char *const *args, const char *cfgfile,
   cfg_filename = GNUNET_strdup (cfgfile);
   cfg = c;
   dir_name = args[0];
-  work_finished = GNUNET_CONTAINER_multihashmap_create (1024);
+  work_finished = GNUNET_CONTAINER_multihashmap_create (1024, GNUNET_NO);
   load_state ();
   run_task = GNUNET_SCHEDULER_add_with_priority (GNUNET_SCHEDULER_PRIORITY_IDLE,
                                                  &scan, NULL);
diff --git a/src/fs/gnunet-service-fs_cp.c b/src/fs/gnunet-service-fs_cp.c
index 4ff6432b0..3de45ff48 100644
--- a/src/fs/gnunet-service-fs_cp.c
+++ b/src/fs/gnunet-service-fs_cp.c
@@ -615,7 +615,7 @@ GSF_peer_connect_handler_ (const struct GNUNET_PeerIdentity *peer,
       (sizeof (respect) == GNUNET_DISK_fn_read (fn, &respect, sizeof (respect))))
     cp->disk_respect = cp->ppd.respect = ntohl (respect);
   GNUNET_free (fn);
-  cp->request_map = GNUNET_CONTAINER_multihashmap_create (128);
+  cp->request_map = GNUNET_CONTAINER_multihashmap_create (128, GNUNET_NO);
   GNUNET_break (GNUNET_OK ==
                 GNUNET_CONTAINER_multihashmap_put (cp_map, &peer->hashPubKey,
                                                    cp,
@@ -1811,7 +1811,7 @@ cron_flush_respect (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 void
 GSF_connected_peer_init_ ()
 {
-  cp_map = GNUNET_CONTAINER_multihashmap_create (128);
+  cp_map = GNUNET_CONTAINER_multihashmap_create (128, GNUNET_NO);
   ats = GNUNET_ATS_performance_init (GSF_cfg, NULL, NULL);
   GNUNET_assert (GNUNET_OK ==
                  GNUNET_CONFIGURATION_get_value_filename (GSF_cfg, "fs",
diff --git a/src/fs/gnunet-service-fs_indexing.c b/src/fs/gnunet-service-fs_indexing.c
index 7bd8316ab..1324b22d7 100644
--- a/src/fs/gnunet-service-fs_indexing.c
+++ b/src/fs/gnunet-service-fs_indexing.c
@@ -613,7 +613,7 @@ GNUNET_FS_indexing_init (const struct GNUNET_CONFIGURATION_Handle *c,
 {
   cfg = c;
   dsh = d;
-  ifm = GNUNET_CONTAINER_multihashmap_create (128);
+  ifm = GNUNET_CONTAINER_multihashmap_create (128, GNUNET_NO);
   read_index_list ();
   return GNUNET_OK;
 }
diff --git a/src/fs/gnunet-service-fs_pe.c b/src/fs/gnunet-service-fs_pe.c
index dbaab7d48..bc08eebe7 100644
--- a/src/fs/gnunet-service-fs_pe.c
+++ b/src/fs/gnunet-service-fs_pe.c
@@ -572,7 +572,7 @@ GSF_plan_add_ (struct GSF_ConnectedPeer *cp, struct GSF_PendingRequest *pr)
   if (NULL == pp)
   {
     pp = GNUNET_malloc (sizeof (struct PeerPlan));
-    pp->plan_map = GNUNET_CONTAINER_multihashmap_create (128);
+    pp->plan_map = GNUNET_CONTAINER_multihashmap_create (128, GNUNET_NO);
     pp->priority_heap =
         GNUNET_CONTAINER_heap_create (GNUNET_CONTAINER_HEAP_ORDER_MAX);
     pp->delay_heap =
@@ -760,7 +760,7 @@ GSF_plan_notify_request_done_ (struct GSF_PendingRequest *pr)
 void
 GSF_plan_init ()
 {
-  plans = GNUNET_CONTAINER_multihashmap_create (256);
+  plans = GNUNET_CONTAINER_multihashmap_create (256, GNUNET_NO);
 }
 
 
diff --git a/src/fs/gnunet-service-fs_pr.c b/src/fs/gnunet-service-fs_pr.c
index ceb034ba0..265784348 100644
--- a/src/fs/gnunet-service-fs_pr.c
+++ b/src/fs/gnunet-service-fs_pr.c
@@ -1627,7 +1627,7 @@ GSF_pending_request_init_ ()
   active_to_migration =
       GNUNET_CONFIGURATION_get_value_yesno (GSF_cfg, "FS", "CONTENT_CACHING");
   datastore_put_load = GNUNET_LOAD_value_init (DATASTORE_LOAD_AUTODECLINE);
-  pr_map = GNUNET_CONTAINER_multihashmap_create (32 * 1024);
+  pr_map = GNUNET_CONTAINER_multihashmap_create (32 * 1024, GNUNET_NO);
   requests_by_expiration_heap =
       GNUNET_CONTAINER_heap_create (GNUNET_CONTAINER_HEAP_ORDER_MIN);
 }
diff --git a/src/include/gnunet_container_lib.h b/src/include/gnunet_container_lib.h
index 96946d02d..a476b7f1b 100644
--- a/src/include/gnunet_container_lib.h
+++ b/src/include/gnunet_container_lib.h
@@ -542,10 +542,20 @@ typedef int (*GNUNET_CONTAINER_HashMapIterator) (void *cls,
  * Create a multi hash map.
  *
  * @param len initial size (map will grow as needed)
+ * @param do_not_copy_keys GNUNET_NO is always safe and should be used by default;
+ *                         GNUNET_YES means that on 'put', the 'key' does not have
+ *                         to be copied as the destination of the pointer is 
+ *                         guaranteed to be life as long as the value is stored in
+ *                         the hashmap.  This can significantly reduce memory 
+ *                         consumption, but of course is also a recipie for 
+ *                         heap corruption if the assumption is not true.  Only
+ *                         use this if (1) memory use is important in this case and
+ *                         (2) you have triple-checked that the invariant holds
  * @return NULL on error
  */
 struct GNUNET_CONTAINER_MultiHashMap *
-GNUNET_CONTAINER_multihashmap_create (unsigned int len);
+GNUNET_CONTAINER_multihashmap_create (unsigned int len,
+                                      int do_not_copy_keys);
 
 
 /**
diff --git a/src/integration-tests/connection_watchdog.c b/src/integration-tests/connection_watchdog.c
index 456782ddd..17aab2159 100644
--- a/src/integration-tests/connection_watchdog.c
+++ b/src/integration-tests/connection_watchdog.c
@@ -1056,7 +1056,7 @@ run (void *cls, char *const *args, const char *cfgfile,
   init();
 
   stats = GNUNET_STATISTICS_create ("watchdog", cfg);
-  peers = GNUNET_CONTAINER_multihashmap_create (20);
+  peers = GNUNET_CONTAINER_multihashmap_create (32, GNUNET_NO);
 
   th = GNUNET_TRANSPORT_connect(cfg, NULL, NULL,
                                 &transport_notify_receive_cb,
diff --git a/src/lockmanager/gnunet-service-lockmanager.c b/src/lockmanager/gnunet-service-lockmanager.c
index 296dd0065..4cb9ff2ae 100644
--- a/src/lockmanager/gnunet-service-lockmanager.c
+++ b/src/lockmanager/gnunet-service-lockmanager.c
@@ -821,7 +821,7 @@ lockmanager_run (void *cls, struct GNUNET_SERVER_Handle *server,
   };
   GNUNET_SERVER_add_handlers (server, message_handlers);
   GNUNET_SERVER_disconnect_notify (server, &client_disconnect_cb, NULL);
-  lock_map = GNUNET_CONTAINER_multihashmap_create (30);
+  lock_map = GNUNET_CONTAINER_multihashmap_create (32, GNUNET_NO);
   GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_FOREVER_REL, &shutdown_task,
                                 NULL);
 }
diff --git a/src/lockmanager/lockmanager_api.c b/src/lockmanager/lockmanager_api.c
index 8adf486ee..3b9e70e59 100644
--- a/src/lockmanager/lockmanager_api.c
+++ b/src/lockmanager/lockmanager_api.c
@@ -567,7 +567,7 @@ GNUNET_LOCKMANAGER_connect (const struct GNUNET_CONFIGURATION_Handle *cfg)
     LOG (GNUNET_ERROR_TYPE_DEBUG, "%s() END\n", __func__);
     return NULL;
   }
-  h->hashmap = GNUNET_CONTAINER_multihashmap_create (15);
+  h->hashmap = GNUNET_CONTAINER_multihashmap_create (16, GNUNET_NO);
   GNUNET_assert (NULL != h->hashmap);
   h->in_replies = GNUNET_YES;
   GNUNET_CLIENT_receive (h->conn, &handle_replies, h,
diff --git a/src/mesh/gnunet-service-mesh.c b/src/mesh/gnunet-service-mesh.c
index a5068e86c..e75bad347 100644
--- a/src/mesh/gnunet-service-mesh.c
+++ b/src/mesh/gnunet-service-mesh.c
@@ -4354,7 +4354,7 @@ tunnel_new (GNUNET_PEER_Id owner,
   t->bck_ack = INITIAL_WINDOW_SIZE - 1;
   t->last_fwd_ack = INITIAL_WINDOW_SIZE - 1;
   t->local_tid = local;
-  t->children_fc = GNUNET_CONTAINER_multihashmap_create (8);
+  t->children_fc = GNUNET_CONTAINER_multihashmap_create (8, GNUNET_NO);
   n_tunnels++;
   GNUNET_STATISTICS_update (stats, "# tunnels", 1, GNUNET_NO);
 
@@ -5286,7 +5286,7 @@ handle_mesh_path_create (void *cls, const struct GNUNET_PeerIdentity *peer,
     if (NULL == t->peers)
     {
       /* New tunnel! Notify clients on first payload message. */
-      t->peers = GNUNET_CONTAINER_multihashmap_create (4);
+      t->peers = GNUNET_CONTAINER_multihashmap_create (4, GNUNET_NO);
     }
     GNUNET_break (GNUNET_SYSERR !=
                   GNUNET_CONTAINER_multihashmap_put (t->peers,
@@ -6534,7 +6534,7 @@ handle_local_new_client (void *cls, struct GNUNET_SERVER_Client *client,
     GNUNET_MESH_ApplicationType at;
     struct GNUNET_HashCode hc;
 
-    c->apps = GNUNET_CONTAINER_multihashmap_create (napps);
+    c->apps = GNUNET_CONTAINER_multihashmap_create (napps, GNUNET_NO);
     for (i = 0; i < napps; i++)
     {
       at = ntohl (a[i]);
@@ -6558,7 +6558,7 @@ handle_local_new_client (void *cls, struct GNUNET_SERVER_Client *client,
     struct GNUNET_HashCode hc;
 
     t = (uint16_t *) & a[napps];
-    c->types = GNUNET_CONTAINER_multihashmap_create (ntypes);
+    c->types = GNUNET_CONTAINER_multihashmap_create (ntypes, GNUNET_NO);
     for (i = 0; i < ntypes; i++)
     {
       u16 = ntohs (t[i]);
@@ -6577,9 +6577,9 @@ handle_local_new_client (void *cls, struct GNUNET_SERVER_Client *client,
               " client has %u+%u subscriptions\n", napps, ntypes);
 
   GNUNET_CONTAINER_DLL_insert (clients, clients_tail, c);
-  c->own_tunnels = GNUNET_CONTAINER_multihashmap_create (32);
-  c->incoming_tunnels = GNUNET_CONTAINER_multihashmap_create (32);
-  c->ignore_tunnels = GNUNET_CONTAINER_multihashmap_create (32);
+  c->own_tunnels = GNUNET_CONTAINER_multihashmap_create (32, GNUNET_NO);
+  c->incoming_tunnels = GNUNET_CONTAINER_multihashmap_create (32, GNUNET_NO);
+  c->ignore_tunnels = GNUNET_CONTAINER_multihashmap_create (32, GNUNET_NO);
   GNUNET_SERVER_notification_context_add (nc, client);
   GNUNET_STATISTICS_update (stats, "# clients", 1, GNUNET_NO);
 
@@ -6697,7 +6697,7 @@ handle_local_tunnel_create (void *cls, struct GNUNET_SERVER_Client *client,
   next_tid = next_tid & ~GNUNET_MESH_LOCAL_TUNNEL_ID_CLI;
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "CREATED TUNNEL %s [%x] (%x)\n",
               GNUNET_i2s (&my_full_id), t->id.tid, t->local_tid);
-  t->peers = GNUNET_CONTAINER_multihashmap_create (32);
+  t->peers = GNUNET_CONTAINER_multihashmap_create (32, GNUNET_NO);
 
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "new tunnel created\n");
   GNUNET_SERVER_receive_done (client, GNUNET_OK);
@@ -7370,8 +7370,8 @@ handle_local_connect_by_string (void *cls, struct GNUNET_SERVER_Client *client,
   info->description = GNUNET_malloc (len + 1);
   memcpy (info->description, string, len);
   info->description[len] = '\0';
-  info->dht_get_handles = GNUNET_CONTAINER_multihashmap_create(32);
-  info->dht_get_results = GNUNET_CONTAINER_multihashmap_create(32);
+  info->dht_get_handles = GNUNET_CONTAINER_multihashmap_create(32, GNUNET_NO);
+  info->dht_get_results = GNUNET_CONTAINER_multihashmap_create(32, GNUNET_NO);
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "   string: %s\n", info->description);
 
   ctx = GNUNET_malloc (sizeof (struct MeshRegexSearchContext));
@@ -8261,11 +8261,11 @@ run (void *cls, struct GNUNET_SERVER_Handle *server,
     dht_replication_level = 10;
   }
 
-  tunnels = GNUNET_CONTAINER_multihashmap_create (32);
-  incoming_tunnels = GNUNET_CONTAINER_multihashmap_create (32);
-  peers = GNUNET_CONTAINER_multihashmap_create (32);
-  applications = GNUNET_CONTAINER_multihashmap_create (32);
-  types = GNUNET_CONTAINER_multihashmap_create (32);
+  tunnels = GNUNET_CONTAINER_multihashmap_create (32, GNUNET_NO);
+  incoming_tunnels = GNUNET_CONTAINER_multihashmap_create (32, GNUNET_NO);
+  peers = GNUNET_CONTAINER_multihashmap_create (32, GNUNET_NO);
+  applications = GNUNET_CONTAINER_multihashmap_create (32, GNUNET_NO);
+  types = GNUNET_CONTAINER_multihashmap_create (32, GNUNET_NO);
 
   dht_handle = GNUNET_DHT_connect (c, 64);
   if (NULL == dht_handle)
diff --git a/src/mesh/mesh_tunnel_tree.c b/src/mesh/mesh_tunnel_tree.c
index a754d9c42..b57f9410f 100644
--- a/src/mesh/mesh_tunnel_tree.c
+++ b/src/mesh/mesh_tunnel_tree.c
@@ -416,7 +416,7 @@ tree_new (GNUNET_PEER_Id peer)
   struct MeshTunnelTree *tree;
 
   tree = GNUNET_malloc (sizeof (struct MeshTunnelTree));
-  tree->first_hops = GNUNET_CONTAINER_multihashmap_create (32);
+  tree->first_hops = GNUNET_CONTAINER_multihashmap_create (32, GNUNET_NO);
   tree->root = tree_node_new (NULL, peer);
   tree->root->status = MESH_PEER_ROOT;
 
diff --git a/src/namestore/gnunet-service-namestore.c b/src/namestore/gnunet-service-namestore.c
index bd32d7155..d13221600 100644
--- a/src/namestore/gnunet-service-namestore.c
+++ b/src/namestore/gnunet-service-namestore.c
@@ -2242,7 +2242,7 @@ run (void *cls, struct GNUNET_SERVER_Handle *server,
 
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, 
               "Scanning directory `%s' for zone files\n", zonefile_directory);
-  zonekeys = GNUNET_CONTAINER_multihashmap_create (16);
+  zonekeys = GNUNET_CONTAINER_multihashmap_create (16, GNUNET_NO);
   counter = 0;
   GNUNET_DISK_directory_scan (zonefile_directory, zonekey_file_it, &counter);
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, 
diff --git a/src/nse/gnunet-service-nse.c b/src/nse/gnunet-service-nse.c
index 435f22774..d7fb439e2 100644
--- a/src/nse/gnunet-service-nse.c
+++ b/src/nse/gnunet-service-nse.c
@@ -1415,7 +1415,7 @@ key_generation_cb (void *cls,
       GNUNET_SCHEDULER_add_with_priority (GNUNET_SCHEDULER_PRIORITY_IDLE,
                                           &find_proof, NULL);
 
-  peers = GNUNET_CONTAINER_multihashmap_create (128);
+  peers = GNUNET_CONTAINER_multihashmap_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/gnunet-service-peerinfo.c b/src/peerinfo/gnunet-service-peerinfo.c
index 4b42708ab..18f10621a 100644
--- a/src/peerinfo/gnunet-service-peerinfo.c
+++ b/src/peerinfo/gnunet-service-peerinfo.c
@@ -268,7 +268,7 @@ add_host_to_known_hosts (const struct GNUNET_PeerIdentity *identity)
                             GNUNET_NO);
   entry = GNUNET_malloc (sizeof (struct HostEntry));
   entry->identity = *identity;
-  GNUNET_CONTAINER_multihashmap_put (hostmap, &identity->hashPubKey, entry,
+  GNUNET_CONTAINER_multihashmap_put (hostmap, &entry->identity.hashPubKey, entry,
                                      GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY);
   fn = get_host_filename (identity);
   entry->hello = read_host_file (fn, GNUNET_YES);
@@ -776,7 +776,7 @@ run (void *cls, struct GNUNET_SERVER_Handle *server,
   char *ip;
   struct DirScanContext dsc;
 
-  hostmap = GNUNET_CONTAINER_multihashmap_create (1024);
+  hostmap = GNUNET_CONTAINER_multihashmap_create (1024, GNUNET_YES);
   stats = GNUNET_STATISTICS_create ("peerinfo", cfg);
   notify_list = GNUNET_SERVER_notification_context_create (server, 0);
   GNUNET_assert (GNUNET_OK ==
diff --git a/src/testbed/gnunet-service-testbed.c b/src/testbed/gnunet-service-testbed.c
index 4cea07acd..b5282cffc 100644
--- a/src/testbed/gnunet-service-testbed.c
+++ b/src/testbed/gnunet-service-testbed.c
@@ -2916,7 +2916,7 @@ testbed_run (void *cls, struct GNUNET_SERVER_Handle *server,
                  (cfg, "testbed", "HOSTNAME", &hostname));
   GNUNET_SERVER_add_handlers (server, message_handlers);
   GNUNET_SERVER_disconnect_notify (server, &client_disconnect_cb, NULL);
-  ss_map = GNUNET_CONTAINER_multihashmap_create (5);
+  ss_map = GNUNET_CONTAINER_multihashmap_create (5, GNUNET_NO);
   shutdown_task_id =
       GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_FOREVER_REL,
                                     &shutdown_task, NULL);
diff --git a/src/testing_old/testing_group.c b/src/testing_old/testing_group.c
index 9191b9fdd..f5c225876 100644
--- a/src/testing_old/testing_group.c
+++ b/src/testing_old/testing_group.c
@@ -3890,9 +3890,9 @@ GNUNET_TESTING_create_topology (struct GNUNET_TESTING_PeerGroup *pg,
 
   for (i = 0; i < pg->total; i++)
   {
-    pg->peers[i].allowed_peers = GNUNET_CONTAINER_multihashmap_create (100);
-    pg->peers[i].connect_peers = GNUNET_CONTAINER_multihashmap_create (100);
-    pg->peers[i].blacklisted_peers = GNUNET_CONTAINER_multihashmap_create (100);
+    pg->peers[i].allowed_peers = GNUNET_CONTAINER_multihashmap_create (100, GNUNET_NO);
+    pg->peers[i].connect_peers = GNUNET_CONTAINER_multihashmap_create (100, GNUNET_NO);
+    pg->peers[i].blacklisted_peers = GNUNET_CONTAINER_multihashmap_create (100, GNUNET_NO);
     pg->peers[i].pg = pg;
   }
 #endif
@@ -4291,7 +4291,7 @@ choose_random_connections (struct GNUNET_TESTING_PeerGroup *pg,
     random_ctx.percentage = percentage;
     random_ctx.pg = pg;
     pg->peers[pg_iter].connect_peers_working_set =
-        GNUNET_CONTAINER_multihashmap_create (pg->total);
+      GNUNET_CONTAINER_multihashmap_create (pg->total, GNUNET_NO);
     GNUNET_CONTAINER_multihashmap_iterate (pg->peers[pg_iter].connect_peers,
                                            &random_connect_iterator,
                                            &random_ctx);
@@ -4450,7 +4450,7 @@ choose_minimum (struct GNUNET_TESTING_PeerGroup *pg, unsigned int num)
   for (pg_iter = 0; pg_iter < pg->total; pg_iter++)
   {
     pg->peers[pg_iter].connect_peers_working_set =
-        GNUNET_CONTAINER_multihashmap_create (num);
+      GNUNET_CONTAINER_multihashmap_create (num, GNUNET_NO);
   }
 
   for (pg_iter = 0; pg_iter < pg->total; pg_iter++)
@@ -4679,7 +4679,7 @@ perform_dfs (struct GNUNET_TESTING_PeerGroup *pg, unsigned int num)
   for (pg_iter = 0; pg_iter < pg->total; pg_iter++)
   {
     pg->peers[pg_iter].connect_peers_working_set =
-        GNUNET_CONTAINER_multihashmap_create (num);
+      GNUNET_CONTAINER_multihashmap_create (num, GNUNET_NO);
   }
 
   starting_peer = 0;
diff --git a/src/topology/gnunet-daemon-topology.c b/src/topology/gnunet-daemon-topology.c
index 9bd6d8e19..2dc3c148b 100644
--- a/src/topology/gnunet-daemon-topology.c
+++ b/src/topology/gnunet-daemon-topology.c
@@ -1306,7 +1306,7 @@ run (void *cls, char *const *args, const char *cfgfile,
                                              "TARGET-CONNECTION-COUNT", &opt))
     opt = 16;
   target_connection_count = (unsigned int) opt;
-  peers = GNUNET_CONTAINER_multihashmap_create (target_connection_count * 2);
+  peers = GNUNET_CONTAINER_multihashmap_create (target_connection_count * 2, GNUNET_NO);
 
   if ((friends_only == GNUNET_YES) || (minimum_friend_count > 0))
     read_friends_file (cfg);
diff --git a/src/transport/gnunet-service-transport_blacklist.c b/src/transport/gnunet-service-transport_blacklist.c
index 505326879..e426b8fd2 100644
--- a/src/transport/gnunet-service-transport_blacklist.c
+++ b/src/transport/gnunet-service-transport_blacklist.c
@@ -687,7 +687,8 @@ GST_blacklist_add_peer (const struct GNUNET_PeerIdentity *peer,
               GNUNET_i2s (peer), transport_name);
   if (blacklist == NULL)
     blacklist =
-        GNUNET_CONTAINER_multihashmap_create (TRANSPORT_BLACKLIST_HT_SIZE);
+      GNUNET_CONTAINER_multihashmap_create (TRANSPORT_BLACKLIST_HT_SIZE,
+                                            GNUNET_NO);
   GNUNET_CONTAINER_multihashmap_put (blacklist, &peer->hashPubKey,
                                      GNUNET_strdup (transport_name),
                                      GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);
diff --git a/src/transport/gnunet-service-transport_neighbours.c b/src/transport/gnunet-service-transport_neighbours.c
index dd506b125..da42b8c56 100644
--- a/src/transport/gnunet-service-transport_neighbours.c
+++ b/src/transport/gnunet-service-transport_neighbours.c
@@ -3197,7 +3197,7 @@ GST_neighbours_start (void *cls,
   connect_notify_cb = connect_cb;
   disconnect_notify_cb = disconnect_cb;
   address_change_cb = peer_address_cb;
-  neighbours = GNUNET_CONTAINER_multihashmap_create (NEIGHBOUR_TABLE_SIZE);
+  neighbours = GNUNET_CONTAINER_multihashmap_create (NEIGHBOUR_TABLE_SIZE, GNUNET_NO);
 }
 
 
diff --git a/src/transport/gnunet-service-transport_validation.c b/src/transport/gnunet-service-transport_validation.c
index 59fe1737f..ab334013d 100644
--- a/src/transport/gnunet-service-transport_validation.c
+++ b/src/transport/gnunet-service-transport_validation.c
@@ -696,7 +696,8 @@ process_peerinfo_hello (void *cls, const struct GNUNET_PeerIdentity *peer,
 void
 GST_validation_start ()
 {
-  validation_map = GNUNET_CONTAINER_multihashmap_create (VALIDATION_MAP_SIZE);
+  validation_map = GNUNET_CONTAINER_multihashmap_create (VALIDATION_MAP_SIZE,
+                                                         GNUNET_NO);
   pnc = GNUNET_PEERINFO_notify (GST_cfg, &process_peerinfo_hello, NULL);
 }
 
diff --git a/src/transport/gnunet-transport.c b/src/transport/gnunet-transport.c
index 217fbf51f..5978de6bb 100644
--- a/src/transport/gnunet-transport.c
+++ b/src/transport/gnunet-transport.c
@@ -655,7 +655,7 @@ testservice_task (void *cls,
   }
   if (iterate_connections)
   {
-    peers = GNUNET_CONTAINER_multihashmap_create (20);
+    peers = GNUNET_CONTAINER_multihashmap_create (20, GNUNET_NO);
     GNUNET_TRANSPORT_peer_get_active_addresses (cfg, NULL, GNUNET_YES,
                                                 TIMEOUT,
                                                 &process_address, (void *) cfg);
diff --git a/src/transport/plugin_transport_tcp.c b/src/transport/plugin_transport_tcp.c
index 9d23c5121..877356c16 100644
--- a/src/transport/plugin_transport_tcp.c
+++ b/src/transport/plugin_transport_tcp.c
@@ -734,7 +734,7 @@ static struct Session *
 create_session (struct Plugin *plugin, const struct GNUNET_PeerIdentity *target,
                 struct GNUNET_SERVER_Client *client, int is_nat)
 {
-  struct Session *ret;
+  struct Session *session;
   struct PendingMessage *pm;
   struct WelcomeMessage welcome;
 
@@ -746,14 +746,14 @@ create_session (struct Plugin *plugin, const struct GNUNET_PeerIdentity *target,
   LOG (GNUNET_ERROR_TYPE_DEBUG, 
        "Creating new session for peer `%4s'\n",
        GNUNET_i2s (target));
-  ret = GNUNET_malloc (sizeof (struct Session));
-  ret->last_activity = GNUNET_TIME_absolute_get ();
-  ret->plugin = plugin;
-  ret->is_nat = is_nat;
-  ret->client = client;
-  ret->target = *target;
-  ret->expecting_welcome = GNUNET_YES;
-  ret->ats_address_network_type = htonl (GNUNET_ATS_NET_UNSPECIFIED);
+  session = GNUNET_malloc (sizeof (struct Session));
+  session->last_activity = GNUNET_TIME_absolute_get ();
+  session->plugin = plugin;
+  session->is_nat = is_nat;
+  session->client = client;
+  session->target = *target;
+  session->expecting_welcome = GNUNET_YES;
+  session->ats_address_network_type = htonl (GNUNET_ATS_NET_UNSPECIFIED);
   pm = GNUNET_malloc (sizeof (struct PendingMessage) +
                       sizeof (struct WelcomeMessage));
   pm->msg = (const char *) &pm[1];
@@ -766,17 +766,17 @@ create_session (struct Plugin *plugin, const struct GNUNET_PeerIdentity *target,
   GNUNET_STATISTICS_update (plugin->env->stats,
                             gettext_noop ("# bytes currently in TCP buffers"),
                             pm->message_size, GNUNET_NO);
-  GNUNET_CONTAINER_DLL_insert (ret->pending_messages_head,
-                               ret->pending_messages_tail, pm);
+  GNUNET_CONTAINER_DLL_insert (session->pending_messages_head,
+                               session->pending_messages_tail, pm);
   if (GNUNET_YES != is_nat)
   {
     GNUNET_STATISTICS_update (plugin->env->stats,
                               gettext_noop ("# TCP sessions active"), 1,
                               GNUNET_NO);
   }
-  start_session_timeout (ret);
+  start_session_timeout (session);
 
-  return ret;
+  return session;
 }
 
 
@@ -1120,7 +1120,9 @@ tcp_plugin_send (void *cls,
        "Asked to transmit %u bytes to `%s', added message to list.\n",
        msgbuf_size, GNUNET_i2s (&session->target));
 
-  if (GNUNET_YES == GNUNET_CONTAINER_multihashmap_contains_value(plugin->sessionmap, &session->target.hashPubKey, session))
+  if (GNUNET_YES == GNUNET_CONTAINER_multihashmap_contains_value (plugin->sessionmap, 
+                                                                  &session->target.hashPubKey, 
+                                                                  session))
   {
     GNUNET_assert (session->client != NULL);
     reschedule_session_timeout (session);
@@ -1246,8 +1248,8 @@ static struct Session *
 tcp_plugin_get_session (void *cls,
                         const struct GNUNET_HELLO_Address *address)
 {
-  struct Plugin * plugin = cls;
-  struct Session * session = NULL;
+  struct Plugin *plugin = cls;
+  struct Session *session = NULL;
   int af;
   const void *sb;
   size_t sbs;
@@ -1270,7 +1272,8 @@ tcp_plugin_get_session (void *cls,
 
   /* look for existing session */
   if (GNUNET_YES == 
-      GNUNET_CONTAINER_multihashmap_contains(plugin->sessionmap, &address->peer.hashPubKey))
+      GNUNET_CONTAINER_multihashmap_contains (plugin->sessionmap, 
+                                              &address->peer.hashPubKey))
   {
     struct SessionItCtx si_ctx;
 
@@ -1279,7 +1282,9 @@ tcp_plugin_get_session (void *cls,
 
     si_ctx.result = NULL;
 
-    GNUNET_CONTAINER_multihashmap_get_multiple(plugin->sessionmap, &address->peer.hashPubKey, &session_lookup_it, &si_ctx);
+    GNUNET_CONTAINER_multihashmap_get_multiple (plugin->sessionmap, 
+                                                &address->peer.hashPubKey, 
+                                                &session_lookup_it, &si_ctx);
     if (si_ctx.result != NULL)
     {
       session = si_ctx.result;
@@ -1372,13 +1377,15 @@ tcp_plugin_get_session (void *cls,
     session->addrlen = 0;
     session->addr = NULL;
     session->ats_address_network_type = ats.value;
-    session->nat_connection_timeout = GNUNET_SCHEDULER_add_delayed(NAT_TIMEOUT,
-        &nat_connect_timeout,
-        session);
+    session->nat_connection_timeout = GNUNET_SCHEDULER_add_delayed (NAT_TIMEOUT,
+                                                                    &nat_connect_timeout,
+                                                                    session);
     GNUNET_assert (session != NULL);
-    GNUNET_assert (GNUNET_CONTAINER_multihashmap_put
-                   (plugin->nat_wait_conns, &address->peer.hashPubKey, session,
-                    GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY) == GNUNET_OK);
+    GNUNET_assert (GNUNET_OK ==
+                   GNUNET_CONTAINER_multihashmap_put (plugin->nat_wait_conns, 
+                                                      &session->target.hashPubKey, 
+                                                      session,
+                                                      GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
 
     LOG (GNUNET_ERROR_TYPE_DEBUG, 
          "Created NAT WAIT connection to `%4s' at `%s'\n",
@@ -1421,7 +1428,9 @@ tcp_plugin_get_session (void *cls,
   session->addrlen = addrlen;
   session->ats_address_network_type = ats.value;
 
-  GNUNET_CONTAINER_multihashmap_put(plugin->sessionmap, &address->peer.hashPubKey, session, GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);
+  GNUNET_CONTAINER_multihashmap_put (plugin->sessionmap, 
+                                     &session->target.hashPubKey, 
+                                     session, GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);
   inc_sessions (plugin, session, __LINE__);
   LOG (GNUNET_ERROR_TYPE_DEBUG, 
        "Creating new session for `%s' address `%s' session %p\n",
@@ -1763,9 +1772,9 @@ handle_tcp_nat_probe (void *cls, struct GNUNET_SERVER_Client *client,
                  (plugin->nat_wait_conns,
                   &tcp_nat_probe->clientIdentity.hashPubKey,
                   session) == GNUNET_YES);
-  GNUNET_CONTAINER_multihashmap_put(plugin->sessionmap,
-                                    &session->target.hashPubKey, session, 
-                                    GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);  
+  GNUNET_CONTAINER_multihashmap_put (plugin->sessionmap,
+                                     &session->target.hashPubKey, session, 
+                                     GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);  
   session->last_activity = GNUNET_TIME_absolute_get ();
   session->inbound = GNUNET_NO;
   LOG (GNUNET_ERROR_TYPE_DEBUG, 
@@ -1896,7 +1905,10 @@ handle_tcp_welcome (void *cls, struct GNUNET_SERVER_Client *client,
       LOG (GNUNET_ERROR_TYPE_DEBUG, 
            "Did not obtain TCP socket address for incoming connection\n");
     }
-    GNUNET_CONTAINER_multihashmap_put(plugin->sessionmap, &wm->clientIdentity.hashPubKey, session, GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);
+    GNUNET_CONTAINER_multihashmap_put (plugin->sessionmap, 
+                                       &session->target.hashPubKey, 
+                                       session, 
+                                       GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);
     inc_sessions (plugin, session, __LINE__);
   }
 
@@ -2332,7 +2344,7 @@ libgnunet_plugin_transport_tcp_init (void *cls)
     service = NULL;
 
   plugin = GNUNET_malloc (sizeof (struct Plugin));
-  plugin->sessionmap = GNUNET_CONTAINER_multihashmap_create(max_connections);
+  plugin->sessionmap = GNUNET_CONTAINER_multihashmap_create (max_connections, GNUNET_YES);
   plugin->max_connections = max_connections;
   plugin->open_port = bport;
   plugin->adv_port = aport;
@@ -2405,7 +2417,7 @@ libgnunet_plugin_transport_tcp_init (void *cls)
     plugin->handlers[i].callback_cls = plugin;
   GNUNET_SERVER_add_handlers (plugin->server, plugin->handlers);
   GNUNET_SERVER_disconnect_notify (plugin->server, &disconnect_notify, plugin);
-  plugin->nat_wait_conns = GNUNET_CONTAINER_multihashmap_create (16);
+  plugin->nat_wait_conns = GNUNET_CONTAINER_multihashmap_create (16, GNUNET_YES);
   if (bport != 0)
     LOG (GNUNET_ERROR_TYPE_INFO, 
          _("TCP transport listening on port %llu\n"), bport);
diff --git a/src/transport/plugin_transport_udp.c b/src/transport/plugin_transport_udp.c
index 1520bf284..bf8220164 100644
--- a/src/transport/plugin_transport_udp.c
+++ b/src/transport/plugin_transport_udp.c
@@ -2348,7 +2348,7 @@ libgnunet_plugin_transport_udp_init (void *cls)
 
   GNUNET_BANDWIDTH_tracker_init (&p->tracker,
                                  GNUNET_BANDWIDTH_value_init ((uint32_t)udp_max_bps), 30);
-  p->sessions = GNUNET_CONTAINER_multihashmap_create (10);
+  p->sessions = GNUNET_CONTAINER_multihashmap_create (10, GNUNET_NO);
   p->defrag_ctxs = GNUNET_CONTAINER_heap_create (GNUNET_CONTAINER_HEAP_ORDER_MIN);
   p->mst = GNUNET_SERVER_mst_create (&process_inbound_tokenized_messages, p);
   p->port = port;
diff --git a/src/transport/plugin_transport_unix.c b/src/transport/plugin_transport_unix.c
index c688039e6..fc1556591 100644
--- a/src/transport/plugin_transport_unix.c
+++ b/src/transport/plugin_transport_unix.c
@@ -1354,7 +1354,7 @@ libgnunet_plugin_transport_unix_init (void *cls)
   if (sockets_created == 0)
     LOG (GNUNET_ERROR_TYPE_WARNING, _("Failed to open UNIX sockets\n"));
 
-  plugin->session_map = GNUNET_CONTAINER_multihashmap_create(10);
+  plugin->session_map = GNUNET_CONTAINER_multihashmap_create (10, GNUNET_NO);
 
   GNUNET_SCHEDULER_add_now (address_notification, plugin);
   return api;
diff --git a/src/transport/transport_api.c b/src/transport/transport_api.c
index 2d4890db9..7fef0cf3e 100644
--- a/src/transport/transport_api.c
+++ b/src/transport/transport_api.c
@@ -353,7 +353,7 @@ neighbour_add (struct GNUNET_TRANSPORT_Handle *h,
                                  MAX_BANDWIDTH_CARRY_S);
   GNUNET_assert (GNUNET_OK ==
                  GNUNET_CONTAINER_multihashmap_put (h->neighbours,
-                                                    &pid->hashPubKey, n,
+                                                    &n->id.hashPubKey, n,
                                                     GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
   return n;
 }
@@ -1191,7 +1191,7 @@ GNUNET_TRANSPORT_connect (const struct GNUNET_CONFIGURATION_Handle *cfg,
   ret->nd_cb = nd;
   ret->reconnect_delay = GNUNET_TIME_UNIT_ZERO;
   ret->neighbours =
-      GNUNET_CONTAINER_multihashmap_create (STARTING_NEIGHBOURS_SIZE);
+    GNUNET_CONTAINER_multihashmap_create (STARTING_NEIGHBOURS_SIZE, GNUNET_YES);
   ret->ready_heap =
       GNUNET_CONTAINER_heap_create (GNUNET_CONTAINER_HEAP_ORDER_MIN);
   LOG (GNUNET_ERROR_TYPE_DEBUG, "Connecting to transport service.\n");
diff --git a/src/util/container_multihashmap.c b/src/util/container_multihashmap.c
index ada98251c..4a41fd015 100644
--- a/src/util/container_multihashmap.c
+++ b/src/util/container_multihashmap.c
@@ -80,10 +80,20 @@ struct GNUNET_CONTAINER_MultiHashMap
  * Create a multi hash map.
  *
  * @param len initial size (map will grow as needed)
+ * @param do_not_copy_keys GNUNET_NO is always safe and should be used by default;
+ *                         GNUNET_YES means that on 'put', the 'key' does not have
+ *                         to be copied as the destination of the pointer is 
+ *                         guaranteed to be life as long as the value is stored in
+ *                         the hashmap.  This can significantly reduce memory 
+ *                         consumption, but of course is also a recipie for 
+ *                         heap corruption if the assumption is not true.  Only
+ *                         use this if (1) memory use is important in this case and
+ *                         (2) you have triple-checked that the invariant holds
  * @return NULL on error
  */
 struct GNUNET_CONTAINER_MultiHashMap *
-GNUNET_CONTAINER_multihashmap_create (unsigned int len)
+GNUNET_CONTAINER_multihashmap_create (unsigned int len,
+                                      int do_not_copy_keys)
 {
   struct GNUNET_CONTAINER_MultiHashMap *ret;
 
diff --git a/src/util/peer.c b/src/util/peer.c
index 2444cb9f8..a0e965605 100644
--- a/src/util/peer.c
+++ b/src/util/peer.c
@@ -117,7 +117,7 @@ GNUNET_PEER_intern (const struct GNUNET_PeerIdentity *pid)
   if (pid == NULL)
     return 0;
   if (NULL == map)
-    map = GNUNET_CONTAINER_multihashmap_create (32);
+    map = GNUNET_CONTAINER_multihashmap_create (32, GNUNET_YES);
   off = (long) GNUNET_CONTAINER_multihashmap_get (map, &pid->hashPubKey);
   e = (off == 0) ? NULL : &table[off];
   if (e != NULL)
@@ -146,7 +146,7 @@ GNUNET_PEER_intern (const struct GNUNET_PeerIdentity *pid)
   table[ret].rc = 1;
   table[ret].pid = ret;
   GNUNET_break (GNUNET_OK ==
-                GNUNET_CONTAINER_multihashmap_put (map, &pid->hashPubKey,
+                GNUNET_CONTAINER_multihashmap_put (map, &table[ret].id.hashPubKey,
                                                    (void *) (long) ret,
                                                    GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
   return ret;
diff --git a/src/util/test_container_multihashmap.c b/src/util/test_container_multihashmap.c
index befd0ce46..ff50df117 100644
--- a/src/util/test_container_multihashmap.c
+++ b/src/util/test_container_multihashmap.c
@@ -40,7 +40,7 @@ testMap (int i)
   const char *ret;
   int j;
 
-  CHECK (NULL != (m = GNUNET_CONTAINER_multihashmap_create (i)));
+  CHECK (NULL != (m = GNUNET_CONTAINER_multihashmap_create (i, GNUNET_NO)));
   memset (&k1, 0, sizeof (k1));
   memset (&k2, 1, sizeof (k2));
   CHECK (GNUNET_NO == GNUNET_CONTAINER_multihashmap_contains (m, &k1));
diff --git a/src/vpn/gnunet-service-vpn.c b/src/vpn/gnunet-service-vpn.c
index 48de1de46..5a52a6cda 100644
--- a/src/vpn/gnunet-service-vpn.c
+++ b/src/vpn/gnunet-service-vpn.c
@@ -3084,9 +3084,9 @@ run (void *cls,
                                              &max_tunnel_mappings))
     max_tunnel_mappings = 200;
 
-  destination_map = GNUNET_CONTAINER_multihashmap_create (max_destination_mappings * 2);
+  destination_map = GNUNET_CONTAINER_multihashmap_create (max_destination_mappings * 2, GNUNET_NO);
   destination_heap = GNUNET_CONTAINER_heap_create (GNUNET_CONTAINER_HEAP_ORDER_MIN);
-  tunnel_map = GNUNET_CONTAINER_multihashmap_create (max_tunnel_mappings * 2);
+  tunnel_map = GNUNET_CONTAINER_multihashmap_create (max_tunnel_mappings * 2, GNUNET_NO);
   tunnel_heap = GNUNET_CONTAINER_heap_create (GNUNET_CONTAINER_HEAP_ORDER_MIN);