gnunet-svn
[Top][All Lists]
Advanced

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

[GNUnet-SVN] r14279 - gnunet/src/testing


From: gnunet
Subject: [GNUnet-SVN] r14279 - gnunet/src/testing
Date: Thu, 27 Jan 2011 20:25:53 +0100

Author: nevans
Date: 2011-01-27 20:25:53 +0100 (Thu, 27 Jan 2011)
New Revision: 14279

Modified:
   gnunet/src/testing/test_testing_group_remote.c
   gnunet/src/testing/test_testing_topology.c
   gnunet/src/testing/testing.c
   gnunet/src/testing/testing_group.c
Log:
reduce topology overheads in testing, probably breaking some stuff

Modified: gnunet/src/testing/test_testing_group_remote.c
===================================================================
--- gnunet/src/testing/test_testing_group_remote.c      2011-01-27 13:26:11 UTC 
(rev 14278)
+++ gnunet/src/testing/test_testing_group_remote.c      2011-01-27 19:25:53 UTC 
(rev 14279)
@@ -85,14 +85,14 @@
   peers_left--;
   if (peers_left == 0)
     {
-      //GNUNET_TESTING_daemons_stop (pg, TIMEOUT, &shutdown_callback, NULL);
+      GNUNET_TESTING_daemons_stop (pg, TIMEOUT, &shutdown_callback, NULL);
       ok = 0;
     }
   else if (peers_failed == peers_left)
     {
       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                   "Too many peers failed, ending test!\n");
-      //GNUNET_TESTING_daemons_stop (pg, TIMEOUT, &shutdown_callback, NULL);
+      GNUNET_TESTING_daemons_stop (pg, TIMEOUT, &shutdown_callback, NULL);
     }
 }
 

Modified: gnunet/src/testing/test_testing_topology.c
===================================================================
--- gnunet/src/testing/test_testing_topology.c  2011-01-27 13:26:11 UTC (rev 
14278)
+++ gnunet/src/testing/test_testing_topology.c  2011-01-27 19:25:53 UTC (rev 
14279)
@@ -279,6 +279,7 @@
   total_server_connections -= 2;
 }
 
+#if DO_STATS
 static void
 stats_finished (void *cls, int result)
 {
@@ -306,6 +307,7 @@
               GNUNET_i2s (peer), subsystem, name, value);
   return GNUNET_OK;
 }
+#endif
 
 static void
 topology_cb (void *cls,
@@ -331,9 +333,11 @@
         {
           fprintf (outfile, "}\n");
           fclose (outfile);
+#if DO_STATS
           GNUNET_TESTING_get_statistics (pg, &stats_finished, &stats_print,
                                          NULL);
-          //GNUNET_SCHEDULER_add_now (&finish_testing, NULL);
+#endif
+          GNUNET_SCHEDULER_add_now (&finish_testing, NULL);
         }
     }
 }
@@ -811,18 +815,19 @@
                                          connect_topology_option,
                                          connect_topology_option_modifier,
                                          &topology_creation_finished, NULL);
-#if VERBOSE > 1
+#if VERBOSE
       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                   "Have %d expected connections\n", expected_connections);
 #endif
     }
 
   GNUNET_SCHEDULER_cancel (die_task);
-  if (expected_connections == GNUNET_SYSERR)
+  if (expected_connections < 1)
     {
       die_task =
         GNUNET_SCHEDULER_add_now (&end_badly,
                                   "from connect topology (bad return)");
+      return;
     }
 
   die_task = GNUNET_SCHEDULER_add_delayed (TEST_TIMEOUT,

Modified: gnunet/src/testing/testing.c
===================================================================
--- gnunet/src/testing/testing.c        2011-01-27 13:26:11 UTC (rev 14278)
+++ gnunet/src/testing/testing.c        2011-01-27 19:25:53 UTC (rev 14279)
@@ -453,7 +453,7 @@
       if (NULL == d->hostname)
         {
 #if DEBUG_TESTING
-          GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+          GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                       "Starting `%s', with command `%s %s %s %s %s %s'.\n",
                       "gnunet-arm", "gnunet-arm", "-c", d->cfgfile,
                       "-L", "DEBUG", "-s");
@@ -473,7 +473,7 @@
             dst = GNUNET_strdup (d->hostname);
 
 #if DEBUG_TESTING
-          GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+          GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                       "Starting `%s', with command `%s %s %s %s %s %s %s 
%s'.\n",
                       "gnunet-arm", "ssh", dst, "gnunet-arm", "-c",
                       d->cfgfile, "-L", "DEBUG", "-s", "-q");
@@ -526,7 +526,7 @@
           return;
         }
 #if DEBUG_TESTING
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                   "Started `%s', waiting for `%s' to be up.\n",
                   "gnunet-arm", "gnunet-service-core");
 #endif
@@ -551,6 +551,7 @@
                     (NULL == d->hostname)
                     ? _("`gnunet-arm' does not seem to terminate.\n")
                     : _("`ssh' does not seem to terminate.\n"));
+              GNUNET_free(d->proc);
               return;
             }
           /* wait some more */
@@ -560,10 +561,15 @@
           return;
         }
 #if DEBUG_TESTING
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                   "Successfully started `%s'.\n", "gnunet-arm");
 #endif
+      GNUNET_free(d->proc);
       d->phase = SP_START_CORE;
+#if DEBUG_TESTING
+      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                  "Calling CORE_connect\n");
+#endif
       d->server = GNUNET_CORE_connect (d->cfg, 1,
 #if NO_MORE_TIMEOUT_FIXME
                                        ARM_START_WAIT,
@@ -604,6 +610,8 @@
               GNUNET_free_non_null (d->hostname);
               GNUNET_free_non_null (d->username);
               GNUNET_free_non_null (d->shortname);
+              GNUNET_free_non_null (d->proc);
+              d->proc = NULL;
               GNUNET_free (d);
               return;
             }
@@ -636,6 +644,8 @@
           GNUNET_free_non_null (d->hostname);
           GNUNET_free_non_null (d->username);
           GNUNET_free_non_null (d->shortname);
+          GNUNET_free_non_null (d->proc);
+          d->proc = NULL;
           GNUNET_free (d);
           return;
         }
@@ -666,6 +676,8 @@
       GNUNET_free_non_null (d->hello);
       d->hello = NULL;
       GNUNET_free_non_null (d->shortname);
+      GNUNET_free_non_null (d->proc);
+      d->proc = NULL;
       d->shortname = NULL;
       if (NULL != d->dead_cb)
         d->dead_cb (d->dead_cb_cls, NULL);
@@ -815,7 +827,10 @@
   char *arg;
   char *username;
   char *servicehome;
+  char *baseservicehome;
+  char *slash;
   char *hostkeyfile;
+  char *temp_file_name;
   struct GNUNET_DISK_FileHandle *fn;
 
   ret = GNUNET_malloc (sizeof (struct GNUNET_TESTING_Daemon));
@@ -826,7 +841,18 @@
     }
   else
     ret->ssh_port_str = NULL;
-  ret->cfgfile = GNUNET_DISK_mktemp ("gnunet-testing-config");
+
+  /* Find service home and base service home directories, create it if it 
doesn't exist */
+  GNUNET_assert(GNUNET_OK ==
+                GNUNET_CONFIGURATION_get_value_string (cfg,
+                                                       "PATHS",
+                                                       "SERVICEHOME",
+                                                       &servicehome));
+
+  GNUNET_assert (GNUNET_OK == GNUNET_DISK_directory_create (servicehome));
+  GNUNET_asprintf(&temp_file_name, "%s/gnunet-testing-config", servicehome);
+  ret->cfgfile = GNUNET_DISK_mktemp (temp_file_name);
+  GNUNET_free(temp_file_name);
 #if DEBUG_TESTING
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "Setting up peer with configuration file `%s'.\n",
@@ -848,14 +874,11 @@
   GNUNET_CONFIGURATION_set_value_string (ret->cfg,
                                          "PATHS",
                                          "DEFAULTCONFIG", ret->cfgfile);
+
+  /* Write hostkey to file, if we were given one */
+  hostkeyfile = NULL;
   if (hostkey != NULL)
     {
-      GNUNET_assert(GNUNET_OK ==
-                    GNUNET_CONFIGURATION_get_value_string (ret->cfg,
-                                                           "PATHS",
-                                                           "SERVICEHOME",
-                                                           &servicehome));
-      GNUNET_assert (GNUNET_OK == GNUNET_DISK_directory_create (servicehome));
       GNUNET_asprintf(&hostkeyfile, "%s/.hostkey", servicehome);
       fn =
       GNUNET_DISK_file_open (hostkeyfile,
@@ -866,11 +889,9 @@
       GNUNET_assert(fn != NULL);
       GNUNET_assert(HOSTKEYFILESIZE == GNUNET_DISK_file_write(fn, hostkey, 
HOSTKEYFILESIZE));
       GNUNET_assert(GNUNET_OK == GNUNET_DISK_file_close(fn));
-      GNUNET_free(servicehome);
-      GNUNET_free(hostkeyfile);
     }
 
-  /* 1) write configuration to temporary file */
+  /* write configuration to temporary file */
   if (GNUNET_OK != GNUNET_CONFIGURATION_write (ret->cfg, ret->cfgfile))
     {
       if (0 != UNLINK (ret->cfgfile))
@@ -897,42 +918,54 @@
     }
   ret->username = username;
 
-  /* 2) copy file to remote host */
+  /* copy directory to remote host */
   if (NULL != hostname)
     {
 #if DEBUG_TESTING
       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Copying configuration file to host `%s'.\n", hostname);
+                  "Copying configuration directory to host `%s'.\n", hostname);
 #endif
+      baseservicehome = GNUNET_strdup(servicehome);
+      /* Remove trailing /'s */
+      while (baseservicehome[strlen(baseservicehome) - 1] == '/')
+        baseservicehome[strlen(baseservicehome) - 1] = '\0';
+      /* Find next directory /, jump one ahead */
+      slash = strrchr(baseservicehome, '/');
+      if (slash != NULL)
+        *(++slash) = '\0';
+
       ret->phase = SP_COPYING;
       if (NULL != username)
-        GNUNET_asprintf (&arg, "address@hidden:%s", username, hostname, 
ret->cfgfile);
+        GNUNET_asprintf (&arg, "address@hidden:%s", username, hostname, 
baseservicehome);
       else
-        GNUNET_asprintf (&arg, "%s:%s", hostname, ret->cfgfile);
+        GNUNET_asprintf (&arg, "%s:%s", hostname, baseservicehome);
 
       if (ret->ssh_port_str == NULL)
         {
-          ret->proc = GNUNET_OS_start_process (NULL, NULL, "scp", "scp",
+          ret->proc = GNUNET_OS_start_process (NULL, NULL, "scp", "scp", "-r",
 #if !DEBUG_TESTING
                                                "-q",
 #endif
-                                               ret->cfgfile, arg, NULL);
+                                               servicehome, arg, NULL);
+#if DEBUG_TESTING
+          GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "copying directory with 
command scp -r %s %s\n", servicehome, arg);
+#endif
         }
       else
         {
           ret->proc = GNUNET_OS_start_process (NULL, NULL, "scp",
-                                               "scp", "-P", ret->ssh_port_str,
+                                               "scp", "-r", "-P", 
ret->ssh_port_str,
 #if !DEBUG_TESTING
                                                "-q",
 #endif
-                                               ret->cfgfile, arg, NULL);
+                                               servicehome, arg, NULL);
         }
       GNUNET_free (arg);
       if (NULL == ret->proc)
         {
           GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                       _
-                      ("Could not start `%s' process to copy configuration 
file.\n"),
+                      ("Could not start `%s' process to copy configuration 
directory.\n"),
                       "scp");
           if (0 != UNLINK (ret->cfgfile))
             GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING,
@@ -942,11 +975,19 @@
           GNUNET_free_non_null (ret->username);
           GNUNET_free (ret->cfgfile);
           GNUNET_free (ret);
+          if ((hostkey != NULL) && (0 != UNLINK(hostkeyfile)))
+            GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING,
+                                      "unlink", hostkeyfile);
+          GNUNET_free_non_null(hostkeyfile);
+          GNUNET_assert (GNUNET_OK == GNUNET_DISK_directory_remove 
(servicehome));
+          GNUNET_free(servicehome);
           return NULL;
         }
       ret->task
         = GNUNET_SCHEDULER_add_delayed (GNUNET_CONSTANTS_EXEC_WAIT,
                                         &start_fsm, ret);
+      GNUNET_free_non_null(hostkeyfile);
+      GNUNET_free(servicehome);
       return ret;
     }
 #if DEBUG_TESTING
