- verboser log, faster start
[oweals/gnunet.git] / src / testbed / testbed_api_testbed.c
index c16e0b3327f4d9c25a1766d740836ae6c774c5eb..e9f7e4cbc7390602101885bfcf490f33cbb87765 100644 (file)
@@ -26,6 +26,7 @@
  */
 
 #include "platform.h"
+#include "gnunet_util_lib.h"
 #include "gnunet_testbed_service.h"
 #include "testbed_api_peers.h"
 #include "testbed_api_hosts.h"
   GNUNET_log_from (kind, "testbed-api-testbed", __VA_ARGS__)
 
 /**
- * Opaque handle to an abstract operation to be executed by the testing framework.
+ * Debug logging shortcut
  */
-struct GNUNET_TESTBED_Testbed
-{
-  /**
-   * The array of hosts
-   */
-  struct GNUNET_TESTBED_Host **hosts;
-
-  /**
-   * The number of hosts in the hosts array
-   */
-  unsigned int num_hosts;
-
-  /**
-   * The controller handle
-   */
-  struct GNUNET_TESTBED_Controller *c;
-};
-
+#define DEBUG(...)                              \
+  LOG (GNUNET_ERROR_TYPE_DEBUG, __VA_ARGS__)
 
 /**
  * DLL of operations
@@ -106,6 +91,11 @@ enum State
    */
   RC_LINKED,
 
+  /**
+   * Peers are created
+   */
+  RC_PEERS_CREATED,
+
   /**
    * The testbed run is ready and the master callback can be called now. At this
    * time the peers are all started and if a topology is provided in the
@@ -162,11 +152,16 @@ struct RunContext
    */
   void *cc_cls;
 
+  /**
+   * The trusted IP string
+   */
+  char *trusted_ip;
+
   /**
    * TestMaster callback to call when testbed initialization is done
    */
   GNUNET_TESTBED_TestMaster test_master;
-  
+
   /**
    * The closure for the TestMaster callback
    */
@@ -213,6 +208,11 @@ struct RunContext
    */
   struct GNUNET_TESTBED_HostRegistrationHandle *reg_handle;
 
+  /**
+   * Profiling start time
+   */
+  struct GNUNET_TIME_Absolute pstart_time;
+
   /**
    * Host registration task
    */
@@ -238,6 +238,11 @@ struct RunContext
    */
   enum GNUNET_TESTBED_TopologyOption topology;
 
+  /**
+   * Have we already shutdown
+   */
+  int shutdown;
+
   /**
    * Number of hosts in the given host file
    */
@@ -260,12 +265,6 @@ struct RunContext
    */
   unsigned int num_peers;
 
-  /**
-   * counter to count overlay connect attempts. This counter includes both
-   * successful and failed overlay connects
-   */
-  unsigned int oc_count;
-
   /**
    * Expected overlay connects. Should be zero if no topology is relavant
    */
@@ -275,10 +274,27 @@ struct RunContext
    * Number of random links to established
    */
   unsigned int random_links;
-  
+
 };
 
 
+/**
+ * Function to return the string representation of the duration between current
+ * time and `pstart_time' in `RunContext'
+ *
+ * @param rc the RunContext
+ * @return the representation string; this is NOT reentrant
+ */
+static const char *
+prof_time (struct RunContext *rc)
+{
+  struct GNUNET_TIME_Relative ptime;
+
+  ptime = GNUNET_TIME_absolute_get_duration (rc->pstart_time);
+  return GNUNET_STRINGS_relative_time_to_string (ptime, GNUNET_YES);
+}
+
+
 /**
  * Task for starting peers
  *
@@ -292,7 +308,8 @@ start_peers_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
   struct DLLOperation *dll_op;
   unsigned int peer;
 
-  LOG (GNUNET_ERROR_TYPE_DEBUG, "Starting Peers\n");
+  DEBUG ("Starting Peers\n");
+  rc->pstart_time = GNUNET_TIME_absolute_get ();
   for (peer = 0; peer < rc->num_peers; peer++)
   {
     dll_op = GNUNET_malloc (sizeof (struct DLLOperation));
@@ -337,7 +354,8 @@ peer_create_cb (void *cls, struct GNUNET_TESTBED_Peer *peer, const char *emsg)
   rc->peer_count++;
   if (rc->peer_count < rc->num_peers)
     return;
-  LOG (GNUNET_ERROR_TYPE_DEBUG, "Required peers created successfully\n");
+  DEBUG ("%u peers created in %s\n", rc->num_peers, prof_time (rc));
+  rc->state = RC_PEERS_CREATED;
   GNUNET_SCHEDULER_add_now (&start_peers_task, rc);
 }
 
@@ -360,19 +378,8 @@ cleanup_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
   GNUNET_assert (NULL == rc->peers);
   GNUNET_assert (NULL == rc->hc_handles);
   GNUNET_assert (RC_PEERS_DESTROYED == rc->state);
-  if (NULL != rc->c)
-    GNUNET_TESTBED_controller_disconnect (rc->c);
-  if (NULL != rc->cproc)
-    GNUNET_TESTBED_controller_stop (rc->cproc);
-  if (NULL != rc->h)
-    GNUNET_TESTBED_host_destroy (rc->h);
-  for (hid = 0; hid < rc->num_hosts; hid++)
-        GNUNET_TESTBED_host_destroy (rc->hosts[hid]);
-  GNUNET_free_non_null (rc->hosts);
   if (NULL != rc->dll_op_head)
-  {
-    LOG (GNUNET_ERROR_TYPE_WARNING,
-         _("Some operations are still pending. Cancelling them\n"));
+  {                             /* cancel our pending operations */
     while (NULL != (dll_op = rc->dll_op_head))
     {
       GNUNET_TESTBED_operation_done (dll_op->op);
@@ -380,13 +387,49 @@ cleanup_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
       GNUNET_free (dll_op);
     }
   }
