1 files changed, 489 insertions, 502 deletions

diff --git a/src/transport/test_transport_ats_multiple_peers.c b/src/transport/test_transport_ats_multiple_peers.c
index 9d30a061d..d060a4d4b 100644
--- a/src/transport/test_transport_ats_multiple_peers.c
+++ b/src/transport/test_transport_ats_multiple_peers.c
@@ -46,17 +46,17 @@ static int peers_left;
 static int failed_peers;
 
 static int measurement_started = GNUNET_NO;
-static char * config_file;
+static char *config_file;
 
 static struct GNUNET_TESTING_PeerGroup *pg;
 
 static GNUNET_SCHEDULER_TaskIdentifier shutdown_task;
 static GNUNET_SCHEDULER_TaskIdentifier stats_task;
 static GNUNET_SCHEDULER_TaskIdentifier send_task;
-struct GNUNET_TESTING_Daemon * master_deamon;
-struct GNUNET_TESTING_Daemon * ping_deamon;
+struct GNUNET_TESTING_Daemon *master_deamon;
+struct GNUNET_TESTING_Daemon *ping_deamon;
 
-struct GNUNET_STATISTICS_Handle * stats;
+struct GNUNET_STATISTICS_Handle *stats;
 
 struct TEST_result
 {
@@ -87,21 +87,21 @@ static int force_rebuild;
 static int send_msg;
 static int machine_parsable;
 
-static struct TEST_result results_new       [MEASUREMENTS+1];
-static struct TEST_result results_modified  [MEASUREMENTS+1];
-static struct TEST_result results_unmodified[MEASUREMENTS+1];
+static struct TEST_result results_new[MEASUREMENTS + 1];
+static struct TEST_result results_modified[MEASUREMENTS + 1];
+static struct TEST_result results_unmodified[MEASUREMENTS + 1];
 static struct TEST_result current;
 
-static struct GNUNET_STATISTICS_GetHandle * s_solution;
-static struct GNUNET_STATISTICS_GetHandle * s_time;
-static struct GNUNET_STATISTICS_GetHandle * s_peers;
-static struct GNUNET_STATISTICS_GetHandle * s_mechs;
-static struct GNUNET_STATISTICS_GetHandle * s_duration;
-static struct GNUNET_STATISTICS_GetHandle * s_invalid;
-static struct GNUNET_STATISTICS_GetHandle * s_state;
+static struct GNUNET_STATISTICS_GetHandle *s_solution;
+static struct GNUNET_STATISTICS_GetHandle *s_time;
+static struct GNUNET_STATISTICS_GetHandle *s_peers;
+static struct GNUNET_STATISTICS_GetHandle *s_mechs;
+static struct GNUNET_STATISTICS_GetHandle *s_duration;
+static struct GNUNET_STATISTICS_GetHandle *s_invalid;
+static struct GNUNET_STATISTICS_GetHandle *s_state;
 
-struct GNUNET_TRANSPORT_TransmitHandle * t;
-struct GNUNET_TRANSPORT_Handle * th;
+struct GNUNET_TRANSPORT_TransmitHandle *t;
+struct GNUNET_TRANSPORT_Handle *th;
 
 /**
  * Check whether peers successfully shut down.
@@ -110,463 +110,459 @@ static void
 shutdown_callback (void *cls, const char *emsg)
 {
   if (emsg != NULL)
-    {
+  {
 #if VERBOSE
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, 
-                  "Shutdown of peers failed!\n");
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Shutdown of peers failed!\n");
 #endif
-      if (ok == 0)
-        ok = 666;
-    }
+    if (ok == 0)
+      ok = 666;
+  }
   else
-    {
+  {
 #if VERBOSE
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "All peers successfully shut down!\n");
-        if (stats != NULL)
-                GNUNET_STATISTICS_destroy(stats, GNUNET_NO);
-        stats = NULL;
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "All peers successfully shut down!\n");
+    if (stats != NULL)
+      GNUNET_STATISTICS_destroy (stats, GNUNET_NO);
+    stats = NULL;
 #endif
-    }
+  }
 }
 
 static void
-shutdown_peers()
+shutdown_peers ()
 {
   if (shutdown_task != GNUNET_SCHEDULER_NO_TASK)
-    {
-      GNUNET_SCHEDULER_cancel(shutdown_task);
-      shutdown_task = GNUNET_SCHEDULER_NO_TASK;
-    }
+  {
+    GNUNET_SCHEDULER_cancel (shutdown_task);
+    shutdown_task = GNUNET_SCHEDULER_NO_TASK;
+  }
   if (stats_task != GNUNET_SCHEDULER_NO_TASK)
-    {
-      GNUNET_SCHEDULER_cancel(stats_task);
-      stats_task = GNUNET_SCHEDULER_NO_TASK;
-    }
+  {
+    GNUNET_SCHEDULER_cancel (stats_task);
+    stats_task = GNUNET_SCHEDULER_NO_TASK;
+  }
   if (send_task != GNUNET_SCHEDULER_NO_TASK)
-    {
-      GNUNET_SCHEDULER_cancel(send_task);
-      send_task = GNUNET_SCHEDULER_NO_TASK;
-    }
-  
+  {
+    GNUNET_SCHEDULER_cancel (send_task);
+    send_task = GNUNET_SCHEDULER_NO_TASK;
+  }
+
   if (t != NULL)
-    {
-      GNUNET_TRANSPORT_notify_transmit_ready_cancel(t);
-      t = NULL;
-    }
-  GNUNET_TRANSPORT_disconnect(th);  
+  {
+    GNUNET_TRANSPORT_notify_transmit_ready_cancel (t);
+    t = NULL;
+  }
+  GNUNET_TRANSPORT_disconnect (th);
   if (s_time != NULL)
-    {
-      GNUNET_STATISTICS_get_cancel(s_time);
-      s_time = NULL;
-    }
+  {
+    GNUNET_STATISTICS_get_cancel (s_time);
+    s_time = NULL;
+  }
   if (s_peers != NULL)
-    {
-      GNUNET_STATISTICS_get_cancel(s_peers);
-      s_peers = NULL;
-    }
+  {
+    GNUNET_STATISTICS_get_cancel (s_peers);
+    s_peers = NULL;
+  }
   if (s_mechs != NULL)
-    {
-      GNUNET_STATISTICS_get_cancel(s_mechs);
-      s_mechs = NULL;
-    }
+  {
+    GNUNET_STATISTICS_get_cancel (s_mechs);
+    s_mechs = NULL;
+  }
   if (s_solution != NULL)
-    {
-      GNUNET_STATISTICS_get_cancel(s_solution);
-      s_solution = NULL;
-    }
+  {
+    GNUNET_STATISTICS_get_cancel (s_solution);
+    s_solution = NULL;
+  }
   if (s_duration != NULL)
-    {
-      GNUNET_STATISTICS_get_cancel(s_duration);
-      s_duration = NULL;
-    }
+  {
+    GNUNET_STATISTICS_get_cancel (s_duration);
+    s_duration = NULL;
+  }
   if (s_invalid != NULL)
-    {
-      GNUNET_STATISTICS_get_cancel(s_invalid);
-      s_invalid = NULL;
-    }
+  {
+    GNUNET_STATISTICS_get_cancel (s_invalid);
+    s_invalid = NULL;
+  }
   if (s_state != NULL)
-    {
-      GNUNET_STATISTICS_get_cancel(s_state);
-      s_state = NULL;
-    }
+  {
+    GNUNET_STATISTICS_get_cancel (s_state);
+    s_state = NULL;
+  }
   GNUNET_TESTING_daemons_stop (pg, TIMEOUT, &shutdown_callback, NULL);
 }
 
-static void 
-evaluate_measurements()
+static void
+evaluate_measurements ()
 {
   int c;
+
   //int mechs = 0;
   double average[3];
   double stddev[3];
+
   //char * output;
   c = 1;
-  
+
   //GNUNET_asprintf(&output, "p,%i,m,%i,",peers, MEASUREMENTS, results_modified[0].mechs,
-  
+
   average[0] = 0.0;
-  for (c=0; c<c_new;c++)
-    {
-      average[0] += (double) results_new[c].duration;
-    }
+  for (c = 0; c < c_new; c++)
+  {
+    average[0] += (double) results_new[c].duration;
+  }
   average[0] /= c_new;
-  
+
   stddev[0] = 0.0;
-  for (c=0; c<c_new;c++)
-    {
-      stddev[0] += (results_new[c].duration - average[0]) *
-          (results_new[c].duration - average[0]);
-    }
+  for (c = 0; c < c_new; c++)
+  {
+    stddev[0] += (results_new[c].duration - average[0]) *
+        (results_new[c].duration - average[0]);
+  }
   stddev[0] /= c_new;
   stddev[0] = sqrt (stddev[0]);
   if (!machine_parsable)
     fprintf (stderr,
-             "new, %i measurements, average: %f stddev: %f\n",
-             c_new, average[0], stddev[0]);
-  
+             "new, %i measurements, average: %f stddev: %f\n",
+             c_new, average[0], stddev[0]);
+
   average[1] = 0.0;
-  for (c=0; c<c_modified;c++)
-    {
-      average[1] += (double) results_modified[c].duration;
-    }
+  for (c = 0; c < c_modified; c++)
+  {
+    average[1] += (double) results_modified[c].duration;
+  }
   average[1] /= c_modified;
-  
+
   stddev[1] = 0.0;
-  for (c=0; c<c_modified;c++)
-    {
-      stddev[1] += (results_modified[c].duration - average[1]) *
-          (results_modified[c].duration - average[1]);
-    }
+  for (c = 0; c < c_modified; c++)
+  {
+    stddev[1] += (results_modified[c].duration - average[1]) *
+        (results_modified[c].duration - average[1]);
+  }
   stddev[1] /= c_modified;
   stddev[1] = sqrt (stddev[1]);
-  if (!machine_parsable) 
+  if (!machine_parsable)
     fprintf (stderr,
-             "modified, %i measurements, average: %f stddev: %f\n",
-             c_modified, average[1], stddev[1]);
-  
+             "modified, %i measurements, average: %f stddev: %f\n",
+             c_modified, average[1], stddev[1]);
+
   average[2] = 0.0;
-  for (c=0; c<c_unmodified;c++)
-    {
-      average[2] += (double) results_unmodified[c].duration;
-    }
+  for (c = 0; c < c_unmodified; c++)
+  {
+    average[2] += (double) results_unmodified[c].duration;
+  }
   average[2] /= c_unmodified;
   stddev[2] = 0.0;
-  for (c=0; c<c_unmodified;c++)
-    {
-      stddev[2] += (results_unmodified[c].duration - average[2]) *
-          (results_unmodified[c].duration - average[2]);
-    }
+  for (c = 0; c < c_unmodified; c++)
+  {
+    stddev[2] += (results_unmodified[c].duration - average[2]) *
+        (results_unmodified[c].duration - average[2]);
+  }
   stddev[2] /= c_unmodified;
   stddev[2] = sqrt (stddev[2]);
-  
-  if (!machine_parsable) 
+
+  if (!machine_parsable)
     fprintf (stderr,
-             "unmodified, %i measurements, average: %f stddev: %f\n",
-             c_unmodified, average[2], stddev[2]);
-  
+             "unmodified, %i measurements, average: %f stddev: %f\n",
+             c_unmodified, average[2], stddev[2]);
+
   if (machine_parsable)
     fprintf (stderr,
-             "peers,%i,mechs,%llu,"
-             "new,%i,%f,%f,"
-             "mod,%i,%f,%f,"
-             "unmod,%i,%f,%f\n",
-             peers-1, (unsigned long long) results_unmodified[0].mechs,
-             c_new, average[0], stddev[0],
-             c_modified, average[1], stddev[1],
-             c_unmodified, average[2], stddev[2]);
-  shutdown_peers();
+             "peers,%i,mechs,%llu,"
+             "new,%i,%f,%f,"
+             "mod,%i,%f,%f,"
+             "unmod,%i,%f,%f\n",
+             peers - 1, (unsigned long long) results_unmodified[0].mechs,
+             c_new, average[0], stddev[0],
+             c_modified, average[1], stddev[1],
+             c_unmodified, average[2], stddev[2]);
+  shutdown_peers ();
 }
 
 
-static int 
+static int
 stats_cb (void *cls,
-          const char *subsystem,
-          const char *name,
-          uint64_t value,
-          int is_persistent)
+          const char *subsystem,
+          const char *name, uint64_t value, int is_persistent)
 {
   static int printed = GNUNET_NO;
+
 #if VERBOSE_ATS
-  GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "%s = %llu\n", name ,value);
+  GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "%s = %llu\n", name, value);
 #endif
-  if (0 == strcmp (name,"ATS invalid solutions"))
-    {
-      if (stats_task != GNUNET_SCHEDULER_NO_TASK)
-        {
-          GNUNET_SCHEDULER_cancel(stats_task);
-          stats_task = GNUNET_SCHEDULER_NO_TASK;
-        }
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,"MLP produced invalid %llu result(s)!\n",
-          value);
-      shutdown_peers();
-      return GNUNET_SYSERR;
-    }
-  
-  if (0 == strcmp (name,"ATS solution"))
+  if (0 == strcmp (name, "ATS invalid solutions"))
+  {
+    if (stats_task != GNUNET_SCHEDULER_NO_TASK)
     {
-      s_solution = NULL;
-    }
-  
-  if (0 == strcmp (name,"ATS peers"))
-    {
-      s_peers = NULL;
+      GNUNET_SCHEDULER_cancel (stats_task);
+      stats_task = GNUNET_SCHEDULER_NO_TASK;
     }
-  
-  if (0 == strcmp (name,"ATS mechanisms"))
-    {
-      s_mechs = NULL;
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "MLP produced invalid %llu result(s)!\n", value);
+    shutdown_peers ();
+    return GNUNET_SYSERR;
+  }
+
+  if (0 == strcmp (name, "ATS solution"))
+  {
+    s_solution = NULL;
+  }
+
+  if (0 == strcmp (name, "ATS peers"))
+  {
+    s_peers = NULL;
+  }
+
+  if (0 == strcmp (name, "ATS mechanisms"))
+  {
+    s_mechs = NULL;
+  }
+
+  if (0 == strcmp (name, "ATS duration"))
+  {
+    s_duration = NULL;
+  }
+  if (0 == strcmp (name, "ATS timestamp"))
+  {
+    s_time = NULL;
+  }
+  if (0 == strcmp (name, "ATS state"))
+  {
+    s_state = NULL;
+  }
+
+  if ((measurement_started == GNUNET_NO) &&
+      (0 == strcmp (name, "ATS peers")) && (value == peers - 1))
+  {
+    measurement_started = GNUNET_YES;
+    count = 1;
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "All %llu peers connected\n", value);
+#if !VERBOSE
+    if (!machine_parsable)
+      fprintf (stderr, "%i", count);
+#endif
+  }
+
+  if (measurement_started == GNUNET_YES)
+  {
+    // GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "%s == %llu\n", name ,value);
+    if (0 == strcmp (name, "ATS timestamp"))
+    {
+      if (current.timestamp == 0)
+      {
+        printed = GNUNET_NO;
+        current.timestamp = value;
+      }
+      if (current.timestamp == value)
+      {
+        printed = GNUNET_YES;
+      }
+      if (current.timestamp != value)
+      {
+        if (current.state == ATS_NEW)
+        {
+          if (c_new < MEASUREMENTS)
+          {
+            results_new[c_new] = current;
+            c_new++;
+          }
+          else
+          {
+            force_rebuild = GNUNET_NO;
+            force_q_updates = GNUNET_NO;
+            send_msg = GNUNET_NO;
+          }
+        }
+        if (current.state == ATS_UNMODIFIED)
+        {
+          if (c_unmodified < MEASUREMENTS)
+          {
+            results_unmodified[c_unmodified] = current;
+            c_unmodified++;
+          }
+
+        }
+        if (current.state == ATS_QUALITY_UPDATED)
+        {
+          if (c_modified < MEASUREMENTS)
+          {
+            results_modified[c_modified] = current;
+            c_modified++;
+          }
+          else
+          {
+            force_q_updates = GNUNET_NO;
+            force_rebuild = GNUNET_YES;
+          }
+        }
+        count++;
+#if VERBOSE
+        fprintf (stderr,
+                 "(new: %i / modified: %i / unmodified: %i) of %i \n",
+                 c_new, c_modified, c_unmodified, MEASUREMENTS);
+#endif
+        if ((c_modified >= MEASUREMENTS) &&
+            (c_new >= MEASUREMENTS) && (c_unmodified >= MEASUREMENTS))
+        {
+#if !VERBOSE
+          if (!machine_parsable)
+            fprintf (stdout, "\n");
+#endif
+          if (stats_task != GNUNET_SCHEDULER_NO_TASK)
+          {
+            GNUNET_SCHEDULER_cancel (stats_task);
+            stats_task = GNUNET_SCHEDULER_NO_TASK;
+          }
+          evaluate_measurements ();
+          return GNUNET_SYSERR;
+        }
+
+        printed = GNUNET_NO;
+        current.timestamp = value;
+#if !VERBOSE
+        if (!machine_parsable)
+          fprintf (stderr, "..%i", count);
+#endif
+        return GNUNET_OK;
+      }
     }
-  
-  if (0 == strcmp (name,"ATS duration"))
+
+    if (0 == strcmp (name, "ATS solution"))
     {
-      s_duration = NULL;
+      current.solution = value;
+      if (printed == GNUNET_NO)
+        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "[%i] %s: %llu \n",
+                    count, name, value);
     }
-  if (0 == strcmp (name,"ATS timestamp"))
+
+    if (0 == strcmp (name, "ATS peers"))
     {
-      s_time = NULL;
+      current.peers = value;
+      if (printed == GNUNET_NO)
+        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "[%i] %s: %llu \n",
+                    count, name, value);
     }
-  if (0 == strcmp (name,"ATS state"))
+
+    if (0 == strcmp (name, "ATS mechanisms"))
     {
-      s_state = NULL;
+      current.mechs = value;
+      if (printed == GNUNET_NO)
+        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "[%i] %s: %llu \n",
+                    count, name, value);
     }
-  
-  if ( (measurement_started == GNUNET_NO) && 
-       (0 == strcmp (name, "ATS peers")) && 
-       (value == peers-1) )
+
+    if (0 == strcmp (name, "ATS duration"))
     {
-      measurement_started = GNUNET_YES;
-      count = 1;
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, 
-                  "All %llu peers connected\n", 
-                  value);
-#if !VERBOSE
-      if (! machine_parsable)   
-        fprintf(stderr, "%i", count);
-#endif
+      current.duration = value;
+      if (printed == GNUNET_NO)
+        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "[%i] %s: %llu \n",
+                    count, name, value);
     }
-  
-  if (measurement_started == GNUNET_YES)
+    if (0 == strcmp (name, "ATS state"))
     {
-      // GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "%s == %llu\n", name ,value);
-      if (0 == strcmp (name,"ATS timestamp"))
-        {
-          if (current.timestamp == 0)
-            {
-              printed = GNUNET_NO;
-              current.timestamp = value;
-            }
-          if (current.timestamp == value)
-            {
-              printed = GNUNET_YES;
-            }
-          if (current.timestamp != value)
-            {
-              if (current.state == ATS_NEW)
-                {
-                  if (c_new < MEASUREMENTS)
-                    {
-                      results_new[c_new] = current;
-                      c_new++;
-                    }
-                  else
-                    {
-                      force_rebuild = GNUNET_NO;
-                      force_q_updates = GNUNET_NO;
-                      send_msg = GNUNET_NO;
-                    }
-                }
-              if (current.state == ATS_UNMODIFIED)
-                {
-                  if (c_unmodified < MEASUREMENTS)
-                    {
-                      results_unmodified[c_unmodified] = current;
-                      c_unmodified++;
-                    }
-                  
-                }
-              if (current.state == ATS_QUALITY_UPDATED)
-                {
-                  if (c_modified < MEASUREMENTS)
-                    {
-                      results_modified[c_modified] = current;
-                      c_modified++;
-                    }
-                  else
-                    {
-                      force_q_updates = GNUNET_NO;
-                      force_rebuild = GNUNET_YES;
-                    }
-                }
-              count ++;
-#if VERBOSE
-              fprintf (stderr,
-                       "(new: %i / modified: %i / unmodified: %i) of %i \n", 
-                       c_new, c_modified, c_unmodified , MEASUREMENTS);
-#endif
-              if ((c_modified >= MEASUREMENTS) &&
-                  (c_new >= MEASUREMENTS) &&
-                  (c_unmodified >= MEASUREMENTS))
-                {
-#if !VERBOSE
-                  if (!machine_parsable)
-                    fprintf(stdout, "\n");
-#endif
-                  if (stats_task != GNUNET_SCHEDULER_NO_TASK)
-                    {
-                      GNUNET_SCHEDULER_cancel(stats_task);
-                      stats_task = GNUNET_SCHEDULER_NO_TASK;
-                    }
-                  evaluate_measurements();
-                  return GNUNET_SYSERR;
-                }
-              
-              printed = GNUNET_NO;
-              current.timestamp = value;
-#if !VERBOSE
-              if (! machine_parsable)
-                fprintf(stderr, "..%i", count);
-#endif
-              return GNUNET_OK;
-            }
-        }
-      
-      if (0 == strcmp (name,"ATS solution"))
-        {
-          current.solution = value;
-          if (printed == GNUNET_NO)
-            GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "[%i] %s: %llu \n",
-                count, name, value);
-        }
-      
-      if (0 == strcmp (name,"ATS peers"))
-        {
-          current.peers = value;
-          if (printed == GNUNET_NO)
-            GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "[%i] %s: %llu \n",
-                count, name, value);
-        }
-      
-      if (0 == strcmp (name,"ATS mechanisms"))
-        {
-          current.mechs = value;
-          if (printed == GNUNET_NO) 
-            GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "[%i] %s: %llu \n",
-                count, name, value);
-        }
-      
-      if (0 == strcmp (name,"ATS duration"))
-        {
-          current.duration = value;
-          if (printed == GNUNET_NO) 
-            GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "[%i] %s: %llu \n",
-                count, name, value);
-        }
-      if (0 == strcmp (name,"ATS state"))
-        {
-          current.state = value;
-          const char * cont;
-          switch (value)
-            {
-            case ATS_NEW:
-              cont = "NEW";
-              break;
-            case ATS_COST_UPDATED:
-              cont = "C_UPDATED";
-              break;
-            case ATS_QUALITY_UPDATED:
-              cont = "Q_UPDATED";
-              break;
-            case ATS_QUALITY_COST_UPDATED:
-              cont = "QC_UPDATED";
-              break;
-            case ATS_UNMODIFIED:
-              cont = "UNMODIFIED";
-              break;
-            default:
-              GNUNET_break (0);
-              cont = "<undefined>";
-              break;
-            }
-          if (printed == GNUNET_NO) 
-            GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, 
-                        "[%i] ATS state: %s\n", 
-                        count, 
-                        cont);
-        }
+      current.state = value;
+      const char *cont;
+
+      switch (value)
+      {
+      case ATS_NEW:
+        cont = "NEW";
+        break;
+      case ATS_COST_UPDATED:
+        cont = "C_UPDATED";
+        break;
+      case ATS_QUALITY_UPDATED:
+        cont = "Q_UPDATED";
+        break;
+      case ATS_QUALITY_COST_UPDATED:
+        cont = "QC_UPDATED";
+        break;
+      case ATS_UNMODIFIED:
+        cont = "UNMODIFIED";
+        break;
+      default:
+        GNUNET_break (0);
+        cont = "<undefined>";
+        break;
+      }
+      if (printed == GNUNET_NO)
+        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                    "[%i] ATS state: %s\n", count, cont);
     }
+  }
   return GNUNET_OK;
 }
 
 
 static void
-stats_get_task (void *cls,
-                const struct GNUNET_SCHEDULER_TaskContext *tc)
+stats_get_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   stats_task = GNUNET_SCHEDULER_NO_TASK;
-  if ( (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN) != 0)
+  if ((tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN) != 0)
     return;
-  
+
   s_time = GNUNET_STATISTICS_get (stats, "transport", "ATS timestamp",
-      TIMEOUT, NULL, &stats_cb, NULL);
+                                  TIMEOUT, NULL, &stats_cb, NULL);
   s_solution = GNUNET_STATISTICS_get (stats, "transport", "ATS solution",
-      TIMEOUT, NULL, &stats_cb, NULL);
-  s_duration = GNUNET_STATISTICS_get (stats, "transport","ATS duration",
-      TIMEOUT, NULL, &stats_cb, NULL);
+                                      TIMEOUT, NULL, &stats_cb, NULL);
+  s_duration = GNUNET_STATISTICS_get (stats, "transport", "ATS duration",
+                                      TIMEOUT, NULL, &stats_cb, NULL);
   s_peers = GNUNET_STATISTICS_get (stats, "transport", "ATS peers",
-      TIMEOUT, NULL, &stats_cb, NULL);
+                                   TIMEOUT, NULL, &stats_cb, NULL);
   s_mechs = GNUNET_STATISTICS_get (stats, "transport", "ATS mechanisms",
-      TIMEOUT, NULL, &stats_cb, NULL);
-  s_invalid = GNUNET_STATISTICS_get (stats, "transport", "ATS invalid solutions",
-      TIMEOUT, NULL, &stats_cb, NULL);
-  s_state = GNUNET_STATISTICS_get (stats, "transport", "ATS state",
-      TIMEOUT, NULL, &stats_cb, NULL);
-  
-  stats_task = GNUNET_SCHEDULER_add_delayed(
-      GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MILLISECONDS, 100),
-      &stats_get_task,
-      NULL);
+                                   TIMEOUT, NULL, &stats_cb, NULL);
+  s_invalid =
+      GNUNET_STATISTICS_get (stats, "transport", "ATS invalid solutions",
+                             TIMEOUT, NULL, &stats_cb, NULL);
+  s_state =
+      GNUNET_STATISTICS_get (stats, "transport", "ATS state", TIMEOUT, NULL,
+                             &stats_cb, NULL);
+
+  stats_task =
+      GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply
+                                    (GNUNET_TIME_UNIT_MILLISECONDS, 100),
+                                    &stats_get_task, NULL);
 }
 
 
 static void
-delay (void *cls,
-       const struct GNUNET_SCHEDULER_TaskContext *tc)
+delay (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   shutdown_task = GNUNET_SCHEDULER_NO_TASK;
-  if ( (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN) != 0)
+  if ((tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN) != 0)
     return;
 #if VERBOSE
-  GNUNET_log (GNUNET_ERROR_TYPE_ERROR, 
-              "Delay over\n");
+  GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Delay over\n");
 #endif
   shutdown_peers ();
 }
 
 static void
-connect_peers()
+connect_peers ()
 {
-  shutdown_task = GNUNET_SCHEDULER_add_delayed(DELAY, &delay, NULL);
+  shutdown_task = GNUNET_SCHEDULER_add_delayed (DELAY, &delay, NULL);
 }
 
 
 /* To make compiler happy */
-void dummy(void)
+void
+dummy (void)
 {
-  struct ATS_quality_metric * q = qm;
+  struct ATS_quality_metric *q = qm;
+
   q = NULL;
   q++;
-  struct ATS_ressource * r = ressources;
+  struct ATS_ressource *r = ressources;
+
   r = NULL;
   r++;
 }
 
-static size_t 
+static size_t
 send_dummy_data_task (void *cls, size_t size, void *buf)
 {
   int s = sizeof (struct TestMessage);
   struct TestMessage hdr;
-  
+
   hdr.header.size = htons (s);
   hdr.header.type = htons (GNUNET_MESSAGE_TYPE_TRANSPORT_ATS);
   if (force_rebuild)
@@ -574,7 +570,7 @@ send_dummy_data_task (void *cls, size_t size, void *buf)
   else if (force_q_updates)
     hdr.num = htonl (2);
   else
-    hdr.num = htonl (0); 
+    hdr.num = htonl (0);
   memcpy (buf, &hdr, s);
   // GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Sent bytes: %i of %i\n", s, s);
   t = NULL;
@@ -582,30 +578,29 @@ send_dummy_data_task (void *cls, size_t size, void *buf)
 }
 
 
-static void 
-send_task_f (void *cls,
-             const struct GNUNET_SCHEDULER_TaskContext *tc)
+static void
+send_task_f (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   send_task = GNUNET_SCHEDULER_NO_TASK;
-  if ( (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN) != 0)
+  if ((tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN) != 0)
     return;
-  
-  if (t!=NULL)
-    {
-      GNUNET_TRANSPORT_notify_transmit_ready_cancel(t);
-      t = NULL;
-    }
+
+  if (t != NULL)
+  {
+    GNUNET_TRANSPORT_notify_transmit_ready_cancel (t);
+    t = NULL;
+  }
 
   if (send_msg == GNUNET_YES)
-    t = GNUNET_TRANSPORT_notify_transmit_ready(th, 
-                                               &master_deamon->id, 
-                                               sizeof (struct TestMessage), 0, 
-                                               SEND_TIMEOUT, 
-                                               &send_dummy_data_task, NULL);
-  send_task = GNUNET_SCHEDULER_add_delayed(
-      GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MILLISECONDS,1000),
-      &send_task_f,
-      NULL);
+    t = GNUNET_TRANSPORT_notify_transmit_ready (th,
+                                                &master_deamon->id,
+                                                sizeof (struct TestMessage), 0,
+                                                SEND_TIMEOUT,
+                                                &send_dummy_data_task, NULL);
+  send_task =
+      GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply
+                                    (GNUNET_TIME_UNIT_MILLISECONDS, 1000),
+                                    &send_task_f, NULL);
 
 }
 