@@ -957,6 +998,8 @@
   GNUNET_SCHEDULER_add_continuation (&start_fsm,
                                      ret,
                                      GNUNET_SCHEDULER_REASON_PREREQ_DONE);
+  GNUNET_free_non_null(hostkeyfile);
+  GNUNET_free(servicehome);
   return ret;
 }
 

Modified: gnunet/src/testing/testing_group.c
===================================================================
--- gnunet/src/testing/testing_group.c  2011-01-27 13:26:11 UTC (rev 14278)
+++ gnunet/src/testing/testing_group.c  2011-01-27 19:25:53 UTC (rev 14279)
@@ -30,12 +30,14 @@
 #include "gnunet_testing_lib.h"
 #include "gnunet_core_service.h"
 
-#define VERBOSE_TESTING GNUNET_NO
+#define VERBOSE_TESTING GNUNET_YES
 
 #define VERBOSE_TOPOLOGY GNUNET_YES
 
 #define DEBUG_CHURN GNUNET_NO
 
+#define OLD 1
+
 /**
  * Lowest port used for GNUnet testing.  Should be high enough to not
  * conflict with other applications running on the hosts but be low
@@ -53,17 +55,35 @@
 
 #define MAX_OUTSTANDING_CONNECTIONS 200
 
-#define MAX_CONCURRENT_HOSTKEYS 200
+#define MAX_CONCURRENT_HOSTKEYS 500
 
 #define MAX_CONCURRENT_STARTING 200
 
-#define MAX_CONCURRENT_SHUTDOWN 100
+#define MAX_CONCURRENT_SHUTDOWN 200
 
 #define CONNECT_TIMEOUT GNUNET_TIME_relative_multiply 
(GNUNET_TIME_UNIT_SECONDS, 180)
 
 #define CONNECT_ATTEMPTS 30
 
 /**
+ * Which list of peers do we need to modify?
+ */
+enum PeerLists
+{
+  /** Modify allowed peers */
+  ALLOWED,
+
+  /** Modify connect peers */
+  CONNECT,
+
+  /** Modify blacklist peers */
+  BLACKLIST,
+
+  /** Modify workingset peers */
+  WORKING_SET
+};
+
+/**
  * Prototype of a function called whenever two peers would be connected
  * in a certain topology.
  */
@@ -73,7 +93,8 @@
                                                             unsigned int
                                                             first,
                                                             unsigned int
-                                                            second);
+                                                            second,
+                                                            enum PeerLists 
list);
 
 
 /**
@@ -244,18 +265,25 @@
   OTHER_PEER_INDEX
 };
 
+
 #if OLD
 struct PeerConnection
 {
+  /**
+   * Doubly Linked list
+   */
+  struct PeerConnection *prev;
+
   /*
-   * Linked list
+   * Doubly Linked list
    */
   struct PeerConnection *next;
 
+
   /*
-   * Pointer to daemon handle
+   * Index of daemon in pg->peers
    */
-  struct GNUNET_TESTING_Daemon *daemon;
+  uint32_t index;
 
 };
 #endif
@@ -356,7 +384,49 @@
    */
   struct GNUNET_TESTING_PeerGroup *pg;
 
+#if OLD
   /**
+   * Linked list of allowed peer connections.
+   */
+  struct PeerConnection *allowed_peers_head;
+
+  /**
+   * Linked list of allowed peer connections.
+   */
+  struct PeerConnection *allowed_peers_tail;
+
+  /**
+   * Linked list of blacklisted peer connections.
+   */
+  struct PeerConnection *blacklisted_peers_head;
+
+  /**
+   * Linked list of blacklisted peer connections.
+   */
+  struct PeerConnection *blacklisted_peers_tail;
+
+  /**
+   * Linked list of connect peer connections.
+   */
+  struct PeerConnection *connect_peers_head;
+
+  /**
+   * Linked list of connect peer connections.
+   */
+  struct PeerConnection *connect_peers_tail;
+
+  /**
+   * Linked list of connect peer connections.
+   */
+  struct PeerConnection *connect_peers_working_set_head;
+
+  /**
+   * Linked list of connect peer connections.
+   */
+  struct PeerConnection *connect_peers_working_set_tail;
+
+#else
+  /**
    * Hash map of allowed peer connections (F2F created topology)
    */
   struct GNUNET_CONTAINER_MultiHashMap *allowed_peers;
@@ -375,6 +445,7 @@
    * Temporary hash map of peer connections
    */
   struct GNUNET_CONTAINER_MultiHashMap *connect_peers_working_set;
+#endif
 
   /**
    * Temporary variable for topology creation, should be reset before
@@ -563,6 +634,11 @@
    * How many peers have already been started?
    */
   unsigned int started;
+
+  /**
+   * Hostkeys loaded from a file.
+   */
+  char *hostkey_data;
 };
 
 struct UpdateContext
@@ -587,10 +663,11 @@
    */
   struct GNUNET_TESTING_PeerGroup *pg;
 
+
   /**
    * Temp value set for each iteration.
    */
-  struct PeerData *first;
+  //struct PeerData *first;
 
   /**
    * Notification that all peers are connected.
@@ -724,6 +801,7 @@
   unsigned int current;
 };
 
+#if !OLD
 /**
  * Convert unique ID to hash code.
  *
@@ -748,6 +826,7 @@
 {
   memcpy (uid, hash, sizeof (uint32_t));
 }
+#endif
 
 /**
  * Number of connects we are waiting on, allows us to rate limit
@@ -984,7 +1063,6 @@
         }
       GNUNET_free (single_variable);
       GNUNET_free (per_host_variable);
-
     }
 
   if ((0 == strcmp (option, "HOSTNAME")) && (ctx->hostname != NULL))
@@ -1049,12 +1127,20 @@
 
       GNUNET_CONFIGURATION_set_value_string (uc.ret, "core", "ACCEPT_FROM",
                                              allowed_hosts);
+      GNUNET_CONFIGURATION_set_value_string (uc.ret, "core", "UNIXPATH",
+                                             "");
       GNUNET_CONFIGURATION_set_value_string (uc.ret, "transport",
                                              "ACCEPT_FROM", allowed_hosts);
+      GNUNET_CONFIGURATION_set_value_string (uc.ret, "transport", "UNIXPATH",
+                                             "");
       GNUNET_CONFIGURATION_set_value_string (uc.ret, "dht", "ACCEPT_FROM",
                                              allowed_hosts);
+      GNUNET_CONFIGURATION_set_value_string (uc.ret, "dht", "UNIXPATH",
+                                             "");
       GNUNET_CONFIGURATION_set_value_string (uc.ret, "statistics",
                                              "ACCEPT_FROM", allowed_hosts);
+      GNUNET_CONFIGURATION_set_value_string (uc.ret, "statistics", "UNIXPATH",
+                                             "");
       GNUNET_free_non_null (control_host);
       GNUNET_free (allowed_hosts);
     }
@@ -1088,251 +1174,261 @@
   return uc.ret;
 }
 
-
 /*
- * Add entries to the peers connect list
+ * Add entries to the some list
  *
  * @param pg the peer group we are working with
  * @param first index of the first peer
  * @param second index of the second peer
+ * @param list the peer list to use
  *
- * @return the number of connections added
- *         technically should only be 0 or 2
+ * @return the number of connections added (can be 0, 1 or 2)
  *
  */
 static unsigned int
