[GNUnet-SVN] r17116 - gnunet/src/dht

[gnunet]

Author: grothoff
Date: 2011-09-29 22:41:03 +0200 (Thu, 29 Sep 2011)
New Revision: 17116

Modified:
   gnunet/src/dht/gnunet-service-dht_neighbours.c
   gnunet/src/dht/test_dht_multipeer.c
   gnunet/src/dht/test_dht_multipeer_data.conf
Log:
cleaning up testcase, debugging

Modified: gnunet/src/dht/gnunet-service-dht_neighbours.c
===================================================================
--- gnunet/src/dht/gnunet-service-dht_neighbours.c      2011-09-29 20:31:38 UTC 
(rev 17115)
+++ gnunet/src/dht/gnunet-service-dht_neighbours.c      2011-09-29 20:41:03 UTC 
(rev 17116)
@@ -76,12 +76,12 @@
 /**
  * How long at least to wait before sending another find peer request.
  */
-#define DHT_MINIMUM_FIND_PEER_INTERVAL 
GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MINUTES, 2)
+#define DHT_MINIMUM_FIND_PEER_INTERVAL 
GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 30)
 
 /**
  * How long at most to wait before sending another find peer request.
  */
-#define DHT_MAXIMUM_FIND_PEER_INTERVAL 
GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MINUTES, 8)
+#define DHT_MAXIMUM_FIND_PEER_INTERVAL 
GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MINUTES, 10)
 
 /**
  * How long at most to wait for transmission of a GET request to another peer?
@@ -611,11 +611,11 @@
   GNUNET_CONTAINER_bloomfilter_free (peer_bf);
   GNUNET_CONTAINER_bloomfilter_free (bcc.bloom);
   /* schedule next round */
+  next_send_time.rel_value =
+    DHT_MINIMUM_FIND_PEER_INTERVAL.rel_value +
+    GNUNET_CRYPTO_random_u64 (GNUNET_CRYPTO_QUALITY_WEAK,
+                             DHT_MAXIMUM_FIND_PEER_INTERVAL.rel_value / 
(newly_found_peers+1));
   newly_found_peers = 0;
-  next_send_time.rel_value =
-    (DHT_MAXIMUM_FIND_PEER_INTERVAL.rel_value / 2) +
-    GNUNET_CRYPTO_random_u64 (GNUNET_CRYPTO_QUALITY_STRONG,
-                             DHT_MAXIMUM_FIND_PEER_INTERVAL.rel_value / 2);
   find_peer_task = GNUNET_SCHEDULER_add_delayed (next_send_time, 
                                                 &send_find_peer_message,
                                                 NULL);  
@@ -646,6 +646,9 @@
     GNUNET_break (0);
     return;
   }
+  GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+             "Peer `%s' connected!\n",
+             GNUNET_i2s (peer));
   GNUNET_STATISTICS_update (GDS_stats,
                            gettext_noop ("# Peers connected"), 1,
                            GNUNET_NO);
@@ -664,8 +667,10 @@
                               peer_bucket);
   if ( (peer_bucket > 0) &&
        (k_buckets[peer_bucket].peers_size <= bucket_size) )
+  {
     ret->preference_task = GNUNET_SCHEDULER_add_now (&update_core_preference, 
ret);
-  newly_found_peers++;
+    newly_found_peers++;
+  }
   GNUNET_assert (GNUNET_OK ==
                 GNUNET_CONTAINER_multihashmap_put (all_known_peers, 
                                                    &peer->hashPubKey, ret,
@@ -692,9 +697,6 @@
   int current_bucket;
   struct P2PPendingMessage *pos;
 
-  GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-             "Peer `%s' disconnected!\n",
-             GNUNET_i2s (peer));
   /* Check for disconnect from self message */
   if (0 == memcmp (&my_identity, peer, sizeof (struct GNUNET_PeerIdentity)))
     return;
@@ -705,6 +707,9 @@
       GNUNET_break (0);
       return;
     }
+  GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+             "Peer `%s' disconnected!\n",
+             GNUNET_i2s (peer));
   GNUNET_STATISTICS_update (GDS_stats,
                            gettext_noop ("# Peers connected"), -1,
                            GNUNET_NO);
@@ -1208,7 +1213,13 @@
                                   desired_replication_level,
                                   &targets);
   if (0 == target_count)