@@ -615,135 +610,127 @@ notify_connect (void *cls,
                 const struct GNUNET_TRANSPORT_ATS_Information *ats,
                 uint32_t ats_count)
 {
-  send_task = GNUNET_SCHEDULER_add_now(&send_task_f, NULL);
+  send_task = GNUNET_SCHEDULER_add_now (&send_task_f, NULL);
 }
 
 static void
-notify_disconnect (void *cls,
-                   const struct GNUNET_PeerIdentity *peer)
+notify_disconnect (void *cls, const struct GNUNET_PeerIdentity *peer)
 {
   if (GNUNET_SCHEDULER_NO_TASK != send_task)
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Disconnect event before transmission request could be scheduled!\n");
-      GNUNET_SCHEDULER_cancel (send_task);
-      send_task = GNUNET_SCHEDULER_NO_TASK;
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Disconnect event before transmission request could be scheduled!\n");
+    GNUNET_SCHEDULER_cancel (send_task);
+    send_task = GNUNET_SCHEDULER_NO_TASK;
+  }
   if (NULL != t)
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Disconnect event before transmission request could be completed!\n");
-      GNUNET_TRANSPORT_notify_transmit_ready_cancel (t);
-      t = NULL;
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Disconnect event before transmission request could be completed!\n");
+    GNUNET_TRANSPORT_notify_transmit_ready_cancel (t);
+    t = NULL;
+  }
 }
 