-add_actual_connections (struct GNUNET_TESTING_PeerGroup *pg,
-                        unsigned int first, unsigned int second)
+remove_connections (struct GNUNET_TESTING_PeerGroup *pg,
+                   unsigned int first, unsigned int second,
+                   enum PeerLists list)
 {
-  int added;
-  int add_first;
-  int add_second;
+  int removed;
+#if OLD
+  struct PeerConnection **first_list;
+  struct PeerConnection **second_list;
+  struct PeerConnection *first_iter;
+  struct PeerConnection *second_iter;
+  struct PeerConnection **first_tail;
+  struct PeerConnection **second_tail;
 
+#else
   GNUNET_HashCode hash_first;
   GNUNET_HashCode hash_second;
 
   hash_from_uid (first, &hash_first);
   hash_from_uid (second, &hash_second);
+#endif
 
-  add_first = GNUNET_NO;
-  if (GNUNET_NO ==
-      GNUNET_CONTAINER_multihashmap_contains (pg->peers[first].connect_peers,
-                                              &hash_second))
+  removed = 0;
+#if OLD
+  switch (list)
+  {
+  case ALLOWED:
+    first_list = &pg->peers[first].allowed_peers_head;
+    second_list = &pg->peers[second].allowed_peers_head;
+    first_tail = &pg->peers[first].allowed_peers_tail;
+    second_tail = &pg->peers[second].allowed_peers_tail;
+    break;
+  case CONNECT:
+    first_list = &pg->peers[first].connect_peers_head;
+    second_list = &pg->peers[second].connect_peers_head;
+    first_tail = &pg->peers[first].connect_peers_tail;
+    second_tail = &pg->peers[second].connect_peers_tail;
+    break;
+  case BLACKLIST:
+    first_list = &pg->peers[first].blacklisted_peers_head;
+    second_list = &pg->peers[second].blacklisted_peers_head;
+    first_tail = &pg->peers[first].blacklisted_peers_tail;
+    second_tail = &pg->peers[second].blacklisted_peers_tail;
+    break;
+  case WORKING_SET:
+    first_list = &pg->peers[first].connect_peers_working_set_head;
+    second_list = &pg->peers[second].connect_peers_working_set_head;
+    first_tail = &pg->peers[first].connect_peers_working_set_tail;
+    second_tail = &pg->peers[second].connect_peers_working_set_tail;
+    break;
+  default:
+    GNUNET_break(0);
+  }
+
+  first_iter = *first_list;
+  while (first_iter != NULL)
     {
-      add_first = GNUNET_YES;
+      if (first_iter->index == second)
+        {
+          GNUNET_CONTAINER_DLL_remove(*first_list, *first_tail, first_iter);
+          GNUNET_free(first_iter);
+          removed++;
+          break;
+        }
+      first_iter = first_iter->next;
     }
 
-  add_second = GNUNET_NO;
-  if (GNUNET_NO ==
-      GNUNET_CONTAINER_multihashmap_contains (pg->peers[second].connect_peers,
-                                              &hash_first))
+  second_iter = *second_list;
+  while (second_iter != NULL)
     {
-      add_second = GNUNET_YES;
+      if (second_iter->index == first)
+        {
+          GNUNET_CONTAINER_DLL_remove(*second_list, *second_tail, second_iter);
+          GNUNET_free(second_iter);
+          removed++;
+          break;
+        }
+      second_iter = second_iter->next;
     }
-
-  added = 0;
-  if (add_first)
+#else
+  if (GNUNET_YES ==
+      GNUNET_CONTAINER_multihashmap_contains 
(pg->peers[first].blacklisted_peers,
+                                              &hash_second))
     {
-      GNUNET_assert (GNUNET_OK ==
-                     GNUNET_CONTAINER_multihashmap_put (pg->
-                                                        peers
-                                                        [first].connect_peers,
-                                                        &hash_second,
-                                                        pg->
-                                                        peers[second].daemon,
-                                                        
GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
-      pg->peers[first].num_connections++;
-      added++;
+      GNUNET_CONTAINER_multihashmap_remove_all 
(pg->peers[first].blacklisted_peers,
+                                                &hash_second);
     }
 
-  if (add_second)
+  if (GNUNET_YES ==
+      GNUNET_CONTAINER_multihashmap_contains 
(pg->peers[second].blacklisted_peers,
+                                              &hash_first))
     {
-      GNUNET_assert (GNUNET_OK ==
-                     GNUNET_CONTAINER_multihashmap_put (pg->
-                                                        peers
-                                                        [second].connect_peers,
-                                                        &hash_first,
-                                                        pg->
-                                                        peers[first].daemon,
-                                                        
GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
-      pg->peers[second].num_connections++;
-      added++;
+      GNUNET_CONTAINER_multihashmap_remove_all 
(pg->peers[second].blacklisted_peers,
+                                                &hash_first);
     }
+#endif
 
-  return added;
+  return removed;
 }
 
-
 /*
- * Add entries to the peers allowed connections list
+ * Add entries to the some list
  *
  * @param pg the peer group we are working with
  * @param first index of the first peer
  * @param second index of the second peer
+ * @param list the list type that we should modify
  *
  * @return the number of connections added (can be 0, 1 or 2)
- *         technically should only be 0 or 2, but the small price
- *         of iterating over the lists (hashmaps in the future)
- *         for being sure doesn't bother me!
  *
  */
 static unsigned int
-add_allowed_connections (struct GNUNET_TESTING_PeerGroup *pg,
-                         unsigned int first, unsigned int second)
+add_connections (struct GNUNET_TESTING_PeerGroup *pg,
+                 unsigned int first, unsigned int second,
+                 enum PeerLists list)
 {
   int added;
+  int add_first;
+  int add_second;
 #if OLD
+  struct PeerConnection **first_list;
+  struct PeerConnection **second_list;
   struct PeerConnection *first_iter;
   struct PeerConnection *second_iter;
   struct PeerConnection *new_first;
   struct PeerConnection *new_second;
-#endif
-  int add_first;
-  int add_second;
-
+  struct PeerConnection **first_tail;
+  struct PeerConnection **second_tail;
+#else
   GNUNET_HashCode hash_first;
   GNUNET_HashCode hash_second;
 
   hash_from_uid (first, &hash_first);
   hash_from_uid (second, &hash_second);
+#endif
 
-  add_first = GNUNET_NO;
-  if (GNUNET_NO ==
-      GNUNET_CONTAINER_multihashmap_contains (pg->peers[first].allowed_peers,
-                                              &hash_second))
-    {
-      add_first = GNUNET_YES;
-    }
+#if OLD
+  switch (list)
+  {
+  case ALLOWED:
+    GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Adding to ALLOWED\n");
+    first_list = &pg->peers[first].allowed_peers_head;
+    second_list = &pg->peers[second].allowed_peers_head;
+    first_tail = &pg->peers[first].allowed_peers_tail;
+    second_tail = &pg->peers[second].allowed_peers_tail;
+    break;
+  case CONNECT:
+    first_list = &pg->peers[first].connect_peers_head;
+    second_list = &pg->peers[second].connect_peers_head;
+    first_tail = &pg->peers[first].connect_peers_tail;
+    second_tail = &pg->peers[second].connect_peers_tail;
+    break;
+  case BLACKLIST:
+    first_list = &pg->peers[first].blacklisted_peers_head;
+    second_list = &pg->peers[second].blacklisted_peers_head;
+    first_tail = &pg->peers[first].blacklisted_peers_tail;
+    second_tail = &pg->peers[second].blacklisted_peers_tail;
+    break;
+  case WORKING_SET:
+    first_list = &pg->peers[first].connect_peers_working_set_head;
+    second_list = &pg->peers[second].connect_peers_working_set_head;
+    first_tail = &pg->peers[first].connect_peers_working_set_tail;
+    second_tail = &pg->peers[second].connect_peers_working_set_tail;
+    break;
+  default:
+    GNUNET_break(0);
+  }
 
-  add_second = GNUNET_NO;
-  if (GNUNET_NO ==
-      GNUNET_CONTAINER_multihashmap_contains (pg->peers[second].allowed_peers,
-                                              &hash_first))
-    {
-      add_second = GNUNET_YES;
-    }
-#if OLD
-  first_iter = pg->peers[first].connected_peers;
+  add_first = GNUNET_YES;
+  add_second = GNUNET_YES;
+
+  first_iter = *first_list;
   while (first_iter != NULL)
     {
-      if (first_iter->daemon == pg->peers[second].daemon)
-        add_first = GNUNET_NO;
+      if (first_iter->index == second)
+        {
+          add_first = GNUNET_NO;
+          break;
+        }
       first_iter = first_iter->next;
     }
 
-  second_iter = pg->peers[second].connected_peers;
-  add_second = GNUNET_YES;
+  second_iter = *second_list;
   while (second_iter != NULL)
     {
-      if (second_iter->daemon == pg->peers[first].daemon)
-        add_second = GNUNET_NO;
+      if (second_iter->index == first)
+        {
+          add_second = GNUNET_NO;
+          break;
+        }
       second_iter = second_iter->next;
     }
-#endif
-
-  added = 0;
-  if (add_first)
-    {
-      GNUNET_assert (GNUNET_OK ==
-                     GNUNET_CONTAINER_multihashmap_put (pg->
-                                                        peers
-                                                        [first].allowed_peers,
-                                                        &hash_second,
-                                                        pg->
-                                                        peers[second].daemon,
-                                                        
GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
-#if OLD
-      new_first = GNUNET_malloc (sizeof (struct PeerConnection));
-      new_first->daemon = pg->peers[second].daemon;
-      new_first->next = pg->peers[first].connected_peers;
-      pg->peers[first].connected_peers = new_first;
-#endif
-      pg->peers[first].num_connections++;
-      added++;
-    }
-
-  if (add_second)
-    {
-      GNUNET_assert (GNUNET_OK ==
-                     GNUNET_CONTAINER_multihashmap_put (pg->
-                                                        peers
-                                                        [second].allowed_peers,
-                                                        &hash_first,
-                                                        pg->
-                                                        peers[first].daemon,
-                                                        
GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
-#if OLD
-      new_second = GNUNET_malloc (sizeof (struct PeerConnection));
-      new_second->daemon = pg->peers[first].daemon;
-      new_second->next = pg->peers[second].connected_peers;
-      pg->peers[second].connected_peers = new_second;
-      pg->peers[first].num_connections++;
-#endif
-      pg->peers[second].num_connections++;
-      added++;
-    }
-
-  return added;
-}
-
-/*
- * Add entries to the peers blacklisted list
- *
- * @param pg the peer group we are working with
- * @param first index of the first peer
- * @param second index of the second peer
- *
- * @return the number of connections added (can be 0, 1 or 2)
- *
- */
-static unsigned int
-blacklist_connections (struct GNUNET_TESTING_PeerGroup *pg,
-                       unsigned int first, unsigned int second)
-{
-  int added;
-  int add_first;
-  int add_second;
-  GNUNET_HashCode hash_first;
-  GNUNET_HashCode hash_second;
-
-  hash_from_uid (first, &hash_first);
-  hash_from_uid (second, &hash_second);
-
-  add_first = GNUNET_NO;
+#else
   if (GNUNET_NO ==
-      GNUNET_CONTAINER_multihashmap_contains (pg->
-                                              peers[first].blacklisted_peers,
+      GNUNET_CONTAINER_multihashmap_contains 
(pg->peers[first].blacklisted_peers,
                                               &hash_second))
     {
       add_first = GNUNET_YES;
     }
 
-  add_second = GNUNET_NO;
   if (GNUNET_NO ==
-      GNUNET_CONTAINER_multihashmap_contains (pg->
-                                              peers[second].blacklisted_peers,
+      GNUNET_CONTAINER_multihashmap_contains 
(pg->peers[second].blacklisted_peers,
                                               &hash_first))
     {
       add_second = GNUNET_YES;
     }
+#endif
 
   added = 0;
   if (add_first)
     {
+#if OLD
+      GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Adding peer %d to %d\n", second, 
first);
+      new_first = GNUNET_malloc (sizeof (struct PeerConnection));
+      new_first->index = second;
+      GNUNET_CONTAINER_DLL_insert(*first_list, *first_tail, new_first);
+      /*
+      new_first->next = *first_list;
+      *first_list = new_first;*/
+#else
       GNUNET_assert (GNUNET_OK ==
-                     GNUNET_CONTAINER_multihashmap_put (pg->
-                                                        peers
-                                                        
[first].blacklisted_peers,
-                                                        &hash_second,
-                                                        pg->
-                                                        peers[second].daemon,
-                                                        
GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
+                           GNUNET_CONTAINER_multihashmap_put (pg->
+                                                              peers
+                                                              
[first].blacklisted_peers,
+                                                              &hash_second,
+                                                              pg->
+                                                              
peers[second].daemon,
+                                                              
GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
+#endif
       pg->peers[first].num_connections++;
       added++;
     }
 
   if (add_second)
     {
+#if OLD
+      new_second = GNUNET_malloc (sizeof (struct PeerConnection));
+      new_second->index = first;
+      GNUNET_CONTAINER_DLL_insert(*second_list, *second_tail, new_second);
+      /*
+      new_second->next = *second_list;
+      *second_list = new_second;
+      *second_list */
+#else
       GNUNET_assert (GNUNET_OK ==
                      GNUNET_CONTAINER_multihashmap_put (pg->
                                                         peers
@@ -1341,6 +1437,7 @@
                                                         pg->
                                                         peers[first].daemon,
                                                         
GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
+#endif
       pg->peers[second].num_connections++;
       added++;
     }
@@ -1348,68 +1445,7 @@
   return added;
 }
 
-/*
- * Remove entries from the peers blacklisted list
- *
- * @param pg the peer group we are working with
- * @param first index of the first peer
- * @param second index of the second peer
- *
- * @return the number of connections removed (can be 0, 1 or 2)
- *
- */
-static unsigned int
-unblacklist_connections (struct GNUNET_TESTING_PeerGroup *pg,
-                         unsigned int first, unsigned int second)
-{
-  int removed;
-  int remove_first;
-  int remove_second;
-  GNUNET_HashCode hash_first;
-  GNUNET_HashCode hash_second;
 
-  hash_from_uid (first, &hash_first);
-  hash_from_uid (second, &hash_second);
-
-  remove_first =
-    GNUNET_CONTAINER_multihashmap_contains (pg->
-                                            peers[first].blacklisted_peers,
-                                            &hash_second);
-  remove_second =
-    GNUNET_CONTAINER_multihashmap_contains (pg->
-                                            peers[second].blacklisted_peers,
-                                            &hash_first);
-
-  removed = 0;
-  if (remove_first)
-    {
-      GNUNET_assert (GNUNET_YES ==
-                     GNUNET_CONTAINER_multihashmap_remove (pg->
-                                                           peers
-                                                           
[first].blacklisted_peers,
-                                                           &hash_second,
-                                                           pg->
-                                                           peers
-                                                           [second].daemon));
-      removed++;
-    }
-
-  if (remove_second)
-    {
-      GNUNET_assert (GNUNET_YES ==
-                     GNUNET_CONTAINER_multihashmap_remove (pg->
-                                                           peers
-                                                           
[second].blacklisted_peers,
-                                                           &hash_first,
-                                                           pg->
-                                                           peers
-                                                           [first].daemon));
-      removed++;
-    }
-
-  return removed;
-}
-
 /**
  * Scale free network construction as described in:
  *
@@ -1427,7 +1463,7 @@
  */
 static unsigned int
 create_scale_free (struct GNUNET_TESTING_PeerGroup *pg,
-                   GNUNET_TESTING_ConnectionProcessor proc)
+                   GNUNET_TESTING_ConnectionProcessor proc, enum PeerLists 
list)
 {
 
   unsigned int total_connections;
@@ -1440,7 +1476,7 @@
   GNUNET_assert (pg->total > 1);
 
   /* Add a connection between the first two nodes */
-  total_connections = proc (pg, 0, 1);
+  total_connections = proc (pg, 0, 1, list);
 
   for (outer_count = 1; outer_count < pg->total; outer_count++)
     {
@@ -1465,7 +1501,7 @@
               GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                           "Connecting peer %d to peer %d\n", outer_count, i);
 #endif
-              total_connections += proc (pg, outer_count, i);
+              total_connections += proc (pg, outer_count, i, list);
             }
         }
     }
@@ -1501,7 +1537,7 @@
  */
 static unsigned int
 create_small_world_ring (struct GNUNET_TESTING_PeerGroup *pg,
-                         GNUNET_TESTING_ConnectionProcessor proc)
+                         GNUNET_TESTING_ConnectionProcessor proc, enum 
PeerLists list)
 {
   unsigned int i, j;
   int nodeToConnect;
@@ -1591,7 +1627,7 @@
                     GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK,
                                               pg->total);
                 }
-              smallWorldConnections += proc (pg, i, randomPeer);
+              smallWorldConnections += proc (pg, i, randomPeer, list);
             }
           else
             {
@@ -1600,7 +1636,7 @@
                 {
                   nodeToConnect = nodeToConnect - pg->total;
                 }
-              connect_attempts += proc (pg, i, nodeToConnect);
+              connect_attempts += proc (pg, i, nodeToConnect, list);
             }
         }
 
@@ -1624,7 +1660,7 @@
  */
 static unsigned int
 create_nated_internet (struct GNUNET_TESTING_PeerGroup *pg,
-                       GNUNET_TESTING_ConnectionProcessor proc)
+                       GNUNET_TESTING_ConnectionProcessor proc, enum PeerLists 
list)
 {
   unsigned int outer_count, inner_count;
   unsigned int cutoff;
@@ -1664,7 +1700,7 @@
                           "Connecting peer %d to peer %d\n",
                           outer_count, inner_count);
 #endif
-              connect_attempts += proc (pg, outer_count, inner_count);
+              connect_attempts += proc (pg, outer_count, inner_count, list);
             }
         }
     }
@@ -1686,7 +1722,7 @@
  */
 static unsigned int
 create_small_world (struct GNUNET_TESTING_PeerGroup *pg,
-                    GNUNET_TESTING_ConnectionProcessor proc)
+                    GNUNET_TESTING_ConnectionProcessor proc, enum PeerLists 
list)
 {
   unsigned int i, j, k;
   unsigned int square;
@@ -1778,7 +1814,7 @@
       else
         nodeToConnect = i - cols + 1;
 
-      connect_attempts += proc (pg, i, nodeToConnect);
+      connect_attempts += proc (pg, i, nodeToConnect, list);
 
       if (i < cols)
         nodeToConnect = (rows * cols) - cols + i;
@@ -1786,7 +1822,7 @@
         nodeToConnect = i - cols;
 
       if (nodeToConnect < pg->total)
-        connect_attempts += proc (pg, i, nodeToConnect);
+        connect_attempts += proc (pg, i, nodeToConnect, list);
     }
   natLog = log (pg->total);
 #if VERBOSE_TESTING > 2
@@ -1828,7 +1864,7 @@
                     ((double) UINT64_MAX);
                   /* If random < probability, then connect the two nodes */
                   if (random < probability)
-                    smallWorldConnections += proc (pg, j, k);
+                    smallWorldConnections += proc (pg, j, k, list);
 
                 }
             }