-    return;
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                 "Not forwarding PUT for `%s' after %u hops!\n",
+                 GNUNET_h2s (key),
+                 hop_count);
+      return;
+    }
   msize = put_path_length * sizeof (struct GNUNET_PeerIdentity) + data_size + 
sizeof (struct PeerPutMessage);
   if (msize >= GNUNET_SERVER_MAX_MESSAGE_SIZE)
   {
@@ -1306,7 +1317,13 @@
                                   desired_replication_level,
                                   &targets);
   if (0 == target_count)
-    return;
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                 "Not forwarding PUT for `%s' after %u hops!\n",
+                 GNUNET_h2s (key),
+                 hop_count);
+      return;
+    }
   reply_bf_size = GNUNET_CONTAINER_bloomfilter_get_size (reply_bf);
   msize = xquery_size + sizeof (struct PeerGetMessage) + reply_bf_size;
   if (msize >= GNUNET_SERVER_MAX_MESSAGE_SIZE)
@@ -1406,6 +1423,9 @@
   if (NULL == pi)
   {
     /* peer disconnected in the meantime, drop reply */
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+               "Not forwarding REPLY for `%s' due to predecessor disconnect\n",
+               GNUNET_h2s (key));
     return;
   }
   GNUNET_STATISTICS_update (GDS_stats,

Modified: gnunet/src/dht/test_dht_multipeer.c
===================================================================
--- gnunet/src/dht/test_dht_multipeer.c 2011-09-29 20:31:38 UTC (rev 17115)
+++ gnunet/src/dht/test_dht_multipeer.c 2011-09-29 20:41:03 UTC (rev 17116)
@@ -34,13 +34,13 @@
 #define TIMEOUT GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MINUTES, 30)
 
 /* Timeout for waiting for replies to get requests */
-#define GET_TIMEOUT GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MINUTES, 5)
+#define GET_TIMEOUT GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 60)
 
 /* Timeout for waiting for gets to complete */
-#define GET_DELAY GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 1)
+#define GET_DELAY GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MILLISECONDS, 
50)
 
 /* Timeout for waiting for puts to complete */
-#define PUT_DELAY GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 1)
+#define PUT_DELAY GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MILLISECONDS, 
50)
 
 /* If number of peers not in config file, use this number */
 #define DEFAULT_NUM_PEERS 10
@@ -53,8 +53,8 @@
 
 #define PATH_TRACKING GNUNET_YES
 
-/* Structs */
 
+
 struct TestPutContext
 {
   /**
@@ -63,6 +63,11 @@
   struct TestPutContext *next;
 
   /**
+   * This is a linked list
+   */
+  struct TestPutContext *prev;
+
+  /**
    * Handle to the first peers DHT service (via the API)
    */
   struct GNUNET_DHT_Handle *dht_handle;
@@ -78,17 +83,25 @@
   uint32_t uid;
 
   /**
-   * Task for disconnecting DHT handles
+   * Task handle for processing of the put.
    */
-  GNUNET_SCHEDULER_TaskIdentifier disconnect_task;
+  GNUNET_SCHEDULER_TaskIdentifier task;
 };
 
+
 struct TestGetContext
 {
-  /* This is a linked list */
+  /**
+   * This is a linked list 
+   */
   struct TestGetContext *next;
 
   /**
+   * This is a linked list 
+   */
+  struct TestGetContext *prev;
+
+  /**
    * Handle to the first peers DHT service (via the API)
    */
   struct GNUNET_DHT_Handle *dht_handle;
@@ -111,7 +124,7 @@
   /**
    * Task for disconnecting DHT handles (and stopping GET)
    */
-  GNUNET_SCHEDULER_TaskIdentifier disconnect_task;
+  GNUNET_SCHEDULER_TaskIdentifier task;
 
   /**
    * Whether or not this request has been fulfilled already.
@@ -119,19 +132,28 @@
   int succeeded;
 };
 
-/* Globals */
 
 /**
  * List of GETS to perform
  */
-struct TestGetContext *all_gets;
+static struct TestGetContext *all_gets_head;
 
 /**
+ * List of GETS to perform
+ */
+static struct TestGetContext *all_gets_tail;
+
+/**
  * List of PUTS to perform
  */
-struct TestPutContext *all_puts;
+static struct TestPutContext *all_puts_head;
 
 /**
+ * List of PUTS to perform
+ */
+static struct TestPutContext *all_puts_tail;
+
+/**
  * Handle to the set of all peers run for this test.
  */
 static struct GNUNET_TESTING_PeerGroup *pg;
@@ -181,9 +203,12 @@
  */
 static GNUNET_SCHEDULER_TaskIdentifier die_task;
 
-/* Global return value (0 for success, anything else for failure) */
+/**
+ * Global return value (0 for success, anything else for failure)
+ */
 static int ok;
 
+
 /**
  * Check whether peers successfully shut down.
  */
@@ -200,19 +225,7 @@
   }
 }
 