-static void 
-daemon_connect_cb(void *cls,
-                  const struct GNUNET_PeerIdentity *first,
-                  const struct GNUNET_PeerIdentity *second,
-                  uint32_t distance,
-                  const struct GNUNET_CONFIGURATION_Handle *first_cfg,
-                  const struct GNUNET_CONFIGURATION_Handle *second_cfg,
-                  struct GNUNET_TESTING_Daemon *first_daemon,
-                  struct GNUNET_TESTING_Daemon *second_daemon,
-                  const char *emsg)
+static void
+daemon_connect_cb (void *cls,
+                   const struct GNUNET_PeerIdentity *first,
+                   const struct GNUNET_PeerIdentity *second,
+                   uint32_t distance,
+                   const struct GNUNET_CONFIGURATION_Handle *first_cfg,
+                   const struct GNUNET_CONFIGURATION_Handle *second_cfg,
+                   struct GNUNET_TESTING_Daemon *first_daemon,
+                   struct GNUNET_TESTING_Daemon *second_daemon,
+                   const char *emsg)
 {
-  char * firstc =  strdup(GNUNET_i2s(first));
-  char * secondc =  strdup(GNUNET_i2s(second));
+  char *firstc = strdup (GNUNET_i2s (first));
+  char *secondc = strdup (GNUNET_i2s (second));
+
   connected++;
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Connected peers `%s'<->`%s' (%i/%i)\n", 
-              firstc, secondc, connected, peers-1);
-  GNUNET_free(firstc);
-  GNUNET_free(secondc);
-  
-  if ( ( (first_daemon == ping_deamon) || 
-         (second_daemon == ping_deamon) ) && 
-       (master_deamon != NULL) && 
-       (ping_deamon != NULL) )
-    {
-      th = GNUNET_TRANSPORT_connect (ping_deamon->cfg,
-                                     &ping_deamon->id, 
-                                     NULL, NULL,
-                                     &notify_connect, 
-                                     &notify_disconnect);
-      force_q_updates = GNUNET_YES;
-      send_msg = GNUNET_YES;
-    }
+              "Connected peers `%s'<->`%s' (%i/%i)\n",
+              firstc, secondc, connected, peers - 1);
+  GNUNET_free (firstc);
+  GNUNET_free (secondc);
+
+  if (((first_daemon == ping_deamon) ||
+       (second_daemon == ping_deamon)) &&
+      (master_deamon != NULL) && (ping_deamon != NULL))
+  {
+    th = GNUNET_TRANSPORT_connect (ping_deamon->cfg,
+                                   &ping_deamon->id,
+                                   NULL, NULL,
+                                   &notify_connect, &notify_disconnect);
+    force_q_updates = GNUNET_YES;
+    send_msg = GNUNET_YES;
+  }
 }
 
 
 
 static void
 daemon_start_cb (void *cls,
-                 const struct GNUNET_PeerIdentity *id,
-                 const struct GNUNET_CONFIGURATION_Handle *cfg,
-                 struct GNUNET_TESTING_Daemon *d, const char *emsg)
+                 const struct GNUNET_PeerIdentity *id,
+                 const struct GNUNET_CONFIGURATION_Handle *cfg,
+                 struct GNUNET_TESTING_Daemon *d, const char *emsg)
 {
   if (id == NULL)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Start callback called with error (too long starting peers), aborting test!\n");
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Error from testing: `%s'\n");
+    failed_peers++;
+    if (failed_peers == peers_left)
     {
       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Start callback called with error (too long starting peers), aborting test!\n");
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Error from testing: `%s'\n");
-      failed_peers++;
-      if (failed_peers == peers_left)
-        {
-          GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                      "Too many peers failed, ending test!\n");
-          ok = 1;
-        shutdown_peers ();
-        }
-      return;
+                  "Too many peers failed, ending test!\n");
+      ok = 1;
+      shutdown_peers ();
     }