@@ -1856,7 +1892,7 @@
  */
 static unsigned int
 create_erdos_renyi (struct GNUNET_TESTING_PeerGroup *pg,
-                    GNUNET_TESTING_ConnectionProcessor proc)
+                    GNUNET_TESTING_ConnectionProcessor proc, enum PeerLists 
list)
 {
   double temp_rand;
   unsigned int outer_count;
@@ -1895,7 +1931,7 @@
 #endif
           if (temp_rand < probability)
             {
-              connect_attempts += proc (pg, outer_count, inner_count);
+              connect_attempts += proc (pg, outer_count, inner_count, list);
             }
         }
     }
@@ -1918,7 +1954,7 @@
  */
 static unsigned int
 create_2d_torus (struct GNUNET_TESTING_PeerGroup *pg,
-                 GNUNET_TESTING_ConnectionProcessor proc)
+                 GNUNET_TESTING_ConnectionProcessor proc, enum PeerLists list)
 {
   unsigned int i;
   unsigned int square;
@@ -1970,7 +2006,7 @@
       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                   "Connecting peer %d to peer %d\n", i, nodeToConnect);
 #endif
-      connect_attempts += proc (pg, i, nodeToConnect);
+      connect_attempts += proc (pg, i, nodeToConnect, list);
 
       /* Second connect to the node immediately above */
       if (i < cols)
@@ -1984,7 +2020,7 @@
           GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                       "Connecting peer %d to peer %d\n", i, nodeToConnect);
 #endif
-          connect_attempts += proc (pg, i, nodeToConnect);
+          connect_attempts += proc (pg, i, nodeToConnect, list);
         }
 
     }
@@ -2006,7 +2042,7 @@
  */
 static unsigned int
 create_clique (struct GNUNET_TESTING_PeerGroup *pg,
-               GNUNET_TESTING_ConnectionProcessor proc)
+               GNUNET_TESTING_ConnectionProcessor proc, enum PeerLists list)
 {
   unsigned int outer_count;
   unsigned int inner_count;
@@ -2024,13 +2060,14 @@
                       "Connecting peer %d to peer %d\n",
                       outer_count, inner_count);
 #endif
-          connect_attempts += proc (pg, outer_count, inner_count);
+          connect_attempts += proc (pg, outer_count, inner_count, list);
         }
     }
 
   return connect_attempts;
 }
 
+#if !OLD
 /**
  * Iterator over hash map entries.
  *
@@ -2056,6 +2093,7 @@
 
   return GNUNET_YES;
 }
+#endif
 
 /**
  * Create a blacklist topology based on the allowed topology
@@ -2076,13 +2114,24 @@
   struct UnblacklistContext un_ctx;
   unsigned int count;
   unsigned int total;
+  struct PeerConnection *iter;
 
   un_ctx.pg = pg;
   total = 0;
   for (count = 0; count < pg->total - 1; count++)
     {
       un_ctx.first_uid = count;
+#if OLD
+      iter = pg->peers[count].allowed_peers_head;
+      while (iter != NULL)
+        {
+          remove_connections(pg, count, iter->index, BLACKLIST);
+          //unblacklist_connections(pg, count, iter->index);
+          iter = iter->next;
+        }
+#else
       total += 
GNUNET_CONTAINER_multihashmap_iterate(pg->peers[count].allowed_peers, 
&unblacklist_iterator, &un_ctx);
+#endif
     }
   GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Unblacklisted %u peers\n", total);
   return total;
@@ -2095,13 +2144,14 @@
  * @param pg the peergroup to create the topology on
  * @param proc the connection processor to call to actually set
  *        up connections between two peers
+ * @param list which list should be modified
  *
  * @return the number of connections that were set up
  *
  */
 static unsigned int
 create_line (struct GNUNET_TESTING_PeerGroup *pg,
-             GNUNET_TESTING_ConnectionProcessor proc)
+             GNUNET_TESTING_ConnectionProcessor proc, enum PeerLists list)
 {
   unsigned int count;
   int connect_attempts;
@@ -2115,7 +2165,7 @@
       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                   "Connecting peer %d to peer %d\n", count, count + 1);
 #endif