+  if (NULL != rc->c)
+    GNUNET_TESTBED_controller_disconnect (rc->c);
+  if (NULL != rc->cproc)
+    GNUNET_TESTBED_controller_stop (rc->cproc);
+  if (NULL != rc->h)
+    GNUNET_TESTBED_host_destroy (rc->h);
+  for (hid = 0; hid < rc->num_hosts; hid++)
+    GNUNET_TESTBED_host_destroy (rc->hosts[hid]);
+  GNUNET_free_non_null (rc->hosts);
   if (NULL != rc->cfg)
     GNUNET_CONFIGURATION_destroy (rc->cfg);
   GNUNET_free_non_null (rc->topo_file);
+  GNUNET_free_non_null (rc->trusted_ip);
   GNUNET_free (rc);
 }
 
 
+/**
+ * Stops the testbed run and releases any used resources
+ *
+ * @param cls the tesbed run handle
+ * @param tc the task context from scheduler
+ */
+static void
+shutdown_run (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc);
+
+
+/**
+ * Function to shutdown now
+ *
+ * @param rc the RunContext
+ */
+static void
+shutdown_now (struct RunContext *rc)
+{
+  if (GNUNET_YES == rc->shutdown)
+    return;
+  if (GNUNET_SCHEDULER_NO_TASK != rc->shutdown_run_task)
+    GNUNET_SCHEDULER_cancel (rc->shutdown_run_task);
+  rc->shutdown_run_task = GNUNET_SCHEDULER_add_now (&shutdown_run, rc);
+}
+
+
 /**
  * Stops the testbed run and releases any used resources
  *
@@ -398,11 +441,14 @@ shutdown_run (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   struct RunContext *rc = cls;
   struct DLLOperation *dll_op;
+  int all_peers_destroyed;
   unsigned int peer;
   unsigned int nhost;
 
   GNUNET_assert (GNUNET_SCHEDULER_NO_TASK != rc->shutdown_run_task);
   rc->shutdown_run_task = GNUNET_SCHEDULER_NO_TASK;
+  GNUNET_assert (GNUNET_NO == rc->shutdown);
+  rc->shutdown = GNUNET_YES;
   if (NULL != rc->hc_handles)
   {
     for (nhost = 0; nhost < rc->num_hosts; nhost++)
@@ -437,6 +483,8 @@ shutdown_run (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
       /* Check if some peers are stopped */
       for (peer = 0; peer < rc->num_peers; peer++)
       {
+        if (NULL == rc->peers[peer])
+          continue;
         if (PS_STOPPED != rc->peers[peer]->state)
           break;
       }