+    return;
+  }
   peers_left--;
 
   if (master_deamon == NULL)
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, 
-                  "Master peer `%s' '%s'\n",
-                  GNUNET_i2s(id), d->cfgfile);      
-      master_deamon = d;
-      stats = GNUNET_STATISTICS_create("transport", master_deamon->cfg);
-      GNUNET_assert (stats != NULL);
-      stats_task = GNUNET_SCHEDULER_add_now(&stats_get_task, NULL);
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Master peer `%s' '%s'\n", GNUNET_i2s (id), d->cfgfile);
+    master_deamon = d;
+    stats = GNUNET_STATISTICS_create ("transport", master_deamon->cfg);
+    GNUNET_assert (stats != NULL);
+    stats_task = GNUNET_SCHEDULER_add_now (&stats_get_task, NULL);
+  }
   else
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, 
-                  "Connecting peer `%s'\n", 
-                  GNUNET_i2s(id), GNUNET_i2s(&master_deamon->id));
-      GNUNET_TESTING_daemons_connect(d,
-          master_deamon,
-          TIMEOUT,
-          0,
-          GNUNET_YES,
-          &daemon_connect_cb,
-          NULL);
-    }
-  
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Connecting peer `%s'\n",
+                GNUNET_i2s (id), GNUNET_i2s (&master_deamon->id));
+    GNUNET_TESTING_daemons_connect (d,
+                                    master_deamon,
+                                    TIMEOUT,
+                                    0, GNUNET_YES, &daemon_connect_cb, NULL);
+  }
+
   if (peers_left == 0)
+  {
+    if (ping_deamon == NULL)
     {
-      if (ping_deamon == NULL)
-        {
-          ping_deamon = d;
-          GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, 
-                      "Ping peer `%s' '%s'\n", GNUNET_i2s(id), d->cfgfile);
-        }
-      
+      ping_deamon = d;
       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "All peers started successfully!\n");