-      connect_attempts += proc (pg, count, count + 1);
+      connect_attempts += proc (pg, count, count + 1, list);
     }
 
   return connect_attempts;
@@ -2136,7 +2186,7 @@
 static unsigned int
 create_from_file (struct GNUNET_TESTING_PeerGroup *pg,
                   char *filename,
-                  GNUNET_TESTING_ConnectionProcessor proc)
+                  GNUNET_TESTING_ConnectionProcessor proc, enum PeerLists list)
 {
   int connect_attempts;
   unsigned int first_peer_index;
@@ -2225,7 +2275,7 @@
               return connect_attempts;
             }
           /* Assume file is written with first peer 1, but array index is 0 */
-          connect_attempts += proc (pg, first_peer_index - 1, 
second_peer_index - 1);
+          connect_attempts += proc (pg, first_peer_index - 1, 
second_peer_index - 1, list);
           while((buf[count] != '\n') && (buf[count] != ',') && (count < 
frstat.st_size - 1))
             count++;
           if (buf[count] == '\n')
@@ -2272,7 +2322,7 @@
  */
 static unsigned int
 create_ring (struct GNUNET_TESTING_PeerGroup *pg,
-             GNUNET_TESTING_ConnectionProcessor proc)
+             GNUNET_TESTING_ConnectionProcessor proc, enum PeerLists list)
 {
   unsigned int count;
   int connect_attempts;
@@ -2286,16 +2336,16 @@
       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                   "Connecting peer %d to peer %d\n", count, count + 1);
 #endif
-      connect_attempts += proc (pg, count, count + 1);
+      connect_attempts += proc (pg, count, count + 1, list);
     }
 
   /* Connect the last peer to the first peer */
-  connect_attempts += proc (pg, pg->total - 1, 0);
+  connect_attempts += proc (pg, pg->total - 1, 0, list);
 
   return connect_attempts;
 }
 
-
+#if !OLD
 /**
  * Iterator for writing friends of a peer to a file.
  *
@@ -2366,7 +2416,9 @@
 
   return GNUNET_YES;
 }
+#endif
 
+
 /*
  * Create the friend files based on the PeerConnection's
  * of each peer in the peer group, and copy the files
@@ -2388,7 +2440,10 @@
   int count;
   int ret;
   int max_wait = 10;
-
+#if OLD
+  struct GNUNET_CRYPTO_HashAsciiEncoded peer_enc;
+  struct PeerConnection *conn_iter;
+#endif
   procarr = GNUNET_malloc (sizeof (struct GNUNET_OS_Process *) * pg->total);
   for (pg_iter = 0; pg_iter < pg->total; pg_iter++)
     {
@@ -2396,9 +2451,19 @@
       GNUNET_assert (mytemp != NULL);
       temp_friend_handle = fopen (mytemp, "wt");
       GNUNET_assert (temp_friend_handle != NULL);
+#if OLD
+      conn_iter = pg->peers[pg_iter].allowed_peers_head;
+      while (conn_iter != NULL)
+        {
+          GNUNET_CRYPTO_hash_to_enc 
(&pg->peers[conn_iter->index].daemon->id.hashPubKey, &peer_enc);
+          fprintf (temp_friend_handle, "%s\n", (char *) &peer_enc);
+          conn_iter = conn_iter->next;
+        }
+#else
       GNUNET_CONTAINER_multihashmap_iterate (pg->peers[pg_iter].allowed_peers,
                                              &friend_file_iterator,
                                              temp_friend_handle);
+#endif
       fclose (temp_friend_handle);
 
       if (GNUNET_OK !=
@@ -2521,7 +2586,6 @@
                                  const char *transports)
 {
   FILE *temp_file_handle;
-  static struct BlacklistContext blacklist_ctx;
   unsigned int pg_iter;
   char *temp_service_path;
   struct GNUNET_OS_Process **procarr;
@@ -2537,6 +2601,12 @@
   char *pos;
   char *temp_transports;
   int entry_count;
+#if OLD
+  struct GNUNET_CRYPTO_HashAsciiEncoded peer_enc;
+  struct PeerConnection *conn_iter;
+#else
+  static struct BlacklistContext blacklist_ctx;
+#endif
 
   procarr = GNUNET_malloc (sizeof (struct GNUNET_OS_Process *) * pg->total);
   for (pg_iter = 0; pg_iter < pg->total; pg_iter++)
@@ -2546,7 +2616,9 @@
       temp_file_handle = fopen (mytemp, "wt");
       GNUNET_assert (temp_file_handle != NULL);
       temp_transports = GNUNET_strdup (transports);
+#if !OLD
       blacklist_ctx.temp_file_handle = temp_file_handle;
+#endif
       transport_len = strlen (temp_transports) + 1;
       pos = NULL;
 
@@ -2557,12 +2629,23 @@
           else if ((temp_transports[i] == ' ') || (temp_transports[i] == 
'\0')) /* At end of string */
             {
               temp_transports[i] = '\0';
+#if OLD
+              conn_iter = pg->peers[pg_iter].blacklisted_peers_head;
+              while (conn_iter != NULL)
+                {
+                  GNUNET_CRYPTO_hash_to_enc 
(&pg->peers[conn_iter->index].daemon->id.hashPubKey, &peer_enc);
+                  fprintf (temp_file_handle, "%s:%s\n", pos, (char *) 
&peer_enc);
+                  conn_iter = conn_iter->next;
+                  entry_count++;
+                }
+#else
               blacklist_ctx.transport = pos;
               entry_count = GNUNET_CONTAINER_multihashmap_iterate (pg->
                                                      peers
                                                      
[pg_iter].blacklisted_peers,
                                                      &blacklist_file_iterator,
                                                      &blacklist_ctx);
+#endif
               pos = NULL;
             }                   /* At beginning of actual string */
           else if (pos == NULL)
@@ -2758,7 +2841,7 @@
     }
 }
 
-
+#if !OLD
 /**
  * Iterator for actually scheduling connections to be created
  * between two peers.
@@ -2785,8 +2868,9 @@
 
   return GNUNET_YES;
 }
+#endif
 
-
+#if !OLD
 /**
  * Iterator for copying all entries in the allowed hashmap to the
  * connect hashmap.
@@ -2809,6 +2893,7 @@
 
   return GNUNET_YES;
 }
+#endif
 
 /**
  * Make the peers to connect the same as those that are allowed to be
@@ -2822,15 +2907,29 @@
   unsigned int pg_iter;
   int ret;
   int total;
-
+#if OLD
+  struct PeerConnection *iter;
+#endif
   total = 0;
+  ret = 0;
   for (pg_iter = 0; pg_iter < pg->total; pg_iter++)
     {
+#if OLD
+      iter = pg->peers[pg_iter].allowed_peers_head;
+      while (iter != NULL)
+        {
+          GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Creating connection between %d 
and %d\n", pg_iter, iter->index);
+          total += add_connections(pg, pg_iter, iter->index, CONNECT);
+          //total += add_actual_connections(pg, pg_iter, iter->index);
+          iter = iter->next;
+        }
+#else
       ret =
         GNUNET_CONTAINER_multihashmap_iterate (pg->
                                                peers[pg_iter].allowed_peers,
                                                &copy_topology_iterator,
                                                &pg->peers[pg_iter]);
+#endif
       if (GNUNET_SYSERR == ret)
         return GNUNET_SYSERR;
 
@@ -2857,12 +2956,13 @@
                   void *notify_cls)
 {
   unsigned int pg_iter;
-  int ret;
   unsigned int total;
   struct ConnectTopologyContext *ct_ctx;
 #if OLD
   struct PeerConnection *connection_iter;
   struct ConnectContext *connect_context;
+#else
+  int ret;
 #endif
 
   total = 0;
@@ -2873,8 +2973,17 @@
 
   for (pg_iter = 0; pg_iter < pg->total; pg_iter++)
     {
+#if OLD
+      connection_iter = pg->peers[pg_iter].connect_peers_head;
+      while (connection_iter != NULL)
+        {
+          connection_iter = connection_iter->next;
+          total++;
+        }
+#else
       total +=
         GNUNET_CONTAINER_multihashmap_size (pg->peers[pg_iter].connect_peers);
+#endif
     }
 
   if (total == 0)
@@ -2887,25 +2996,26 @@
 
   for (pg_iter = 0; pg_iter < pg->total; pg_iter++)
     {
-      ct_ctx->first = &pg->peers[pg_iter];
-      ret =
-        GNUNET_CONTAINER_multihashmap_iterate (pg->
-                                               peers[pg_iter].connect_peers,
-                                               &connect_iterator, ct_ctx);
-      GNUNET_assert (GNUNET_SYSERR != ret && ret >= 0);
-      total = total + ret;
-
 #if OLD
-      connection_iter = FIXME;
+      connection_iter = pg->peers[pg_iter].connect_peers_head;
       while (connection_iter != NULL)
         {
+          GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Scheduling connect of peer %d 
to peer %d\n", pg_iter, connection_iter->index);
           connect_context = GNUNET_malloc (sizeof (struct ConnectContext));
-          connect_context->pg = pg;
-          connect_context->first = FIXME;
-          connect_context->second = connection_iter->daemon;
+          connect_context->first = pg->peers[pg_iter].daemon;
+          connect_context->second = pg->peers[connection_iter->index].daemon;
+          connect_context->ct_ctx = ct_ctx;
           GNUNET_SCHEDULER_add_now (&schedule_connect, connect_context);
           connection_iter = connection_iter->next;
+          total++;
         }
+#else
+      ret =
+        GNUNET_CONTAINER_multihashmap_iterate (pg->
+                                               peers[pg_iter].connect_peers,
+                                               &connect_iterator, ct_ctx);
+      GNUNET_assert (GNUNET_SYSERR != ret && ret >= 0);
+      total = total + ret;
 #endif
     }
   return total;
@@ -2941,17 +3051,32 @@
                                 const char *restrict_transports)
 {
   int ret;
+
   unsigned int num_connections;
   int unblacklisted_connections;
   char *filename;
 
+#if !OLD
+  unsigned int i;
+  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].pg = pg;
+    }
+#endif
+
   switch (topology)
     {
     case GNUNET_TESTING_TOPOLOGY_CLIQUE:
 #if VERBOSE_TESTING
       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, _("Creating clique topology\n"));
 #endif
-      num_connections = create_clique (pg, &add_allowed_connections);
+      num_connections = create_clique (pg, &add_connections, ALLOWED);
       break;
     case GNUNET_TESTING_TOPOLOGY_SMALL_WORLD_RING:
 #if VERBOSE_TESTING
@@ -2959,53 +3084,53 @@
                   _("Creating small world (ring) topology\n"));
 #endif
       num_connections =
-        create_small_world_ring (pg, &add_allowed_connections);
+        create_small_world_ring (pg, &add_connections, ALLOWED);
       break;
     case GNUNET_TESTING_TOPOLOGY_SMALL_WORLD:
 #if VERBOSE_TESTING
       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                   _("Creating small world (2d-torus) topology\n"));
 #endif
-      num_connections = create_small_world (pg, &add_allowed_connections);
+      num_connections = create_small_world (pg, &add_connections, ALLOWED);
       break;
     case GNUNET_TESTING_TOPOLOGY_RING:
 #if VERBOSE_TESTING
       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, _("Creating ring topology\n"));
 #endif
-      num_connections = create_ring (pg, &add_allowed_connections);
+      num_connections = create_ring (pg, &add_connections, ALLOWED);
       break;
     case GNUNET_TESTING_TOPOLOGY_2D_TORUS:
 #if VERBOSE_TESTING
       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, _("Creating 2d torus topology\n"));
 #endif
-      num_connections = create_2d_torus (pg, &add_allowed_connections);
+      num_connections = create_2d_torus (pg, &add_connections, ALLOWED);
       break;
     case GNUNET_TESTING_TOPOLOGY_ERDOS_RENYI:
 #if VERBOSE_TESTING
       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                   _("Creating Erdos-Renyi topology\n"));
 #endif
-      num_connections = create_erdos_renyi (pg, &add_allowed_connections);
+      num_connections = create_erdos_renyi (pg, &add_connections, ALLOWED);
       break;
     case GNUNET_TESTING_TOPOLOGY_INTERNAT:
 #if VERBOSE_TESTING
       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, _("Creating InterNAT topology\n"));
 #endif
-      num_connections = create_nated_internet (pg, &add_allowed_connections);
+      num_connections = create_nated_internet (pg, &add_connections, ALLOWED);
       break;
     case GNUNET_TESTING_TOPOLOGY_SCALE_FREE:
 #if VERBOSE_TESTING
       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                   _("Creating Scale Free topology\n"));
 #endif
-      num_connections = create_scale_free (pg, &add_allowed_connections);
+      num_connections = create_scale_free (pg, &add_connections, ALLOWED);
       break;
     case GNUNET_TESTING_TOPOLOGY_LINE:
 #if VERBOSE_TESTING
       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                   _("Creating straight line topology\n"));
 #endif
-      num_connections = create_line (pg, &add_allowed_connections);
+      num_connections = create_line (pg, &add_connections, ALLOWED);
       break;
     case GNUNET_TESTING_TOPOLOGY_FROM_FILE:
 #if VERBOSE_TESTING
@@ -3015,7 +3140,7 @@
       if (GNUNET_OK ==
           GNUNET_CONFIGURATION_get_value_string (pg->cfg, "testing", 
"topology_file",
                                                  &filename))
-        num_connections = create_from_file (pg, filename, 
&add_allowed_connections);
+        num_connections = create_from_file (pg, filename, &add_connections, 
ALLOWED);
       else
       {
         GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Missing configuration option 
TESTING:TOPOLOGY_FILE for creating topology from file!");
@@ -3057,7 +3182,8 @@
     }
 
   /* Use the create clique method to initially set all connections as 
blacklisted. */
-  create_clique (pg, &blacklist_connections);
+  if ((restrict_topology != GNUNET_TESTING_TOPOLOGY_NONE) && 
(restrict_topology != GNUNET_TESTING_TOPOLOGY_FROM_FILE))
+    create_clique (pg, &add_connections, BLACKLIST);
 
   unblacklisted_connections = 0;
   /* Un-blacklist connections as per the topology specified */