-/**
- * Task to release DHT handles for PUT
- */
-static void
-put_disconnect_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
-{
-  struct TestPutContext *test_put = cls;
 
-  test_put->disconnect_task = GNUNET_SCHEDULER_NO_TASK;
-  GNUNET_DHT_disconnect (test_put->dht_handle);
-  test_put->dht_handle = NULL;
-}
-
 /**
  * Function scheduled to be run on the successful completion of this
  * testcase.
@@ -220,32 +233,39 @@
 static void
 finish_testing (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
-  GNUNET_assert (pg != NULL);
-  struct TestPutContext *test_put = all_puts;
-  struct TestGetContext *test_get = all_gets;
+  struct TestPutContext *test_put;
+  struct TestGetContext *test_get;
 
-  while (test_put != NULL)
+  die_task = GNUNET_SCHEDULER_NO_TASK;
+  while (NULL != (test_put = all_puts_head))
   {
-    if (test_put->disconnect_task != GNUNET_SCHEDULER_NO_TASK)
-      GNUNET_SCHEDULER_cancel (test_put->disconnect_task);
+    if (test_put->task != GNUNET_SCHEDULER_NO_TASK)
+      GNUNET_SCHEDULER_cancel (test_put->task);
     if (test_put->dht_handle != NULL)
       GNUNET_DHT_disconnect (test_put->dht_handle);
-    test_put = test_put->next;
+    GNUNET_CONTAINER_DLL_remove (all_puts_head,
+                                all_puts_tail,
+                                test_put);
+    GNUNET_free (test_put);
   }
 
-  while (test_get != NULL)
+  while (NULL != (test_get = all_gets_head))
   {
-    if (test_get->disconnect_task != GNUNET_SCHEDULER_NO_TASK)
-      GNUNET_SCHEDULER_cancel (test_get->disconnect_task);
+    if (test_get->task != GNUNET_SCHEDULER_NO_TASK)
+      GNUNET_SCHEDULER_cancel (test_get->task);
     if (test_get->get_handle != NULL)
       GNUNET_DHT_get_stop (test_get->get_handle);
     if (test_get->dht_handle != NULL)
       GNUNET_DHT_disconnect (test_get->dht_handle);
-    test_get = test_get->next;
+    GNUNET_CONTAINER_DLL_remove (all_gets_head,
+                                all_gets_tail,
+                                test_get);
+    GNUNET_free (test_get);
   }
 
+  ok = 0;
   GNUNET_TESTING_daemons_stop (pg, TIMEOUT, &shutdown_callback, NULL);
-  ok = 0;
+  pg = NULL;
 }
 
 
@@ -258,36 +278,41 @@
 end_badly (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   const char *emsg = cls;
+  struct TestPutContext *test_put;
+  struct TestGetContext *test_get;
 
+  die_task = GNUNET_SCHEDULER_NO_TASK;
   fprintf (stderr, 
           "Failing test with error: `%s'!\n",
           emsg);
-
-  struct TestPutContext *test_put = all_puts;
-  struct TestGetContext *test_get = all_gets;
-
-  while (test_put != NULL)
+  while (NULL != (test_put = all_puts_head))
   {
-    if (test_put->disconnect_task != GNUNET_SCHEDULER_NO_TASK)
-      GNUNET_SCHEDULER_cancel (test_put->disconnect_task);
+    if (test_put->task != GNUNET_SCHEDULER_NO_TASK)
+      GNUNET_SCHEDULER_cancel (test_put->task);
     if (test_put->dht_handle != NULL)
       GNUNET_DHT_disconnect (test_put->dht_handle);
-    test_put = test_put->next;
+    GNUNET_CONTAINER_DLL_remove (all_puts_head,
+                                all_puts_tail,
+                                test_put);
+    GNUNET_free (test_put);
   }
 
-  while (test_get != NULL)
+  while (NULL != (test_get = all_gets_head))
   {
-    if (test_get->disconnect_task != GNUNET_SCHEDULER_NO_TASK)
-      GNUNET_SCHEDULER_cancel (test_get->disconnect_task);
+    if (test_get->task != GNUNET_SCHEDULER_NO_TASK)
+      GNUNET_SCHEDULER_cancel (test_get->task);
     if (test_get->get_handle != NULL)
       GNUNET_DHT_get_stop (test_get->get_handle);
     if (test_get->dht_handle != NULL)
       GNUNET_DHT_disconnect (test_get->dht_handle);
-    test_get = test_get->next;
+    GNUNET_CONTAINER_DLL_remove (all_gets_head,
+                                all_gets_tail,
+                                test_get);
+    GNUNET_free (test_get);
   }
-
+  ok = 1;
   GNUNET_TESTING_daemons_stop (pg, TIMEOUT, &shutdown_callback, NULL);
-  ok = 1;
+  pg = NULL;
 }
 
 
@@ -301,16 +326,16 @@
   GNUNET_HashCode search_key;   /* Key stored under */
   char original_data[TEST_DATA_SIZE];   /* Made up data to store */
 