@@ -444,19 +492,30 @@ shutdown_run (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
       {
         /* All peers are stopped */
         rc->state = RC_PEERS_STOPPED;
+        all_peers_destroyed = GNUNET_YES;
         for (peer = 0; peer < rc->num_peers; peer++)
         {
+          if (NULL == rc->peers[peer])
+            continue;
+          all_peers_destroyed = GNUNET_NO;
           dll_op = GNUNET_malloc (sizeof (struct DLLOperation));
           dll_op->op = GNUNET_TESTBED_peer_destroy (rc->peers[peer]);
           GNUNET_CONTAINER_DLL_insert_tail (rc->dll_op_head, rc->dll_op_tail,
                                             dll_op);
         }
-        return;
+        if (all_peers_destroyed == GNUNET_NO)
+        {
+          DEBUG ("Destroying peers\n");
+          rc->pstart_time = GNUNET_TIME_absolute_get ();
+          return;
+        }
       }
       /* Some peers are stopped */
+      DEBUG ("Stopping peers\n");
+      rc->pstart_time = GNUNET_TIME_absolute_get ();
       for (peer = 0; peer < rc->num_peers; peer++)
       {
-        if (PS_STARTED != rc->peers[peer]->state)
+        if ((NULL == rc->peers[peer]) || (PS_STARTED != rc->peers[peer]->state))
         {
           rc->peer_count++;
           continue;
@@ -469,6 +528,8 @@ shutdown_run (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
       }
       if (rc->peer_count != rc->num_peers)
         return;
+      GNUNET_free (rc->peers);
+      rc->peers = NULL;
     }
   }
   rc->state = RC_PEERS_DESTROYED;       /* No peers are present so we consider the
@@ -487,9 +548,10 @@ static void
 call_master (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   struct RunContext *rc = cls;
-  
+
   if (NULL != rc->topology_operation)
   {
+    DEBUG ("Overlay topology generated in %s\n", prof_time (rc));
     GNUNET_TESTBED_operation_done (rc->topology_operation);
     rc->topology_operation = NULL;
   }
@@ -498,6 +560,27 @@ call_master (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 }
 
 
+/**
+ * Callbacks of this type are called when topology configuration is completed
+ *
+ * @param cls the operation closure given to
+ *          GNUNET_TESTBED_overlay_configure_topology_va() and
+ *          GNUNET_TESTBED_overlay_configure() calls
+ * @param nsuccess the number of successful overlay connects
+ * @param nfailures the number of overlay connects which failed
+ */
+static void
+topology_completion_callback (void *cls, unsigned int nsuccess,
+                              unsigned int nfailures)
+{
+  struct RunContext *rc = cls;
+
+  rc->state = RC_READY;
+  GNUNET_SCHEDULER_add_continuation (&call_master, rc,
+                                     GNUNET_SCHEDULER_REASON_PREREQ_DONE);
+}
+
+
 /**
  * Function to create peers
  *
@@ -509,6 +592,8 @@ create_peers (struct RunContext *rc)
   struct DLLOperation *dll_op;
   unsigned int peer;
 
+  DEBUG ("Creating peers\n");
+  rc->pstart_time = GNUNET_TIME_absolute_get ();
   rc->peers =
       GNUNET_malloc (sizeof (struct GNUNET_TESTBED_Peer *) * rc->num_peers);
   GNUNET_assert (NULL != rc->c);
@@ -518,11 +603,11 @@ create_peers (struct RunContext *rc)
     dll_op = GNUNET_malloc (sizeof (struct DLLOperation));
     dll_op->rc = rc;
     dll_op->op =
-        GNUNET_TESTBED_peer_create (rc->c, 
-                                    (0 == rc->num_hosts)
-                                    ? rc->h : rc->hosts[peer % rc->num_hosts],
-                                    rc->cfg,
-                                    peer_create_cb, dll_op);
+        GNUNET_TESTBED_peer_create (rc->c,
+                                    (0 ==
+                                     rc->num_hosts) ? rc->h : rc->hosts[peer %
+                                                                        rc->num_hosts],
+                                    rc->cfg, peer_create_cb, dll_op);
     GNUNET_CONTAINER_DLL_insert_tail (rc->dll_op_head, rc->dll_op_tail, dll_op);
   }
 }
@@ -550,10 +635,8 @@ event_cb (void *cls, const struct GNUNET_TESTBED_EventInformation *event)
       dll_op = event->details.operation_finished.op_cls;
       if (NULL != event->details.operation_finished.emsg)
       {
-        LOG (GNUNET_ERROR_TYPE_ERROR,
-             _("Linking controllers failed. Exiting"));
-        GNUNET_SCHEDULER_cancel (rc->shutdown_run_task);
-        rc->shutdown_run_task = GNUNET_SCHEDULER_add_now (&shutdown_run, rc);
+        LOG (GNUNET_ERROR_TYPE_ERROR, _("Linking controllers failed. Exiting"));
+        shutdown_now (rc);
       }
       else
         rc->reg_hosts++;
@@ -568,80 +651,56 @@ event_cb (void *cls, const struct GNUNET_TESTBED_EventInformation *event)
       }
       return;
     default:
-      GNUNET_assert (0);
-      GNUNET_SCHEDULER_cancel (rc->shutdown_run_task);
-      rc->shutdown_run_task = GNUNET_SCHEDULER_add_now (&shutdown_run, rc);
+      GNUNET_break (0);
+      shutdown_now (rc);
       return;
     }
   }
-  if (NULL != rc->topology_operation)
+  for (dll_op = rc->dll_op_head; NULL != dll_op; dll_op = dll_op->next)
   {
-    switch (event->type)
-    {
-    case GNUNET_TESTBED_ET_OPERATION_FINISHED:
-    case GNUNET_TESTBED_ET_CONNECT:
-      rc->oc_count++;
+    if ((GNUNET_TESTBED_ET_OPERATION_FINISHED == event->type) &&
+        (event->details.operation_finished.operation == dll_op->op))
+      break;
+    if ((GNUNET_TESTBED_ET_PEER_STOP == event->type) &&
+        (event->details.peer_stop.peer == dll_op->cls))
       break;
-    default:
-      GNUNET_assert (0);
-      GNUNET_SCHEDULER_cancel (rc->shutdown_run_task);
-      rc->shutdown_run_task = GNUNET_SCHEDULER_add_now (&shutdown_run, rc);
-      return;
-    }
-    if (rc->oc_count == rc->num_oc)
-    {
-      rc->state = RC_READY;
-      GNUNET_SCHEDULER_add_continuation (&call_master, rc,
-                                         GNUNET_SCHEDULER_REASON_PREREQ_DONE);
-    }
-    return;
   }
-  if ((RC_LINKED < rc->state) &&
-      ((GNUNET_TESTBED_ET_OPERATION_FINISHED == event->type) ||
-       (GNUNET_TESTBED_ET_PEER_STOP == event->type)))
+  if (NULL == dll_op)
+    goto call_cc;
+  GNUNET_CONTAINER_DLL_remove (rc->dll_op_head, rc->dll_op_tail, dll_op);
+  GNUNET_TESTBED_operation_done (dll_op->op);
+  GNUNET_free (dll_op);
+  rc->peer_count++;
+  if (rc->peer_count < rc->num_peers)
+    return;
+  switch (rc->state)
   {
-    for (dll_op = rc->dll_op_head; NULL != dll_op; dll_op = dll_op->next)
-    {
-      if ((GNUNET_TESTBED_ET_OPERATION_FINISHED == event->type) &&
-          (event->details.operation_finished.operation == dll_op->op))
-        break;
-      if ((GNUNET_TESTBED_ET_PEER_STOP == event->type) &&
-          (event->details.peer_stop.peer == dll_op->cls))
-        break;
-    }
-    if (NULL == dll_op)
-      goto call_cc;
-    GNUNET_CONTAINER_DLL_remove (rc->dll_op_head, rc->dll_op_tail, dll_op);
-    GNUNET_TESTBED_operation_done (dll_op->op);
-    GNUNET_free (dll_op);
-    rc->peer_count++;
-    if (rc->peer_count < rc->num_peers)
-      return;
-    switch (rc->state)
+  case RC_PEERS_CREATED:
+  case RC_READY:
+    rc->state = RC_PEERS_STOPPED;
+    DEBUG ("Peers stopped in %s\n", prof_time (rc));
+    DEBUG ("Destroying peers\n");
+    rc->pstart_time = GNUNET_TIME_absolute_get ();
+    rc->peer_count = 0;
+    for (peer_id = 0; peer_id < rc->num_peers; peer_id++)
     {
-    case RC_READY:
-      rc->state = RC_PEERS_STOPPED;
-      rc->peer_count = 0;
-      for (peer_id = 0; peer_id < rc->num_peers; peer_id++)
-      {
-        dll_op = GNUNET_malloc (sizeof (struct DLLOperation));
-        dll_op->op = GNUNET_TESTBED_peer_destroy (rc->peers[peer_id]);
-        GNUNET_CONTAINER_DLL_insert_tail (rc->dll_op_head, rc->dll_op_tail,
-                                          dll_op);
-      }
-      break;
-    case RC_PEERS_STOPPED:
-      rc->state = RC_PEERS_DESTROYED;
-      GNUNET_free (rc->peers);
-      rc->peers = NULL;
-      LOG (GNUNET_ERROR_TYPE_DEBUG, "All peers successfully destroyed\n");
-      GNUNET_SCHEDULER_add_now (&cleanup_task, rc);
-      break;
-    default:
-      GNUNET_assert (0);
+      dll_op = GNUNET_malloc (sizeof (struct DLLOperation));
+      dll_op->op = GNUNET_TESTBED_peer_destroy (rc->peers[peer_id]);
+      GNUNET_CONTAINER_DLL_insert_tail (rc->dll_op_head, rc->dll_op_tail,
+                                        dll_op);
     }
-    return;
+    break;
+  case RC_PEERS_STOPPED:
+    rc->state = RC_PEERS_DESTROYED;
+    GNUNET_free (rc->peers);
+    rc->peers = NULL;
+    DEBUG ("Peers destroyed in %s\n", prof_time (rc));
+    GNUNET_SCHEDULER_add_now (&cleanup_task, rc);
+    break;
+  default:
+    GNUNET_assert (0);
   }
+  return;
 
 call_cc:
   if ((0 != (rc->event_mask & (1LL << event->type))) && (NULL != rc->cc))
@@ -652,25 +711,26 @@ call_cc:
     if ((NULL != dll_op->cls) &&
         (event->details.peer_start.peer == dll_op->cls))
       break;
-  GNUNET_assert (NULL != dll_op);
+  if (NULL == dll_op)           /* Not our operation */
+    return;
   GNUNET_CONTAINER_DLL_remove (rc->dll_op_head, rc->dll_op_tail, dll_op);
   GNUNET_TESTBED_operation_done (dll_op->op);
   GNUNET_free (dll_op);
   rc->peer_count++;
   if (rc->peer_count < rc->num_peers)
     return;
-  LOG (GNUNET_ERROR_TYPE_DEBUG, "Peers started successfully\n");
+  DEBUG ("%u peers started in %s\n", rc->num_peers, prof_time (rc));
   if (GNUNET_TESTBED_TOPOLOGY_NONE != rc->topology)
   {
-    if ( (GNUNET_TESTBED_TOPOLOGY_ERDOS_RENYI == rc->topology)
-         || (GNUNET_TESTBED_TOPOLOGY_SMALL_WORLD_RING == rc->topology)
-         || (GNUNET_TESTBED_TOPOLOGY_SMALL_WORLD == rc->topology))
+    if ((GNUNET_TESTBED_TOPOLOGY_ERDOS_RENYI == rc->topology) ||
+        (GNUNET_TESTBED_TOPOLOGY_SMALL_WORLD_RING == rc->topology) ||
+        (GNUNET_TESTBED_TOPOLOGY_SMALL_WORLD == rc->topology))
     {
       rc->topology_operation =
-          GNUNET_TESTBED_overlay_configure_topology (NULL,
-                                                     rc->num_peers,
-                                                     rc->peers,
-                                                     &rc->num_oc,
+          GNUNET_TESTBED_overlay_configure_topology (NULL, rc->num_peers,
+                                                     rc->peers, &rc->num_oc,
+                                                     &topology_completion_callback,
+                                                     rc,
                                                      rc->topology,
                                                      rc->random_links,
                                                      GNUNET_TESTBED_TOPOLOGY_OPTION_END);
@@ -679,27 +739,31 @@ call_cc:
     {
       GNUNET_assert (NULL != rc->topo_file);
       rc->topology_operation =
-          GNUNET_TESTBED_overlay_configure_topology (NULL,
-                                                     rc->num_peers,
-                                                     rc->peers,
-                                                     &rc->num_oc,
+          GNUNET_TESTBED_overlay_configure_topology (NULL, rc->num_peers,
+                                                     rc->peers, &rc->num_oc,
+                                                     &topology_completion_callback,
+                                                     rc,
                                                      rc->topology,
                                                      rc->topo_file,
                                                      GNUNET_TESTBED_TOPOLOGY_OPTION_END);
     }
     else
       rc->topology_operation =
-          GNUNET_TESTBED_overlay_configure_topology (NULL,
-                                                     rc->num_peers,
-                                                     rc->peers,
-                                                     &rc->num_oc,
+          GNUNET_TESTBED_overlay_configure_topology (NULL, rc->num_peers,
+                                                     rc->peers, &rc->num_oc,
+                                                     &topology_completion_callback,
+                                                     rc,
                                                      rc->topology,
                                                      GNUNET_TESTBED_TOPOLOGY_OPTION_END);
     if (NULL == rc->topology_operation)
       LOG (GNUNET_ERROR_TYPE_WARNING,
            "Not generating topology. Check number of peers\n");
     else
+    {
+      DEBUG ("Creating overlay topology\n");
+      rc->pstart_time = GNUNET_TIME_absolute_get ();
       return;
+    }
   }
   rc->state = RC_READY;
   GNUNET_SCHEDULER_add_continuation (&call_master, rc,
@@ -733,8 +797,7 @@ host_registration_completion (void *cls, const char *emsg)
   {
     LOG (GNUNET_ERROR_TYPE_WARNING,
          _("Host registration failed for a host. Error: %s\n"), emsg);
-    GNUNET_SCHEDULER_cancel (rc->shutdown_run_task);
-    rc->shutdown_run_task = GNUNET_SCHEDULER_add_now (&shutdown_run, rc);
+    shutdown_now (rc);
     return;
   }
   rc->register_hosts_task = GNUNET_SCHEDULER_add_now (&register_hosts, rc);
@@ -757,28 +820,25 @@ register_hosts (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
   rc->register_hosts_task = GNUNET_SCHEDULER_NO_TASK;
   if (rc->reg_hosts == rc->num_hosts)
   {
-    LOG (GNUNET_ERROR_TYPE_DEBUG,
-         "All hosts successfully registered\n");
+    DEBUG ("All hosts successfully registered\n");
     /* Start slaves */
     for (slave = 0; slave < rc->num_hosts; slave++)
     {
       dll_op = GNUNET_malloc (sizeof (struct DLLOperation));
       dll_op->rc = rc;
-      dll_op->op = GNUNET_TESTBED_controller_link (dll_op,
-                                                   rc->c,
-                                                   rc->hosts[slave],
-                                                   rc->h,
-                                                   rc->cfg,
-                                                   GNUNET_YES);
-      GNUNET_CONTAINER_DLL_insert_tail (rc->dll_op_head, rc->dll_op_tail, dll_op);
+      dll_op->op =
+          GNUNET_TESTBED_controller_link (dll_op, rc->c, rc->hosts[slave],
+                                          rc->h, rc->cfg, GNUNET_YES);
+      GNUNET_CONTAINER_DLL_insert_tail (rc->dll_op_head, rc->dll_op_tail,
+                                        dll_op);
     }
     rc->reg_hosts = 0;
     return;
   }
-  rc->reg_handle = GNUNET_TESTBED_register_host (rc->c,
-                                                 rc->hosts[rc->reg_hosts++],
-                                                 host_registration_completion,
-                                                 rc);
+  rc->reg_handle =
+      GNUNET_TESTBED_register_host (rc->c, rc->hosts[rc->reg_hosts],
+                                    host_registration_completion, rc);
+  rc->reg_hosts++;
 }
 
 
@@ -800,8 +860,18 @@ controller_status_cb (void *cls, const struct GNUNET_CONFIGURATION_Handle *cfg,
 
   if (status != GNUNET_OK)
   {
-    GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "Testbed startup failed\n");
-    return;
+    switch (rc->state)
+    {
+    case RC_INIT:
+      GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "Testbed startup failed\n");
+      return;
+    default:
+      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                  "Controller crash detected. Shutting down.\n");
+      rc->cproc = NULL;
+      shutdown_now (rc);
+      return;
+    }
   }
   GNUNET_CONFIGURATION_destroy (rc->cfg);
   rc->cfg = GNUNET_CONFIGURATION_dup (cfg);
@@ -812,9 +882,11 @@ controller_status_cb (void *cls, const struct GNUNET_CONFIGURATION_Handle *cfg,
   if (rc->topology < GNUNET_TESTBED_TOPOLOGY_NONE)
     event_mask |= GNUNET_TESTBED_ET_CONNECT;
   rc->c =
-      GNUNET_TESTBED_controller_connect (rc->cfg, rc->h, event_mask, &event_cb, rc);
+      GNUNET_TESTBED_controller_connect (rc->cfg, rc->h, event_mask, &event_cb,
+                                         rc);
   if (0 < rc->num_hosts)
   {
+    rc->reg_hosts = 0;
     rc->register_hosts_task = GNUNET_SCHEDULER_add_now (&register_hosts, rc);
     return;
   }
@@ -823,6 +895,44 @@ controller_status_cb (void *cls, const struct GNUNET_CONFIGURATION_Handle *cfg,
 }
 
 
+/**
+ * Callback function invoked for each interface found.
+ *
+ * @param cls closure
+ * @param name name of the interface (can be NULL for unknown)
+ * @param isDefault is this presumably the default interface
+ * @param addr address of this interface (can be NULL for unknown or unassigned)
+ * @param broadcast_addr the broadcast address (can be NULL for unknown or unassigned)
+ * @param netmask the network mask (can be NULL for unknown or unassigned))
+ * @param addrlen length of the address
+ * @return GNUNET_OK to continue iteration, GNUNET_SYSERR to abort
+ */
+static int
+netint_proc (void *cls, const char *name, int isDefault,
+             const struct sockaddr *addr, const struct sockaddr *broadcast_addr,
+             const struct sockaddr *netmask, socklen_t addrlen)
+{
+  struct RunContext *rc = cls;
+  char hostip[NI_MAXHOST];
+  char *buf;
+
+  if (sizeof (struct sockaddr_in) != addrlen)
+    return GNUNET_OK;           /* Only consider IPv4 for now */
+  if (0 !=
+      getnameinfo (addr, addrlen, hostip, NI_MAXHOST, NULL, 0, NI_NUMERICHOST))
+    GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "getnameinfo");
+  if (NULL == rc->trusted_ip)
+  {
+    rc->trusted_ip = GNUNET_strdup (hostip);
+    return GNUNET_YES;
+  }
+  (void) GNUNET_asprintf (&buf, "%s; %s", rc->trusted_ip, hostip);
+  GNUNET_free (rc->trusted_ip);
+  rc->trusted_ip = buf;
+  return GNUNET_YES;
+}
+
+
 /**
  * Callbacks of this type are called by GNUNET_TESTBED_is_host_habitable to
  * inform whether the given host is habitable or not. The Handle returned by
@@ -833,12 +943,14 @@ controller_status_cb (void *cls, const struct GNUNET_CONFIGURATION_Handle *cfg,
  *          given to GNUNET_TESTBED_is_host_habitable() is NULL
  * @param status GNUNET_YES if it is habitable; GNUNET_NO if not
  */
-static void 
-host_habitable_cb (void *cls, const struct GNUNET_TESTBED_Host *host, int status)
+static void
+host_habitable_cb (void *cls, const struct GNUNET_TESTBED_Host *host,
+                   int status)
 {
   struct RunContext *rc = cls;
+  struct GNUNET_TESTBED_Host **old_hosts;
   unsigned int nhost;
-  
+
   for (nhost = 0; nhost < rc->num_hosts; nhost++)
   {
     if (host == rc->hosts[nhost])
@@ -852,9 +964,9 @@ host_habitable_cb (void *cls, const struct GNUNET_TESTBED_Host *host, int status
       LOG (GNUNET_ERROR_TYPE_ERROR, _("Host %s cannot start testbed\n"),
            GNUNET_TESTBED_host_get_hostname (host));
     else
-      LOG (GNUNET_ERROR_TYPE_ERROR, _("Testbed cannot be started on localhost\n"));
-    GNUNET_SCHEDULER_cancel (rc->shutdown_run_task);
-    rc->shutdown_run_task = GNUNET_SCHEDULER_add_now (&shutdown_run, rc);
+      LOG (GNUNET_ERROR_TYPE_ERROR,
+           _("Testbed cannot be started on localhost\n"));
+    shutdown_now (rc);
     return;
   }
   rc->reg_hosts++;
@@ -865,22 +977,31 @@ host_habitable_cb (void *cls, const struct GNUNET_TESTBED_Host *host, int status
   rc->h = rc->hosts[0];
   rc->num_hosts--;
   if (0 < rc->num_hosts)
-    rc->hosts = &rc->hosts[1];
+  {
+    old_hosts = rc->hosts;
+    rc->hosts =
+        GNUNET_malloc (sizeof (struct GNUNET_TESTBED_Host *) * rc->num_hosts);
+    memcpy (rc->hosts, &old_hosts[1],
+            (sizeof (struct GNUNET_TESTBED_Host *) * rc->num_hosts));
+    GNUNET_free (old_hosts);
+  }
   else
   {
     GNUNET_free (rc->hosts);
     rc->hosts = NULL;
   }
-  /* FIXME: If we are starting controller on different host 127.0.0.1 may not ab
-  correct */
+  GNUNET_OS_network_interfaces_list (netint_proc, rc);
+  if (NULL == rc->trusted_ip)
+    rc->trusted_ip = GNUNET_strdup ("127.0.0.1");
   rc->cproc =
-      GNUNET_TESTBED_controller_start ("127.0.0.1", rc->h, rc->cfg,
+      GNUNET_TESTBED_controller_start (rc->trusted_ip, rc->h, rc->cfg,
                                        &controller_status_cb, rc);
+  GNUNET_free (rc->trusted_ip);
+  rc->trusted_ip = NULL;
   if (NULL == rc->cproc)
   {
     LOG (GNUNET_ERROR_TYPE_ERROR, _("Cannot start the master controller"));
-    GNUNET_SCHEDULER_cancel (rc->shutdown_run_task);
-    rc->shutdown_run_task = GNUNET_SCHEDULER_add_now (&shutdown_run, rc);
+    shutdown_now (rc);
   }
 }
 
@@ -925,9 +1046,8 @@ GNUNET_TESTBED_run (const char *host_filename,
   unsigned long long random_links;
   unsigned int hid;
   unsigned int nhost;
-  
+
   GNUNET_assert (num_peers > 0);
-  host_filename = NULL;
   rc = GNUNET_malloc (sizeof (struct RunContext));
   if (NULL != host_filename)
   {
@@ -950,16 +1070,17 @@ GNUNET_TESTBED_run (const char *host_filename,
   rc->test_master = test_master;
   rc->test_master_cls = test_master_cls;
   rc->state = RC_INIT;
-  rc->topology = GNUNET_TESTBED_TOPOLOGY_NONE;  
-  if (GNUNET_OK == GNUNET_CONFIGURATION_get_value_string (rc->cfg, "testbed",
-                                                          "OVERLAY_TOPOLOGY",
-                                                          &topology))
+  rc->topology = GNUNET_TESTBED_TOPOLOGY_NONE;
+  if (GNUNET_OK ==
+      GNUNET_CONFIGURATION_get_value_string (rc->cfg, "testbed",
+                                             "OVERLAY_TOPOLOGY", &topology))
   {
-    if (GNUNET_NO == GNUNET_TESTBED_topology_get_ (&rc->topology,
-                                                    topology))
+    if (GNUNET_NO == GNUNET_TESTBED_topology_get_ (&rc->topology, topology))
     {
-      LOG (GNUNET_ERROR_TYPE_WARNING,
-           "Unknown topology %s given in configuration\n", topology);
+      GNUNET_log_config_invalid (GNUNET_ERROR_TYPE_ERROR, "testbed",
+                                 "OVERLAY_TOPLOGY",
+                                 _
+                                 ("Specified topology must be supported by testbed"));
     }
     GNUNET_free (topology);
   }
@@ -968,47 +1089,54 @@ GNUNET_TESTBED_run (const char *host_filename,
   case GNUNET_TESTBED_TOPOLOGY_ERDOS_RENYI:
   case GNUNET_TESTBED_TOPOLOGY_SMALL_WORLD_RING:
   case GNUNET_TESTBED_TOPOLOGY_SMALL_WORLD:
-    if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_number (rc->cfg, "testbed",
-                                                            "OVERLAY_RANDOM_LINKS",
-                                                            &random_links))
+    if (GNUNET_OK !=
+        GNUNET_CONFIGURATION_get_value_number (rc->cfg, "testbed",
+                                               "OVERLAY_RANDOM_LINKS",
+                                               &random_links))
     {
       /* OVERLAY option RANDOM & SMALL_WORLD_RING requires OVERLAY_RANDOM_LINKS
-         option to be set to the number of random links to be established  */
-      GNUNET_break (0);
+       * option to be set to the number of random links to be established  */
+      GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR, "testbed",
+                                 "OVERLAY_RANDOM_LINKS");
       goto error_cleanup;
     }
     if (random_links > UINT32_MAX)
     {
-      GNUNET_break (0);       /* Too big number */
+      GNUNET_break (0);         /* Too big number */
       goto error_cleanup;
     }
     rc->random_links = (unsigned int) random_links;
     break;
   case GNUNET_TESTBED_TOPOLOGY_FROM_FILE:
-    if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_string (rc->cfg, "testbed",
-                                                            "TOPOLOGY_FILE",
-                                                            &rc->topo_file))
+    if (GNUNET_OK !=
+        GNUNET_CONFIGURATION_get_value_string (rc->cfg, "testbed",
+                                               "OVERLAY_TOPOLOGY_FILE",
+                                               &rc->topo_file))
     {
-      /* You need to set TOPOLOGY_FILE option to a topolog file */
-      GNUNET_break (0);
+      GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR, "testbed",
+                                 "OVERLAY_TOPOLOGY_FILE");
       goto error_cleanup;
     }
-    break;
-  default:   
-    /* Do nothing */
+  default:
+    /* Warn if OVERLAY_RANDOM_LINKS is present that it will be ignored */
+    if (GNUNET_YES ==
+        GNUNET_CONFIGURATION_have_value (rc->cfg, "testbed",
+                                         "OVERLAY_RANDOM_LINKS"))
+      LOG (GNUNET_ERROR_TYPE_WARNING,
+           "Ignoring value of `OVERLAY_RANDOM_LINKS' in given configuration\n");
     break;
   }
   if (NULL != host_filename)
   {
-    rc->hc_handles = GNUNET_malloc (sizeof (struct
-                                            GNUNET_TESTBED_HostHabitableCheckHandle *) 
-                                    * rc->num_hosts);
-    for (nhost = 0; nhost < rc->num_hosts; nhost++) 
-    {    
-      if (NULL == (rc->hc_handles[nhost] = 
-                   GNUNET_TESTBED_is_host_habitable (rc->hosts[nhost], rc->cfg,
-                                                     &host_habitable_cb,
-                                                     rc)))
+    rc->hc_handles =
+        GNUNET_malloc (sizeof (struct GNUNET_TESTBED_HostHabitableCheckHandle *)
+                       * rc->num_hosts);
+    for (nhost = 0; nhost < rc->num_hosts; nhost++)
+    {
+      if (NULL ==
+          (rc->hc_handles[nhost] =
+           GNUNET_TESTBED_is_host_habitable (rc->hosts[nhost], rc->cfg,
+                                             &host_habitable_cb, rc)))
       {
         GNUNET_break (0);
         for (nhost = 0; nhost < rc->num_hosts; nhost++)
@@ -1022,14 +1150,14 @@ GNUNET_TESTBED_run (const char *host_filename,
   }
   else
     rc->cproc =
-      GNUNET_TESTBED_controller_start ("127.0.0.1", rc->h, rc->cfg,
-                                       &controller_status_cb, rc);
+        GNUNET_TESTBED_controller_start ("127.0.0.1", rc->h, rc->cfg,
+                                         &controller_status_cb, rc);
   rc->shutdown_run_task =
-      GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_FOREVER_REL,
-                                    &shutdown_run, rc);
+      GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_FOREVER_REL, &shutdown_run,
+                                    rc);
   return;
 
- error_cleanup:
+error_cleanup:
   if (NULL != rc->h)
     GNUNET_TESTBED_host_destroy (rc->h);
   if (NULL != rc->hosts)
@@ -1043,105 +1171,4 @@ GNUNET_TESTBED_run (const char *host_filename,
 }
 
 
-/**
- * Configure and run a testbed using the given
- * master controller on 'num_hosts' starting
- * 'num_peers' using the given peer configuration.
- *
- * @param controller master controller for the testbed
- *                   (must not be destroyed until after the
- *                    testbed is destroyed).
- * @param num_hosts number of hosts in 'hosts', 0 to only
- *        use 'localhost'
- * @param hosts list of hosts to use for the testbed
- * @param num_peers number of peers to start
- * @param cfg the configuration to use as a template for peers and also for
- *         checking the value of testbed helper binary
- * @param underlay_topology underlay topology to create
- * @param va topology-specific options
- * @return handle to the testbed; NULL upon error (error messaage will be printed)
- */
-struct GNUNET_TESTBED_Testbed *
-GNUNET_TESTBED_create_va (struct GNUNET_TESTBED_Controller *controller,
-                          unsigned int num_hosts,
-                          struct GNUNET_TESTBED_Host **hosts,
-                          unsigned int num_peers,
-                          const struct GNUNET_CONFIGURATION_Handle *cfg,
-                          enum GNUNET_TESTBED_TopologyOption underlay_topology,
-                          va_list va)
-{
-  /* unsigned int nhost; */
-
-  /* GNUNET_assert (underlay_topology < GNUNET_TESTBED_TOPOLOGY_NONE); */
-  /* if (num_hosts != 0) */
-  /* { */
-  /*   for (nhost = 0; nhost < num_hosts; nhost++) */
-  /*   { */
-  /*     if (GNUNET_YES != GNUNET_TESTBED_is_host_habitable (hosts[nhost], cfg)) */
-  /*     { */
-  /*       LOG (GNUNET_ERROR_TYPE_ERROR, _("Host %s cannot start testbed\n"), */
-  /*            GNUNET_TESTBED_host_get_hostname_ (hosts[nhost])); */
-  /*       break; */
-  /*     } */
-  /*   } */
-  /*   if (num_hosts != nhost) */
-  /*     return NULL; */
-  /* } */
-  /* We need controller callback here to get operation done events while
-     linking hosts */
-  GNUNET_break (0);
-  return NULL;
-}
-
-
-/**
- * Configure and run a testbed using the given
- * master controller on 'num_hosts' starting
- * 'num_peers' using the given peer configuration.
- *
- * @param controller master controller for the testbed
- *                   (must not be destroyed until after the
- *                    testbed is destroyed).
- * @param num_hosts number of hosts in 'hosts', 0 to only
- *        use 'localhost'
- * @param hosts list of hosts to use for the testbed
- * @param num_peers number of peers to start
- * @param cfg the configuration to use as a template for peers and also for
- *         checking the value of testbed helper binary
- * @param underlay_topology underlay topology to create
- * @param ... topology-specific options
- */
-struct GNUNET_TESTBED_Testbed *
-GNUNET_TESTBED_create (struct GNUNET_TESTBED_Controller *controller,
-                       unsigned int num_hosts,
-                       struct GNUNET_TESTBED_Host **hosts,
-                       unsigned int num_peers,
-                       const struct GNUNET_CONFIGURATION_Handle *cfg,
-                       enum GNUNET_TESTBED_TopologyOption underlay_topology,
-                       ...)
-{
-  struct GNUNET_TESTBED_Testbed *testbed;
-  va_list vargs;
-  
-  va_start (vargs, underlay_topology);
-  testbed = GNUNET_TESTBED_create_va (controller, num_hosts, hosts, num_peers,
-                                      cfg, underlay_topology, vargs);
-  va_end (vargs);
-  return testbed;
-}
-
-
-/**
- * Destroy a testbed.  Stops all running peers and then
- * destroys all peers.  Does NOT destroy the master controller.
- *
- * @param testbed testbed to destroy
- */
-void
-GNUNET_TESTBED_destroy (struct GNUNET_TESTBED_Testbed *testbed)
-{
-  GNUNET_break (0);
-}
-
-
 /* end of testbed_api_testbed.c */