-      connect_peers();
-      ok = 0;
+                  "Ping peer `%s' '%s'\n", GNUNET_i2s (id), d->cfgfile);
     }
+
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "All peers started successfully!\n");
+    connect_peers ();
+    ok = 0;
+  }
   else if (failed_peers == peers_left)
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Too many peers failed, ending test!\n");
-      shutdown_peers();
-      ok = 1;
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Too many peers failed, ending test!\n");
+    shutdown_peers ();
+    ok = 1;
+  }
 }
 
 
@@ -758,10 +745,9 @@ run (void *cls,
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Starting %i peers.\n", peers);
 #endif
   peers_left = peers;
-  pg = GNUNET_TESTING_daemons_start (cfg,
-                                     peers_left, /* Total number of peers */
-                                     peers_left, /* Number of outstanding connections */
-                                     peers_left, /* Number of parallel ssh connections, or peers being started at once */
+  pg = GNUNET_TESTING_daemons_start (cfg, peers_left,   /* Total number of peers */
+                                     peers_left,        /* Number of outstanding connections */
+                                     peers_left,        /* Number of parallel ssh connections, or peers being started at once */
                                      TIMEOUT,
                                      NULL, NULL,
                                      &daemon_start_cb, NULL, NULL, NULL, NULL);
@@ -808,28 +794,29 @@ main (int argc, char *argv[])
   config_file = "test_transport_ats_4addr.conf";
 
   int c = 0;
+
   if (argc >= 2)
-    {
-      for (c=0; c<argc; c++)
-        {
-          /* set peers */
-          if ((strcmp(argv[c], "-p") == 0) && c < (argc-1))
-            {
-              peers = atoi(argv[c+1]);
-              peers++;
-            }
-          /* set machine parsable */
-          if (strcmp(argv[c], "-m") == 0)
-            {
-              machine_parsable = GNUNET_YES;
-            }
-          /* set config file */
-          if ((strcmp(argv[c], "-c") == 0) && c < (argc-1))
-            {
-              config_file = argv[c+1];
-            }
-         }
-    }
+  {
+    for (c = 0; c < argc; c++)
+    {
+      /* set peers */
+      if ((strcmp (argv[c], "-p") == 0) && c < (argc - 1))
+      {
+        peers = atoi (argv[c + 1]);
+        peers++;
+      }
+      /* set machine parsable */
+      if (strcmp (argv[c], "-m") == 0)
+      {
+        machine_parsable = GNUNET_YES;
+      }
+      /* set config file */
+      if ((strcmp (argv[c], "-c") == 0) && c < (argc - 1))
+      {
+        config_file = argv[c + 1];
+      }
+    }
+  }
 
   ret = check ();
   /**