-  test_get->disconnect_task = GNUNET_SCHEDULER_NO_TASK;
+  test_get->task = GNUNET_SCHEDULER_NO_TASK;
   memset (original_data, test_get->uid, sizeof (original_data));
   GNUNET_CRYPTO_hash (original_data, TEST_DATA_SIZE, &search_key);
-
   if (test_get->succeeded != GNUNET_YES)
   {
     gets_failed++;
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                "Get from peer %s for key %s failed!\n",
-                test_get->daemon->shortname, GNUNET_h2s (&search_key));
+    fprintf (stderr,
+            "Get from peer %s for key %s failed!\n",
+            GNUNET_i2s (&test_get->daemon->id), 
+            GNUNET_h2s (&search_key));
   }
   GNUNET_assert (test_get->get_handle != NULL);
   GNUNET_DHT_get_stop (test_get->get_handle);
@@ -323,23 +348,27 @@
   fprintf (stderr,
           "%llu gets succeeded, %llu gets failed!\n",
           gets_completed, gets_failed);
+  GNUNET_CONTAINER_DLL_remove (all_gets_head,
+                              all_gets_tail,
+                              test_get);
+  GNUNET_free (test_get);
+
   if ((gets_failed > 0) && (outstanding_gets == 0))       /* Had some failures 
*/
   {
-      GNUNET_SCHEDULER_cancel (die_task);
-      die_task =
-        GNUNET_SCHEDULER_add_now (&end_badly, "not all gets succeeded");
-      return;
+    GNUNET_SCHEDULER_cancel (die_task);
+    die_task = GNUNET_SCHEDULER_add_now (&end_badly, "not all gets succeeded");
+    return;
   }
 
   if ( (gets_completed == num_peers * num_peers) && 
        (outstanding_gets == 0) )  /* All gets successful */
   {
     GNUNET_SCHEDULER_cancel (die_task);
-    //GNUNET_SCHEDULER_add_delayed 
(GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MINUTES, 5), &get_topology, 
NULL);
     die_task = GNUNET_SCHEDULER_add_now (&finish_testing, NULL);
   }
 }
 
+
 /**
  * Iterator called if the GET request initiated returns a response.
  *
@@ -366,7 +395,6 @@
 
   memset (original_data, test_get->uid, sizeof (original_data));
   GNUNET_CRYPTO_hash (original_data, TEST_DATA_SIZE, &search_key);
-
   if (test_get->succeeded == GNUNET_YES)
     return;                     /* Get has already been successful, probably 
ending now */
 
@@ -394,18 +422,14 @@
   if ((0 != memcmp (&search_key, key, sizeof (GNUNET_HashCode))) ||
       (0 != memcmp (original_data, data, sizeof (original_data))))
   {
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                "Key or data is not the same as was inserted!\n");
+    fprintf (stderr,
+            "Key or data is not the same as was inserted!\n");
+    return;
   }
-  else
-  {
-    gets_completed++;
-    test_get->succeeded = GNUNET_YES;
-  }
-
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Received correct GET response!\n");
-  GNUNET_SCHEDULER_cancel (test_get->disconnect_task);
-  test_get->disconnect_task = GNUNET_SCHEDULER_add_now (&get_stop_task, 
test_get);
+  gets_completed++;
+  test_get->succeeded = GNUNET_YES;  
+  GNUNET_SCHEDULER_cancel (test_get->task);
+  test_get->task = GNUNET_SCHEDULER_add_now (&get_stop_task, test_get);
 }
 
 