@@ -3069,7 +3195,7 @@
                   _("Blacklisting all but clique topology\n"));
 #endif
       unblacklisted_connections =
-        create_clique (pg, &unblacklist_connections);
+        create_clique (pg, &remove_connections, BLACKLIST);
       break;
     case GNUNET_TESTING_TOPOLOGY_SMALL_WORLD_RING:
 #if VERBOSE_TESTING
@@ -3077,7 +3203,7 @@
                   _("Blacklisting all but small world (ring) topology\n"));
 #endif
       unblacklisted_connections =
-        create_small_world_ring (pg, &unblacklist_connections);
+        create_small_world_ring (pg, &remove_connections, BLACKLIST);
       break;
     case GNUNET_TESTING_TOPOLOGY_SMALL_WORLD:
 #if VERBOSE_TESTING
@@ -3086,14 +3212,14 @@
                   ("Blacklisting all but small world (2d-torus) topology\n"));
 #endif
       unblacklisted_connections =
-        create_small_world (pg, &unblacklist_connections);
+        create_small_world (pg, &remove_connections, BLACKLIST);
       break;
     case GNUNET_TESTING_TOPOLOGY_RING:
 #if VERBOSE_TESTING
       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                   _("Blacklisting all but ring topology\n"));
 #endif
-      unblacklisted_connections = create_ring (pg, &unblacklist_connections);
+      unblacklisted_connections = create_ring (pg, &remove_connections, 
BLACKLIST);
       break;
     case GNUNET_TESTING_TOPOLOGY_2D_TORUS:
 #if VERBOSE_TESTING
@@ -3101,7 +3227,7 @@
                   _("Blacklisting all but 2d torus topology\n"));
 #endif
       unblacklisted_connections =
-        create_2d_torus (pg, &unblacklist_connections);
+        create_2d_torus (pg, &remove_connections, BLACKLIST);
       break;
     case GNUNET_TESTING_TOPOLOGY_ERDOS_RENYI:
 #if VERBOSE_TESTING
@@ -3109,7 +3235,7 @@
                   _("Blacklisting all but Erdos-Renyi topology\n"));
 #endif
       unblacklisted_connections =
-        create_erdos_renyi (pg, &unblacklist_connections);
+        create_erdos_renyi (pg, &remove_connections, BLACKLIST);
       break;
     case GNUNET_TESTING_TOPOLOGY_INTERNAT:
 #if VERBOSE_TESTING
@@ -3117,7 +3243,7 @@
                   _("Blacklisting all but InterNAT topology\n"));
 #endif
       unblacklisted_connections =
-        create_nated_internet (pg, &unblacklist_connections);
+        create_nated_internet (pg, &remove_connections, BLACKLIST);
       break;
     case GNUNET_TESTING_TOPOLOGY_SCALE_FREE:
 #if VERBOSE_TESTING
@@ -3125,16 +3251,16 @@
                   _("Blacklisting all but Scale Free topology\n"));
 #endif
       unblacklisted_connections =
-        create_scale_free (pg, &unblacklist_connections);
+        create_scale_free (pg, &remove_connections, BLACKLIST);
       break;
     case GNUNET_TESTING_TOPOLOGY_LINE:
 #if VERBOSE_TESTING
       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                   _("Blacklisting all but straight line topology\n"));
 #endif
-      unblacklisted_connections = create_line (pg, &unblacklist_connections);
+      unblacklisted_connections = create_line (pg, &remove_connections, 
BLACKLIST);
       break;
-    case GNUNET_TESTING_TOPOLOGY_NONE:
+    case GNUNET_TESTING_TOPOLOGY_NONE: /* Fall through */
     case GNUNET_TESTING_TOPOLOGY_FROM_FILE:
 #if VERBOSE_TESTING
       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
@@ -3144,14 +3270,14 @@
     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                 _
                 ("Creating blacklist topology from allowed\n"));
-    unblacklisted_connections = copy_allowed (pg, &unblacklist_connections);
+    unblacklisted_connections = copy_allowed (pg, &remove_connections);
     default:
       break;
     }
 
   if ((unblacklisted_connections > 0) && (restrict_transports != NULL))
     {
-      GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "Creating blacklist with `%s'", 
restrict_transports);
+      GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "Creating blacklist with `%s'\n", 
restrict_transports);
       ret = create_and_copy_blacklist_files (pg, restrict_transports);
       if (ret != GNUNET_OK)
         {
@@ -3173,6 +3299,7 @@
 }
 
 
+#if !OLD
 /**
  * Iterator for choosing random peers to connect.
  *
@@ -3201,6 +3328,7 @@
                                                         key, value,
                                                         
GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
     }
+
   /* Now we have considered this particular connection, remove it from the 
second peer so it's not double counted */
   uid_from_hash (key, &second_pos);
   hash_from_uid (random_ctx->first_uid, &first_hash);
@@ -3216,6 +3344,7 @@
   return GNUNET_YES;
 }
 
+
 /**
  * Iterator for adding at least X peers to a peers connection set.
  *
@@ -3318,8 +3447,8 @@
   dfs_ctx->current++;
   return GNUNET_YES;
 }
+#endif
 
-
 /**
  * From the set of connections possible, choose percentage percent of 
connections
  * to actually connect.
@@ -3333,6 +3462,11 @@
 {
   struct RandomContext random_ctx;
   uint32_t pg_iter;
+#if OLD
+  struct PeerConnection *temp_peers;
+  struct PeerConnection *conn_iter;
+  double random_number;
+#endif
 
   for (pg_iter = 0; pg_iter < pg->total; pg_iter++)
     {
@@ -3340,6 +3474,22 @@
       random_ctx.first = &pg->peers[pg_iter];
       random_ctx.percentage = percentage;
       random_ctx.pg = pg;
+#if OLD
+      temp_peers = NULL;
+      conn_iter = pg->peers[pg_iter].connect_peers_head;
+      while (conn_iter != NULL)
+        {
+          random_number =
+            ((double)
+             GNUNET_CRYPTO_random_u64 (GNUNET_CRYPTO_QUALITY_WEAK,
+                                       UINT64_MAX)) / ((double) UINT64_MAX);
+          if (random_number < percentage)
+            {
+              add_connections(pg, pg_iter, conn_iter->index, WORKING_SET);
+            }
+          conn_iter = conn_iter->next;
+        }
+#else
       pg->peers[pg_iter].connect_peers_working_set =
         GNUNET_CONTAINER_multihashmap_create (pg->total);
       GNUNET_CONTAINER_multihashmap_iterate (pg->peers[pg_iter].connect_peers,
@@ -3351,10 +3501,109 @@
       /* And replace with the random set */
       pg->peers[pg_iter].connect_peers =
         pg->peers[pg_iter].connect_peers_working_set;
+#endif
     }