@@ -419,36 +443,45 @@
   GNUNET_HashCode key;          /* Made up key to store data under */
   char data[TEST_DATA_SIZE];    /* Made up data to store */
 
-  if (test_get == NULL)
-    return;                     /* End of the list */
-  memset (data, test_get->uid, sizeof (data));
-  GNUNET_CRYPTO_hash (data, TEST_DATA_SIZE, &key);
-
   if (outstanding_gets > MAX_OUTSTANDING_GETS)
   {
     GNUNET_SCHEDULER_add_delayed (GET_DELAY, &do_get, test_get);
     return;
   }
-
+  memset (data, test_get->uid, sizeof (data));
+  GNUNET_CRYPTO_hash (data, TEST_DATA_SIZE, &key);
   test_get->dht_handle = GNUNET_DHT_connect (test_get->daemon->cfg, 10);
-  /* Insert the data at the first peer */
   GNUNET_assert (test_get->dht_handle != NULL);
   outstanding_gets++;
   test_get->get_handle =
-      GNUNET_DHT_get_start (test_get->dht_handle, GNUNET_TIME_UNIT_FOREVER_REL,
-                            GNUNET_BLOCK_TYPE_TEST, &key,
-                            1, route_option, NULL, 0,
-                            &get_result_iterator, test_get);
-#if VERBOSE
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Starting get for uid %u from peer 
%s\n",
-              test_get->uid, test_get->daemon->shortname);
-#endif
-  test_get->disconnect_task =
-      GNUNET_SCHEDULER_add_delayed (GET_TIMEOUT, &get_stop_task, test_get);
-  GNUNET_SCHEDULER_add_now (&do_get, test_get->next);
+    GNUNET_DHT_get_start (test_get->dht_handle, GNUNET_TIME_UNIT_FOREVER_REL,
+                         GNUNET_BLOCK_TYPE_TEST, &key,
+                         1, route_option, NULL, 0,
+                         &get_result_iterator, test_get);
+  test_get->task =
+    GNUNET_SCHEDULER_add_delayed (GET_TIMEOUT, &get_stop_task, test_get);
 }
 
+
 /**
+ * Task to release DHT handles for PUT
+ */
+static void
+put_disconnect_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+{
+  struct TestPutContext *test_put = cls;
+
+  test_put->task = GNUNET_SCHEDULER_NO_TASK;
+  GNUNET_DHT_disconnect (test_put->dht_handle);
+  test_put->dht_handle = NULL;
+  GNUNET_CONTAINER_DLL_remove (all_puts_head,
+                              all_puts_tail,
+                              test_put);
+  GNUNET_free (test_put);
+}
+
+
+/**
  * Called when the PUT request has been transmitted to the DHT service.
  * Schedule the GET request for some time in the future.
  */
@@ -456,23 +489,37 @@
 put_finished (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   struct TestPutContext *test_put = cls;
+  unsigned long long i;
+  unsigned long long j;
+  struct TestGetContext *test_get;
 
   outstanding_puts--;
   puts_completed++;
-
-  GNUNET_SCHEDULER_cancel (test_put->disconnect_task);
-  test_put->disconnect_task =
+  GNUNET_SCHEDULER_cancel (test_put->task);
+  test_put->task =
       GNUNET_SCHEDULER_add_now (&put_disconnect_task, test_put);
-  if (puts_completed == num_peers)
-  {
-    GNUNET_assert (outstanding_puts == 0);
-    GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply
-                                  (GNUNET_TIME_UNIT_SECONDS, 10), &do_get,
-                                  all_gets);
+  if (puts_completed != num_peers)
     return;
-  }
+
+  GNUNET_assert (outstanding_puts == 0);
+  fprintf (stderr, 
+          "Issuing %llu GETs\n",
+          num_peers * num_peers);
+  for (i = 0; i < num_peers; i++)
+    for (j = 0; j < num_peers; j++)
+      {
+       test_get = GNUNET_malloc (sizeof (struct TestGetContext));
+       test_get->uid = i;
+       test_get->daemon = GNUNET_TESTING_daemon_get (pg, j);
+       GNUNET_CONTAINER_DLL_insert (all_gets_head,
+                                    all_gets_tail,
+                                    test_get);
+       test_get->task = GNUNET_SCHEDULER_add_now (&do_get,
+                                                  test_get);
+      }
 }
 