+
+  for (pg_iter = 0; pg_iter < pg->total; pg_iter++)
+    {
+      conn_iter = pg->peers[pg_iter].connect_peers_head;
+      while (pg->peers[pg_iter].connect_peers_head != NULL)
+        remove_connections(pg, pg_iter, 
pg->peers[pg_iter].connect_peers_head->index, CONNECT);
+
+      pg->peers[pg_iter].connect_peers_head = 
pg->peers[pg_iter].connect_peers_working_set_head;
+      pg->peers[pg_iter].connect_peers_tail = 
pg->peers[pg_iter].connect_peers_working_set_tail;
+      pg->peers[pg_iter].connect_peers_working_set_head = NULL;
+      pg->peers[pg_iter].connect_peers_working_set_tail = NULL;
+    }
 }
 
+
 /**
+ * Count the number of connections in a linked list of connections.
+ *
+ * @param conn_list the connection list to get the count of
+ *
+ * @return the number of elements in the list
+ */
+static unsigned int
+count_connections (struct PeerConnection *conn_list)
+{
+  struct PeerConnection *iter;
+  unsigned int count;
+  count = 0;
+  iter = conn_list;
+  while (iter != NULL)
+    {
+      iter = iter->next;
+      count++;
+    }
+  return count;
+}
+
+
+static unsigned int
+count_workingset_connections (struct GNUNET_TESTING_PeerGroup *pg)
+{
+  unsigned int count;
+  unsigned int pg_iter;
+#if OLD
+  struct PeerConnection *conn_iter;
+#endif
+  count = 0;
+
+  for (pg_iter = 0; pg_iter < pg->total; pg_iter++)
+    {
+#if OLD
+      conn_iter = pg->peers[pg_iter].connect_peers_working_set_head;
+      while (conn_iter != NULL)
+        {
+          count++;
+          conn_iter = conn_iter->next;
+        }
+#else
+      count +=
+        GNUNET_CONTAINER_multihashmap_size (pg->
+                                            peers
+                                            
[pg_iter].connect_peers_working_set);
+#endif
+    }
+
+  return count;
+}
+
+
+static unsigned int
+count_allowed_connections (struct GNUNET_TESTING_PeerGroup *pg)
+{
+  unsigned int count;
+  unsigned int pg_iter;
+#if OLD
+  struct PeerConnection *conn_iter;
+#endif
+
+  count = 0;
+  for (pg_iter = 0; pg_iter < pg->total; pg_iter++)
+    {
+#if OLD
+      conn_iter = pg->peers[pg_iter].allowed_peers_head;
+      while (conn_iter != NULL)
+        {
+          count++;
+          conn_iter = conn_iter->next;
+        }
+#else
+      count +=
+        GNUNET_CONTAINER_multihashmap_size (pg->
+                                            peers
+                                            [pg_iter].allowed_peers);
+#endif
+    }
+
+  return count;
+}
+
+
+/**
  * From the set of connections possible, choose at least num connections per
  * peer.
  *
@@ -3364,11 +3613,40 @@
 static void
 choose_minimum (struct GNUNET_TESTING_PeerGroup *pg, unsigned int num)
 {
+#if !OLD
   struct MinimumContext minimum_ctx;
+#else
+  struct PeerConnection *conn_iter;
+  unsigned int temp_list_size;
+  unsigned int i;
+  unsigned int count;
+  uint32_t random; /* Random list entry to connect peer to */
+#endif
   uint32_t pg_iter;
 
+#if OLD
   for (pg_iter = 0; pg_iter < pg->total; pg_iter++)
     {
+      temp_list_size = 
count_connections(pg->peers[pg_iter].connect_peers_head);
+      if (temp_list_size == 0)
+        {
+          GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Peer %d has 0 
connections!?!?\n", pg_iter);
+          break;
+        }
+      for (i = 0; i < num; i++)
+        {
+          random = GNUNET_CRYPTO_random_u32(GNUNET_CRYPTO_QUALITY_WEAK, 
temp_list_size);
+          conn_iter = pg->peers[pg_iter].connect_peers_head;
+          for (count = 0; count < random; count++)
+            conn_iter = conn_iter->next;
+          /* We now have a random connection, connect it! */
+          GNUNET_assert(conn_iter != NULL);
+          add_connections(pg, pg_iter, conn_iter->index, WORKING_SET);
+        }
+    }
+#else
+  for (pg_iter = 0; pg_iter < pg->total; pg_iter++)
+    {
       pg->peers[pg_iter].connect_peers_working_set =
         GNUNET_CONTAINER_multihashmap_create (num);
     }
@@ -3398,48 +3676,20 @@
       pg->peers[pg_iter].connect_peers =
         pg->peers[pg_iter].connect_peers_working_set;
     }
-
-}
-
-
-static unsigned int
-count_workingset_connections (struct GNUNET_TESTING_PeerGroup *pg)
-{
-  unsigned int count;
-  unsigned int pg_iter;
-
-  count = 0;
-
+#endif
   for (pg_iter = 0; pg_iter < pg->total; pg_iter++)
     {
-      count +=
-        GNUNET_CONTAINER_multihashmap_size (pg->
-                                            peers
-                                            
[pg_iter].connect_peers_working_set);
-    }
+      while (pg->peers[pg_iter].connect_peers_head != NULL)
+        remove_connections(pg, pg_iter, 
pg->peers[pg_iter].connect_peers_head->index, CONNECT);
 
-  return count;
-}
-
-
-static unsigned int
-count_allowed_connections (struct GNUNET_TESTING_PeerGroup *pg)
-{
-  unsigned int count;
-  unsigned int pg_iter;
-
-  count = 0;
-
-  for (pg_iter = 0; pg_iter < pg->total; pg_iter++)
-    {
-      count +=
-        GNUNET_CONTAINER_multihashmap_size (pg->peers[pg_iter].connect_peers);
+      pg->peers[pg_iter].connect_peers_head = 
pg->peers[pg_iter].connect_peers_working_set_head;
+      pg->peers[pg_iter].connect_peers_tail = 
pg->peers[pg_iter].connect_peers_working_set_tail;
+      pg->peers[pg_iter].connect_peers_working_set_head = NULL;
+      pg->peers[pg_iter].connect_peers_working_set_tail = NULL;
     }
-
-  return count;
 }
 
-
+#if !OLD
 struct FindClosestContext
 {
   /**
@@ -3503,6 +3753,7 @@
   return GNUNET_YES;
 }
 
+
 /**
  * From the set of connections possible, choose at num connections per
  * peer based on depth which are closest out of those allowed.  Guaranteed
@@ -3515,9 +3766,13 @@
  */
 void
 add_closest (struct GNUNET_TESTING_PeerGroup *pg, unsigned int num,
-             GNUNET_TESTING_ConnectionProcessor proc)
+             GNUNET_TESTING_ConnectionProcessor proc, enum PeerLists list)
 {
+#if OLD
+
+#else
   struct FindClosestContext closest_ctx;
+#endif
   uint32_t pg_iter;
   uint32_t i;
 
@@ -3536,11 +3791,12 @@
           if (closest_ctx.closest != NULL)
             {
               GNUNET_assert (closest_ctx.closest_num < pg->total);
-              proc (pg, pg_iter, closest_ctx.closest_num);
+              proc (pg, pg_iter, closest_ctx.closest_num, list);
             }
         }
     }
 }
+#endif
 
 /**
  * From the set of connections possible, choose at least num connections per
@@ -3553,13 +3809,59 @@
 void
 perform_dfs (struct GNUNET_TESTING_PeerGroup *pg, unsigned int num)
 {
-  struct DFSContext dfs_ctx;
   uint32_t pg_iter;
   uint32_t dfs_count;
   uint32_t starting_peer;
   uint32_t least_connections;
+  uint32_t random_connection;
+#if OLD
+  unsigned int temp_count;
+  struct PeerConnection *peer_iter;
+#else
+  struct DFSContext dfs_ctx;
   GNUNET_HashCode second_hash;
+#endif
 
+#if OLD
+  starting_peer = 0;
+  dfs_count = 0;
+  while ((count_workingset_connections (pg) < num * pg->total)
+         && (count_allowed_connections (pg) > 0))
+    {
+      if (dfs_count % pg->total == 0)   /* Restart the DFS at some weakly 
connected peer */
+        {
+          least_connections = -1;       /* Set to very high number */
+          for (pg_iter = 0; pg_iter < pg->total; pg_iter++)
+            {
+              temp_count = 
count_connections(pg->peers[pg_iter].connect_peers_working_set_head);
+              if (temp_count < least_connections)
+                {
+                  starting_peer = pg_iter;
+                  least_connections = temp_count;
+                }
+            }
+        }
+
+      temp_count = 
count_connections(pg->peers[starting_peer].connect_peers_head);
+      if (temp_count == 0)
+        continue; /* FIXME: infinite loop? */
+
+      random_connection = GNUNET_CRYPTO_random_u32 
(GNUNET_CRYPTO_QUALITY_WEAK, temp_count);
+      temp_count = 0;
+      peer_iter = pg->peers[starting_peer].connect_peers_head;
+      while (temp_count < random_connection)
+        {
+          peer_iter = peer_iter->next;
+          temp_count++;
+        }
+      GNUNET_assert(peer_iter != NULL);
+      add_connections(pg, starting_peer, peer_iter->index, WORKING_SET);
+      remove_connections(pg, starting_peer, peer_iter->index, CONNECT);
+      starting_peer = peer_iter->index;
+      dfs_count++;
+    }
+
+#else
   for (pg_iter = 0; pg_iter < pg->total; pg_iter++)
     {
       pg->peers[pg_iter].connect_peers_working_set =
@@ -3630,8 +3932,10 @@
       pg->peers[pg_iter].connect_peers =
         pg->peers[pg_iter].connect_peers_working_set;
     }
+#endif
 }
 
+
 /**
  * Internal callback for topology information for a particular peer.
  */
@@ -4028,63 +4332,63 @@
       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                   _("Creating clique CONNECT topology\n"));
 #endif
-      create_clique (pg, &add_actual_connections);
+      create_clique (pg, &add_connections, CONNECT);
       break;
     case GNUNET_TESTING_TOPOLOGY_SMALL_WORLD_RING:
 #if VERBOSE_TOPOLOGY
       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                   _("Creating small world (ring) CONNECT topology\n"));
 #endif
-      create_small_world_ring (pg, &add_actual_connections);
+      create_small_world_ring (pg, &add_connections, CONNECT);
       break;
     case GNUNET_TESTING_TOPOLOGY_SMALL_WORLD:
 #if VERBOSE_TOPOLOGY
       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                   _("Creating small world (2d-torus) CONNECT topology\n"));
 #endif
-      create_small_world (pg, &add_actual_connections);
+      create_small_world (pg, &add_connections, CONNECT);
       break;
     case GNUNET_TESTING_TOPOLOGY_RING:
 #if VERBOSE_TOPOLOGY
       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                   _("Creating ring CONNECT topology\n"));
 #endif