+
 /**
  * Set up some data, and call API PUT function
  */
@@ -483,24 +530,15 @@
   GNUNET_HashCode key;          /* Made up key to store data under */
   char data[TEST_DATA_SIZE];    /* Made up data to store */
 
-  if (test_put == NULL)
-    return;                     /* End of list */
-
-  memset (data, test_put->uid, sizeof (data));
-  GNUNET_CRYPTO_hash (data, TEST_DATA_SIZE, &key);
-
+  test_put->task = GNUNET_SCHEDULER_NO_TASK;
   if (outstanding_puts > MAX_OUTSTANDING_PUTS)
   {
-    GNUNET_SCHEDULER_add_delayed (PUT_DELAY, &do_put, test_put);
+    test_put->task = GNUNET_SCHEDULER_add_delayed (PUT_DELAY, &do_put, 
test_put);
     return;
   }
-
-#if VERBOSE
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Starting put for uid %u from peer 
%s\n",
-              test_put->uid, test_put->daemon->shortname);
-#endif
+  memset (data, test_put->uid, sizeof (data));
+  GNUNET_CRYPTO_hash (data, TEST_DATA_SIZE, &key);
   test_put->dht_handle = GNUNET_DHT_connect (test_put->daemon->cfg, 10);
-
   GNUNET_assert (test_put->dht_handle != NULL);
   outstanding_puts++;
   fprintf (stderr, "PUT %u at `%s'\n",
@@ -510,10 +548,9 @@
                   route_option, GNUNET_BLOCK_TYPE_TEST, sizeof (data), data,
                   GNUNET_TIME_UNIT_FOREVER_ABS, GNUNET_TIME_UNIT_FOREVER_REL,
                   &put_finished, test_put);
-  test_put->disconnect_task =
+  test_put->task =
     GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_FOREVER_REL,
                                  &put_disconnect_task, test_put);
-  GNUNET_SCHEDULER_add_now (&do_put, test_put->next);
 }
 
 
@@ -529,9 +566,7 @@
 run_dht_test (void *cls, const char *emsg)
 {
   unsigned long long i;
-  unsigned long long j;
   struct TestPutContext *test_put;
-  struct TestGetContext *test_get;
 
   if (emsg != NULL)
   {
@@ -560,23 +595,11 @@
     test_put = GNUNET_malloc (sizeof (struct TestPutContext));
     test_put->uid = i;
     test_put->daemon = GNUNET_TESTING_daemon_get (pg, i);    
-    test_put->next = all_puts;
-    all_puts = test_put;
+    test_put->task = GNUNET_SCHEDULER_add_now (&do_put, test_put);
+    GNUNET_CONTAINER_DLL_insert (all_puts_head,
+                                all_puts_tail,
+                                test_put);
   }
-  GNUNET_SCHEDULER_add_now (&do_put, all_puts);
-
-  fprintf (stderr, 
-          "Issuing %llu GETs\n",
-          num_peers * num_peers);
-  for (i = 0; i < num_peers; i++)
-    for (j = 0; j < num_peers; j++)
-      {
-       test_get = GNUNET_malloc (sizeof (struct TestGetContext));
-       test_get->uid = i;
-       test_get->daemon = GNUNET_TESTING_daemon_get (pg, j);
-       test_get->next = all_gets;
-       all_gets = test_get;
-      }
 }
 
 
@@ -604,11 +627,7 @@
                                       &run_dht_test,
                                       NULL,
                                       NULL);
-  if (NULL == pg)
-    {
-      GNUNET_break (0);
-      return;
-    }
+  GNUNET_assert (NULL != pg);
 }
 
 

Modified: gnunet/src/dht/test_dht_multipeer_data.conf
===================================================================
--- gnunet/src/dht/test_dht_multipeer_data.conf 2011-09-29 20:31:38 UTC (rev 
17115)
+++ gnunet/src/dht/test_dht_multipeer_data.conf 2011-09-29 20:41:03 UTC (rev 
17116)
@@ -81,7 +81,12 @@
 
 [TESTING]
 TOPOLOGY = FROM_FILE
+# file contains a ring
 CONNECT_TOPOLOGY = NONE
+# None == use all allowed connections
+# BLACKLIST_TOPOLOGY = X
+# No additional restrictions...
+
 TOPOLOGY_FILE = multipeer_topo.dat
 MAX_CONCURRENT_SSH = 1
 PEERGROUP_TIMEOUT = 10000