-      create_ring (pg, &add_actual_connections);
+      create_ring (pg, &add_connections, CONNECT);
       break;
     case GNUNET_TESTING_TOPOLOGY_2D_TORUS:
 #if VERBOSE_TOPOLOGY
       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                   _("Creating 2d torus CONNECT topology\n"));
 #endif
-      create_2d_torus (pg, &add_actual_connections);
+      create_2d_torus (pg, &add_connections, CONNECT);
       break;
     case GNUNET_TESTING_TOPOLOGY_ERDOS_RENYI:
 #if VERBOSE_TOPOLOGY
       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                   _("Creating Erdos-Renyi CONNECT topology\n"));
 #endif
-      create_erdos_renyi (pg, &add_actual_connections);
+      create_erdos_renyi (pg, &add_connections, CONNECT);
       break;
     case GNUNET_TESTING_TOPOLOGY_INTERNAT:
 #if VERBOSE_TOPOLOGY
       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                   _("Creating InterNAT CONNECT topology\n"));
 #endif
-      create_nated_internet (pg, &add_actual_connections);
+      create_nated_internet (pg, &add_connections, CONNECT);
       break;
     case GNUNET_TESTING_TOPOLOGY_SCALE_FREE:
 #if VERBOSE_TOPOLOGY
       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                   _("Creating Scale Free CONNECT topology\n"));
 #endif
-      create_scale_free (pg, &add_actual_connections);
+      create_scale_free (pg, &add_connections, CONNECT);
       break;
     case GNUNET_TESTING_TOPOLOGY_LINE:
 #if VERBOSE_TOPOLOGY
       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                   _("Creating straight line CONNECT topology\n"));
 #endif
-      create_line (pg, &add_actual_connections);
+      create_line (pg, &add_connections, CONNECT);
       break;
     case GNUNET_TESTING_TOPOLOGY_NONE:
 #if VERBOSE_TOPOLOGY
@@ -4126,7 +4430,9 @@
                   ("Using DFS to connect a minimum of %u peers each (if 
possible)\n"),
                   (unsigned int) option_modifier);
 #endif
+#if FIXME
       perform_dfs (pg, (int) option_modifier);
+#endif
       break;
     case GNUNET_TESTING_TOPOLOGY_OPTION_ADD_CLOSEST:
 #if VERBOSE_TOPOLOGY
@@ -4135,8 +4441,10 @@
                   ("Finding additional %u closest peers each (if possible)\n"),
                   (unsigned int) option_modifier);
 #endif
+#if FIXME
       add_closest (pg, (unsigned int) option_modifier,
-                   &add_actual_connections);
+                   &add_connections, CONNECT);
+#endif
       break;
     case GNUNET_TESTING_TOPOLOGY_OPTION_NONE:
       break;
@@ -4412,24 +4720,27 @@
   char *newservicehome;
   char *tmpdir;
   char *hostkeys_file;
-  char *hostkey_data;
+  char *arg;
+  char *ssh_port_str;
   struct GNUNET_DISK_FileHandle *fd;
   struct GNUNET_CONFIGURATION_Handle *pcfg;
   unsigned int off;
   unsigned int hostcnt;
+  unsigned int i;
   uint16_t minport;
   uint16_t sshport;
   uint32_t upnum;
   uint32_t fdnum;
   uint64_t fs;
   uint64_t total_hostkeys;
+  struct GNUNET_OS_Process *proc;
 
   if (0 == total)
     {
       GNUNET_break (0);
       return NULL;
     }
-  hostkey_data = NULL;
+
   upnum = 0;
   fdnum = 0;
   pg = GNUNET_malloc (sizeof (struct GNUNET_TESTING_PeerGroup));
@@ -4522,6 +4833,34 @@
       minport = LOW_PORT;
     }
 
+  /* Create the servicehome directory for each remote peer */
+  GNUNET_assert(GNUNET_OK == GNUNET_CONFIGURATION_get_value_string (cfg, 
"PATHS", "SERVICEHOME",
+                                                                    
&baseservicehome));
+  for (i = 0; i < pg->num_hosts; i++)
+    {
+
+      if (NULL != pg->hosts[i].username)
+        GNUNET_asprintf (&arg, "address@hidden", pg->hosts[i].username, 
pg->hosts[i].hostname);
+      else
+        GNUNET_asprintf (&arg, "%s", pg->hosts[i].hostname);
+      if (pg->hosts[i].sshport != 0)
+        {
+          GNUNET_asprintf (&ssh_port_str, "%d", pg->hosts[i].sshport);
+          proc = GNUNET_OS_start_process (NULL, NULL, "ssh",
+                                          "ssh", "-P", ssh_port_str,
+#if !DEBUG_TESTING
+                                          "-q",
+#endif
+                                          arg, "mkdir -p", baseservicehome,  
NULL);
+        }
+      else
+        proc = GNUNET_OS_start_process (NULL, NULL, "ssh",
+                                            "ssh", arg, "mkdir -p", 
baseservicehome,  NULL);
+      GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Creating remote dir with command 
ssh %s %s %s\n", arg, " mkdir -p ", baseservicehome);
+      GNUNET_OS_process_wait(proc);
+    }
+  GNUNET_free(baseservicehome);
+
   if (GNUNET_YES == GNUNET_CONFIGURATION_get_value_string (cfg, "TESTING", 
"HOSTKEYSFILE",
                                                           &hostkeys_file))
     {
@@ -4541,7 +4880,7 @@
           if (GNUNET_YES != GNUNET_DISK_file_size (hostkeys_file, &fs, 
GNUNET_YES))
             fs = 0;
 
-          GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Found file size %llu for 
hostkeys, expect hostkeys to be size %d\n", fs, HOSTKEYFILESIZE);
+          GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Found file size %llu for 
hostkeys, expect hostkeys to be size %d\n", fs, HOSTKEYFILESIZE);
 
           if (fs % HOSTKEYFILESIZE != 0)
             {
@@ -4550,11 +4889,13 @@
           else
             {
               total_hostkeys = fs / HOSTKEYFILESIZE;
-              GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Will read %llu hostkeys 
from file\n", total_hostkeys);
-              hostkey_data = GNUNET_malloc_large (fs);
-              GNUNET_assert (fs == GNUNET_DISK_file_read (fd, hostkey_data, 
fs));
+              GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Will read %llu hostkeys 
from file\n", total_hostkeys);
+              pg->hostkey_data = GNUNET_malloc_large (fs);
+              GNUNET_assert (fs == GNUNET_DISK_file_read (fd, 
pg->hostkey_data, fs));
+              GNUNET_assert(GNUNET_OK == GNUNET_DISK_file_close(fd));
             }
         }
+      GNUNET_free(hostkeys_file);
     }
 
   for (off = 0; off < total; off++)
@@ -4605,21 +4946,24 @@
                                              "SERVICEHOME", newservicehome);
       GNUNET_free (newservicehome);
       pg->peers[off].cfg = pcfg;
+#if DEFER
+      /* Can we do this later? */
       pg->peers[off].allowed_peers =
         GNUNET_CONTAINER_multihashmap_create (total);
       pg->peers[off].connect_peers =
         GNUNET_CONTAINER_multihashmap_create (total);
       pg->peers[off].blacklisted_peers =
         GNUNET_CONTAINER_multihashmap_create (total);
+
+#endif
       pg->peers[off].pg = pg;
-
       pg->peers[off].internal_context.peer = &pg->peers[off];
       pg->peers[off].internal_context.timeout = timeout;
       pg->peers[off].internal_context.hostname = hostname;
       pg->peers[off].internal_context.username = username;
       pg->peers[off].internal_context.sshport = sshport;
-      if (hostkey_data != NULL)
-        pg->peers[off].internal_context.hostkey = &hostkey_data[off * 
HOSTKEYFILESIZE];
+      if (pg->hostkey_data != NULL)
+        pg->peers[off].internal_context.hostkey = &pg->hostkey_data[off * 
HOSTKEYFILESIZE];
       pg->peers[off].internal_context.hostkey_callback = hostkey_callback;
       pg->peers[off].internal_context.hostkey_cls = hostkey_cls;
       pg->peers[off].internal_context.start_cb = cb;
@@ -5190,6 +5534,10 @@
   unsigned int off;
   struct ShutdownContext *shutdown_ctx;
   struct PeerShutdownContext *peer_shutdown_ctx;
+#if OLD
+  struct PeerConnection *conn_iter;
+  struct PeerConnection *temp_conn;
+#endif
 
   GNUNET_assert (pg->total > 0);
 
@@ -5207,9 +5555,42 @@
       peer_shutdown_ctx->daemon = pg->peers[off].daemon;
       peer_shutdown_ctx->shutdown_ctx = shutdown_ctx;
       GNUNET_SCHEDULER_add_now (&schedule_shutdown_task, peer_shutdown_ctx);
-      //GNUNET_TESTING_daemon_stop (pg->peers[off].daemon, timeout, 
shutdown_cb, shutdown_ctx, GNUNET_YES, GNUNET_NO);
+
       if (NULL != pg->peers[off].cfg)
         GNUNET_CONFIGURATION_destroy (pg->peers[off].cfg);
+#if OLD
+      conn_iter = pg->peers[off].allowed_peers_head;
+      while (conn_iter != NULL)
+        {
+          temp_conn = conn_iter->next;
+          GNUNET_free(conn_iter);
+          conn_iter = temp_conn;
+        }
+
+      conn_iter = pg->peers[off].connect_peers_head;
+      while (conn_iter != NULL)
+        {
+          temp_conn = conn_iter->next;
+          GNUNET_free(conn_iter);
+          conn_iter = temp_conn;
+        }
+
+      conn_iter = pg->peers[off].blacklisted_peers_head;
+      while (conn_iter != NULL)
+        {
+          temp_conn = conn_iter->next;
+          GNUNET_free(conn_iter);
+          conn_iter = temp_conn;
+        }
+
+      conn_iter = pg->peers[off].connect_peers_working_set_head;
+      while (conn_iter != NULL)
+        {
+          temp_conn = conn_iter->next;
+          GNUNET_free(conn_iter);
+          conn_iter = temp_conn;
+        }
+#else
       if (pg->peers[off].allowed_peers != NULL)
         GNUNET_CONTAINER_multihashmap_destroy (pg->peers[off].allowed_peers);
       if (pg->peers[off].connect_peers != NULL)
@@ -5217,8 +5598,10 @@
       if (pg->peers[off].blacklisted_peers != NULL)
         GNUNET_CONTAINER_multihashmap_destroy (pg->
                                                peers[off].blacklisted_peers);
+#endif
     }
   GNUNET_free (pg->peers);
+  GNUNET_free_non_null(pg->hostkey_data);
   for (off = 0; off < pg->num_hosts; off++)
     {
       GNUNET_free (pg->hosts[off].hostname);




reply via email to

[Prev in Thread] Current Thread [Next in Thread]