the big core API/protocol change, breaks all testcases using core, since the code...

[oweals/gnunet.git] / src / dv / test_transport_api_dv.c

diff --git a/src/dv/test_transport_api_dv.c b/src/dv/test_transport_api_dv.c
index e0d956e86fae9a5289ce5beb192aa80d431b9d40..d4c7eef2caa41bcf0dd540f0e7495cd843ff4bc7 100644 (file)
--- a/src/dv/test_transport_api_dv.c
+++ b/src/dv/test_transport_api_dv.c
@@ -4,7 +4,7 @@
 
      GNUnet is free software; you can redistribute it and/or modify
      it under the terms of the GNU General Public License as published
 
      GNUnet is free software; you can redistribute it and/or modify
      it under the terms of the GNU General Public License as published

-     by the Free Software Foundation; either version 2, or (at your
+     by the Free Software Foundation; either version 3, or (at your

      option) any later version.
 
      GNUnet is distributed in the hope that it will be useful, but
      option) any later version.
 
      GNUnet is distributed in the hope that it will be useful, but


@@ -25,7 +25,7 @@
 #include "gnunet_testing_lib.h"
 #include "gnunet_core_service.h"
 
 #include "gnunet_testing_lib.h"
 #include "gnunet_core_service.h"
 

-#define VERBOSE GNUNET_YES
+#define VERBOSE GNUNET_NO

 
 #define TEST_ALL GNUNET_NO
 
 
 #define TEST_ALL GNUNET_NO
 


@@ -41,12 +41,16 @@
 
 #define DEFAULT_NUM_PEERS 4
 
 
 #define DEFAULT_NUM_PEERS 4
 

+#define DEFAULT_ADDITIONAL_MESSAGES 2
+

 #define MAX_OUTSTANDING_CONNECTIONS 100
 
 static float fail_percentage = 0.00;
 
 static int ok;
 
 #define MAX_OUTSTANDING_CONNECTIONS 100
 
 static float fail_percentage = 0.00;
 
 static int ok;
 

+static unsigned long long num_additional_messages;
+

 static unsigned long long num_peers;
 
 static unsigned int total_connections;
 static unsigned long long num_peers;
 
 static unsigned int total_connections;


@@ -71,8 +75,6 @@ static unsigned long long peers_left;
 
 static struct GNUNET_TESTING_PeerGroup *pg;
 
 
 static struct GNUNET_TESTING_PeerGroup *pg;
 

-static struct GNUNET_SCHEDULER_Handle *sched;
-

 const struct GNUNET_CONFIGURATION_Handle *main_cfg;
 
 GNUNET_SCHEDULER_TaskIdentifier die_task;
 const struct GNUNET_CONFIGURATION_Handle *main_cfg;
 
 GNUNET_SCHEDULER_TaskIdentifier die_task;


@@ -162,6 +164,30 @@ static struct TestMessageContext *test_messages;
 
 static struct TestMessageContext *other_test_messages;
 
 
 static struct TestMessageContext *other_test_messages;
 

+/**
+ * Check whether peers successfully shut down.
+ */
+void shutdown_callback (void *cls,
+                        const char *emsg)
+{
+  if (emsg != NULL)
+    {
+#if VERBOSE
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "Shutdown of peers failed!\n");
+#endif
+      if (ok == 0)
+        ok = 666;
+    }
+  else
+    {
+#if VERBOSE
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "All peers successfully shut down!\n");
+#endif
+    }
+}
+

 static void
 finish_testing ()
 {
 static void
 finish_testing ()
 {


@@ -170,7 +196,6 @@ finish_testing ()
   struct PeerContext *free_peer_pos;
   struct TestMessageContext *pos;
   struct TestMessageContext *free_pos;
   struct PeerContext *free_peer_pos;
   struct TestMessageContext *pos;
   struct TestMessageContext *free_pos;

-  int count;

 
 #if VERBOSE
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 
 #if VERBOSE
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,


@@ -187,7 +212,6 @@ finish_testing ()
     }
   all_peers = NULL;
 
     }
   all_peers = NULL;
 

-  count = 0;

   pos = test_messages;
   while (pos != NULL)
     {
   pos = test_messages;
   while (pos != NULL)
     {


@@ -205,7 +229,7 @@ finish_testing ()
       pos = pos->next;
       if (free_pos->disconnect_task != GNUNET_SCHEDULER_NO_TASK)
         {
       pos = pos->next;
       if (free_pos->disconnect_task != GNUNET_SCHEDULER_NO_TASK)
         {

-          GNUNET_SCHEDULER_cancel(sched, free_pos->disconnect_task);
+          GNUNET_SCHEDULER_cancel(free_pos->disconnect_task);

         }
       GNUNET_free(free_pos);
     }
         }
       GNUNET_free(free_pos);
     }


@@ -227,7 +251,7 @@ finish_testing ()
       pos = pos->next;
       if (free_pos->disconnect_task != GNUNET_SCHEDULER_NO_TASK)
         {
       pos = pos->next;
       if (free_pos->disconnect_task != GNUNET_SCHEDULER_NO_TASK)
         {

-          GNUNET_SCHEDULER_cancel(sched, free_pos->disconnect_task);
+          GNUNET_SCHEDULER_cancel(free_pos->disconnect_task);

         }
       GNUNET_free(free_pos);
     }
         }
       GNUNET_free(free_pos);
     }


@@ -240,7 +264,7 @@ finish_testing ()
           GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                       "Calling daemons_stop\n");
 #endif
           GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                       "Calling daemons_stop\n");
 #endif

-  GNUNET_TESTING_daemons_stop (pg, TIMEOUT);
+  GNUNET_TESTING_daemons_stop (pg, TIMEOUT, &shutdown_callback, NULL);

 #if VERBOSE
           GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                       "daemons_stop finished\n");
 #if VERBOSE
           GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                       "daemons_stop finished\n");


@@ -281,61 +305,6 @@ disconnect_cores (void *cls, const struct GNUNET_SCHEDULER_TaskContext * tc)
   total_server_connections -= 2;
 }
 
   total_server_connections -= 2;
 }
 

-static void
-send_other_messages (void *cls, const struct GNUNET_SCHEDULER_TaskContext * tc);
-
-static int
-process_mtype (void *cls,
-               const struct GNUNET_PeerIdentity *peer,
-               const struct GNUNET_MessageHeader *message,
-               struct GNUNET_TIME_Relative latency,
-               uint32_t distance)
-{
-  struct TestMessageContext *pos = cls;
-  struct GNUNET_TestMessage *msg = (struct GNUNET_TestMessage *)message;
-  if (pos->uid != ntohl(msg->uid))
-    return GNUNET_OK;
-
-  GNUNET_assert(0 == memcmp(peer, &pos->peer1->id, sizeof(struct GNUNET_PeerIdentity)));
-  if (total_other_expected_messages == 0)
-    {
-      total_messages_received++;
-#if VERBOSE
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Received message from `%4s', type %d, uid %u, distance %u.\n", GNUNET_i2s (peer), ntohs(message->type), ntohl(msg->uid), distance);
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Total messages received %d, expected %d.\n", total_messages_received, expected_messages);
-#endif
-    }
-  else
-    {
-      total_other_messages++;
-#if VERBOSE
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Received message from `%4s', type %d, uid %u, distance %u.\n", GNUNET_i2s (peer), ntohs(message->type), ntohl(msg->uid), distance);
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Total messages received %d, expected %d.\n", total_other_messages, total_other_expected_messages);
-#endif
-    }
-
-  if ((total_messages_received == expected_messages) && (total_other_messages == 0))
-    {
-      GNUNET_SCHEDULER_cancel (sched, die_task);
-      GNUNET_SCHEDULER_add_delayed (sched, GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 45), &send_other_messages, NULL);
-    }
-  else if ((total_other_expected_messages > 0) && (total_other_messages == total_other_expected_messages))
-    {
-      GNUNET_SCHEDULER_cancel (sched, die_task);
-      GNUNET_SCHEDULER_add_now (sched, &finish_testing, NULL);
-    }
-  else
-    {
-      pos->disconnect_task = GNUNET_SCHEDULER_add_now(sched, &disconnect_cores, pos);
-    }
-
-  return GNUNET_OK;
-}
-

 static void
 end_badly (void *cls, const struct GNUNET_SCHEDULER_TaskContext * tc)
 {
 static void
 end_badly (void *cls, const struct GNUNET_SCHEDULER_TaskContext * tc)
 {


@@ -393,14 +362,14 @@ end_badly (void *cls, const struct GNUNET_SCHEDULER_TaskContext * tc)
       pos = pos->next;
       if (free_pos->disconnect_task != GNUNET_SCHEDULER_NO_TASK)
         {
       pos = pos->next;
       if (free_pos->disconnect_task != GNUNET_SCHEDULER_NO_TASK)
         {

-          GNUNET_SCHEDULER_cancel(sched, free_pos->disconnect_task);
+          GNUNET_SCHEDULER_cancel(free_pos->disconnect_task);

         }
       GNUNET_free(free_pos);
     }
 
   if (pg != NULL)
     {
         }
       GNUNET_free(free_pos);
     }
 
   if (pg != NULL)
     {

-      GNUNET_TESTING_daemons_stop (pg, TIMEOUT);
+      GNUNET_TESTING_daemons_stop (pg, TIMEOUT, &shutdown_callback, NULL);

       ok = 7331;                /* Opposite of leet */
     }
   else
       ok = 7331;                /* Opposite of leet */
     }
   else


@@ -413,6 +382,71 @@ end_badly (void *cls, const struct GNUNET_SCHEDULER_TaskContext * tc)
     }
 }
 
     }
 }
 

+static void
+send_other_messages (void *cls, const struct GNUNET_SCHEDULER_TaskContext * tc);
+
+static int
+process_mtype (void *cls,
+               const struct GNUNET_PeerIdentity *peer,
+               const struct GNUNET_MessageHeader *message,
+               struct GNUNET_TIME_Relative latency,
+               uint32_t distance)
+{
+  struct TestMessageContext *pos = cls;
+  struct GNUNET_TestMessage *msg = (struct GNUNET_TestMessage *)message;
+  if (pos->uid != ntohl(msg->uid))
+    return GNUNET_OK;
+
+  GNUNET_assert(0 == memcmp(peer, &pos->peer1->id, sizeof(struct GNUNET_PeerIdentity)));
+  if (total_other_expected_messages == 0)
+    {
+      total_messages_received++;
+#if VERBOSE
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "Received message from `%4s', type %d, uid %u, distance %u.\n", GNUNET_i2s (peer), ntohs(message->type), ntohl(msg->uid), distance);
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "Total messages received %d, expected %d.\n", total_messages_received, expected_messages);
+#endif
+    }
+  else
+    {
+      total_other_messages++;
+#if VERBOSE
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "Received message from `%4s', type %d, uid %u, distance %u.\n", GNUNET_i2s (peer), ntohs(message->type), ntohl(msg->uid), distance);
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "Total messages received %d, expected %d.\n", total_other_messages, total_other_expected_messages);
+#endif
+    }
+
+  if ((total_messages_received == expected_messages) && (total_other_messages == 0))
+    {
+      GNUNET_SCHEDULER_cancel (die_task);
+      die_task = GNUNET_SCHEDULER_add_delayed (TEST_TIMEOUT,
+                                               &end_badly, "waiting for DV peers to connect!");
+      /*
+      if ((num_peers == 3) && (total_other_expected_messages == 2))
+        {
+          GNUNET_SCHEDULER_add_now (&send_other_messages, NULL);
+        }
+      else
+        {
+          GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 20), &send_other_messages, NULL);
+        }*/
+    }
+  else if ((total_other_expected_messages > 0) && (total_other_messages == total_other_expected_messages))
+    {
+      GNUNET_SCHEDULER_cancel (die_task);
+      GNUNET_SCHEDULER_add_now (&finish_testing, NULL);
+    }
+  else
+    {
+      pos->disconnect_task = GNUNET_SCHEDULER_add_now(&disconnect_cores, pos);
+    }
+
+  return GNUNET_OK;
+}
+

 static size_t
 transmit_ready (void *cls, size_t size, void *buf)
 {
 static size_t
 transmit_ready (void *cls, size_t size, void *buf)
 {


@@ -494,15 +528,15 @@ init_notify_peer1 (void *cls,
   /*
    * Connect to the receiving peer
    */
   /*
    * Connect to the receiving peer
    */

-  pos->peer2handle = GNUNET_CORE_connect (sched,
-                       pos->peer2->cfg,
-                       TIMEOUT,
-                       pos,
-                       &init_notify_peer2,
-                       NULL,
-                       NULL,
-                       NULL,
-                       GNUNET_YES, NULL, GNUNET_YES, handlers);
+  pos->peer2handle = GNUNET_CORE_connect (pos->peer2->cfg,
+                                         1, 
+                                         TIMEOUT,
+                                         pos,
+                                         &init_notify_peer2,
+                                         NULL,
+                                         NULL,
+                                         NULL, NULL,
+                                         GNUNET_YES, NULL, GNUNET_YES, handlers);

 
 }
 
 
 }
 


@@ -517,14 +551,13 @@ send_test_messages (void *cls, const struct GNUNET_SCHEDULER_TaskContext * tc)
 
   if (die_task == GNUNET_SCHEDULER_NO_TASK)
     {
 
   if (die_task == GNUNET_SCHEDULER_NO_TASK)
     {

-      die_task = GNUNET_SCHEDULER_add_delayed (sched,
-                                               TEST_TIMEOUT,
+      die_task = GNUNET_SCHEDULER_add_delayed (TEST_TIMEOUT,

                                                &end_badly, "from create topology (timeout)");
     }
 
   if (total_server_connections >= MAX_OUTSTANDING_CONNECTIONS)
     {
                                                &end_badly, "from create topology (timeout)");
     }
 
   if (total_server_connections >= MAX_OUTSTANDING_CONNECTIONS)
     {

-      GNUNET_SCHEDULER_add_delayed (sched, GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 1),
+      GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 1),

                                     &send_test_messages, pos);
       return; /* Otherwise we'll double schedule messages here! */
     }
                                     &send_test_messages, pos);
       return; /* Otherwise we'll double schedule messages here! */
     }


@@ -534,12 +567,12 @@ send_test_messages (void *cls, const struct GNUNET_SCHEDULER_TaskContext * tc)
   /*
    * Connect to the sending peer
    */
   /*
    * Connect to the sending peer
    */

-  pos->peer1handle = GNUNET_CORE_connect (sched,
-                                          pos->peer1->cfg,
+  pos->peer1handle = GNUNET_CORE_connect (pos->peer1->cfg,
+                                         1,

                                           TIMEOUT,
                                           pos,
                                           &init_notify_peer1,
                                           TIMEOUT,
                                           pos,
                                           &init_notify_peer1,

-                                          NULL,
+                                          NULL, NULL,

                                           NULL,
                                           NULL,
                                           GNUNET_NO, NULL, GNUNET_NO, no_handlers);
                                           NULL,
                                           NULL,
                                           GNUNET_NO, NULL, GNUNET_NO, no_handlers);


@@ -548,12 +581,11 @@ send_test_messages (void *cls, const struct GNUNET_SCHEDULER_TaskContext * tc)
 
   if (total_server_connections < MAX_OUTSTANDING_CONNECTIONS)
     {
 
   if (total_server_connections < MAX_OUTSTANDING_CONNECTIONS)
     {

-      GNUNET_SCHEDULER_add_now (sched,
-                                &send_test_messages, pos->next);
+      GNUNET_SCHEDULER_add_now (&send_test_messages, pos->next);

     }
   else
     {
     }
   else
     {

-      GNUNET_SCHEDULER_add_delayed (sched, GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 1),
+      GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 1),

                                     &send_test_messages, pos->next);
     }
 }
                                     &send_test_messages, pos->next);
     }
 }


@@ -615,19 +647,24 @@ send_other_messages (void *cls, const struct GNUNET_SCHEDULER_TaskContext * tc)
       pos = pos->next;
       if (free_pos->disconnect_task != GNUNET_SCHEDULER_NO_TASK)
         {
       pos = pos->next;
       if (free_pos->disconnect_task != GNUNET_SCHEDULER_NO_TASK)
         {

-          GNUNET_SCHEDULER_cancel(sched, free_pos->disconnect_task);
+          GNUNET_SCHEDULER_cancel(free_pos->disconnect_task);

         }
       GNUNET_free(free_pos);
     }
   test_messages = NULL;
 
   total_other_expected_messages = temp_total_other_messages;
         }
       GNUNET_free(free_pos);
     }
   test_messages = NULL;
 
   total_other_expected_messages = temp_total_other_messages;

+  if (total_other_expected_messages == 0)
+    {
+      GNUNET_SCHEDULER_add_now (&end_badly, "send_other_messages had 0 messages to send, no DV connections made!");
+    }

 #if VERBOSE
   GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Preparing to send %d other test messages\n", total_other_expected_messages);
 #endif
 
 #if VERBOSE
   GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Preparing to send %d other test messages\n", total_other_expected_messages);
 #endif
 

-  GNUNET_SCHEDULER_add_now (sched, &send_test_messages, other_test_messages);
-  die_task = GNUNET_SCHEDULER_add_delayed (sched, GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 250), &end_badly, "from send_other_messages");
+  GNUNET_SCHEDULER_add_now (&send_test_messages, other_test_messages);
+  GNUNET_SCHEDULER_cancel(die_task);
+  die_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 250), &end_badly, "from send_other_messages");

 }
 
 void
 }
 
 void


@@ -676,29 +713,26 @@ topology_callback (void *cls,
     {
 #if VERBOSE
       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
     {
 #if VERBOSE
       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,

-                  "Created %d total connections, which is our target number!  Calling send messages.\n",
+                  "Created %u total connections, which is our target number!  Calling send messages.\n",

                   total_connections);
 #endif
 
                   total_connections);
 #endif
 

-      GNUNET_SCHEDULER_cancel (sched, die_task);
+      GNUNET_SCHEDULER_cancel (die_task);

       die_task = GNUNET_SCHEDULER_NO_TASK;
       die_task = GNUNET_SCHEDULER_NO_TASK;

-      GNUNET_SCHEDULER_add_now (sched, &send_test_messages, test_messages);
-      //GNUNET_SCHEDULER_add_delayed (sched, GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 1), &send_test_messages, test_messages);
+      GNUNET_SCHEDULER_add_now (&send_test_messages, test_messages);

     }
   else if (total_connections + failed_connections == expected_connections)
     {
       if (failed_connections < (unsigned int)(fail_percentage * total_connections))
         {
     }
   else if (total_connections + failed_connections == expected_connections)
     {
       if (failed_connections < (unsigned int)(fail_percentage * total_connections))
         {

-          GNUNET_SCHEDULER_cancel (sched, die_task);
+          GNUNET_SCHEDULER_cancel (die_task);

           die_task = GNUNET_SCHEDULER_NO_TASK;
           die_task = GNUNET_SCHEDULER_NO_TASK;

-          GNUNET_SCHEDULER_add_now (sched, &send_test_messages, test_messages);
-          //GNUNET_SCHEDULER_add_delayed (sched, GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 1), &send_test_messages, test_messages);
+          GNUNET_SCHEDULER_add_now (&send_test_messages, test_messages);

         }
       else
         {
         }
       else
         {

-          GNUNET_SCHEDULER_cancel (sched, die_task);
-          die_task = GNUNET_SCHEDULER_add_now (sched,
-                                               &end_badly, "from topology_callback (too many failed connections)");
+          GNUNET_SCHEDULER_cancel (die_task);
+          die_task = GNUNET_SCHEDULER_add_now (&end_badly, "from topology_callback (too many failed connections)");

         }
     }
   else
         }
     }
   else


@@ -717,22 +751,20 @@ connect_topology ()
   expected_connections = -1;
   if ((pg != NULL) && (peers_left == 0))
     {
   expected_connections = -1;
   if ((pg != NULL) && (peers_left == 0))
     {

-      expected_connections = GNUNET_TESTING_connect_topology (pg, connection_topology, connect_topology_option, connect_topology_option_modifier);
+      expected_connections = GNUNET_TESTING_connect_topology (pg, connection_topology, connect_topology_option, connect_topology_option_modifier, NULL, NULL);

 #if VERBOSE
       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                   "Have %d expected connections\n", expected_connections);
 #endif
     }
 
 #if VERBOSE
       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                   "Have %d expected connections\n", expected_connections);
 #endif
     }
 

-  GNUNET_SCHEDULER_cancel (sched, die_task);
+  GNUNET_SCHEDULER_cancel (die_task);

   if (expected_connections == GNUNET_SYSERR)
     {
   if (expected_connections == GNUNET_SYSERR)
     {

-      die_task = GNUNET_SCHEDULER_add_now (sched,
-                                           &end_badly, "from connect topology (bad return)");
+      die_task = GNUNET_SCHEDULER_add_now (&end_badly, "from connect topology (bad return)");

     }
 
     }
 

-  die_task = GNUNET_SCHEDULER_add_delayed (sched,
-                                           TEST_TIMEOUT,
+  die_task = GNUNET_SCHEDULER_add_delayed (TEST_TIMEOUT,

                                            &end_badly, "from connect topology (timeout)");
 }
 
                                            &end_badly, "from connect topology (timeout)");
 }
 


@@ -750,13 +782,11 @@ create_topology ()
     }
   else
     {
     }
   else
     {

-      GNUNET_SCHEDULER_cancel (sched, die_task);
-      die_task = GNUNET_SCHEDULER_add_now (sched,
-                                           &end_badly, "from create topology (bad return)");
+      GNUNET_SCHEDULER_cancel (die_task);
+      die_task = GNUNET_SCHEDULER_add_now (&end_badly, "from create topology (bad return)");

     }
     }

-  GNUNET_SCHEDULER_cancel (sched, die_task);
-  die_task = GNUNET_SCHEDULER_add_delayed (sched,
-                                           TEST_TIMEOUT,
+  GNUNET_SCHEDULER_cancel (die_task);
+  die_task = GNUNET_SCHEDULER_add_delayed (TEST_TIMEOUT,

                                            &end_badly, "from continue startup (timeout)");
 }
 
                                            &end_badly, "from continue startup (timeout)");
 }
 


@@ -792,6 +822,7 @@ static void all_connect_handler (void *cls,
   if (second_daemon == NULL)
     {
       GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "Couldn't find second peer!\n");
   if (second_daemon == NULL)
     {
       GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "Couldn't find second peer!\n");

+      GNUNET_free(second_shortname);

       return;
     }
 #if !TEST_ALL
       return;
     }
 #if !TEST_ALL


@@ -823,6 +854,11 @@ static void all_connect_handler (void *cls,
         fprintf(dotOutFile, "\tn%s -- n%s [color=brown];\n", d->shortname, second_shortname);
     }
   GNUNET_free(second_shortname);
         fprintf(dotOutFile, "\tn%s -- n%s [color=brown];\n", d->shortname, second_shortname);
     }
   GNUNET_free(second_shortname);

+
+  if (temp_total_other_messages == num_additional_messages)
+    {
+      GNUNET_SCHEDULER_add_now (&send_other_messages, NULL);
+    }

 }
 
 static void
 }
 
 static void


@@ -846,7 +882,14 @@ peers_started_callback (void *cls,
   GNUNET_assert(GNUNET_SYSERR != GNUNET_CONTAINER_multihashmap_put(peer_daemon_hash, &id->hashPubKey, d, GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
 
   new_peer = GNUNET_malloc(sizeof(struct PeerContext));
   GNUNET_assert(GNUNET_SYSERR != GNUNET_CONTAINER_multihashmap_put(peer_daemon_hash, &id->hashPubKey, d, GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
 
   new_peer = GNUNET_malloc(sizeof(struct PeerContext));

-  new_peer->peer_handle = GNUNET_CORE_connect(sched, cfg, GNUNET_TIME_UNIT_FOREVER_REL, d, NULL, &all_connect_handler, NULL, NULL, GNUNET_NO, NULL, GNUNET_NO, no_handlers);
+  new_peer->peer_handle = GNUNET_CORE_connect(cfg, 
+                                             1,
+                                             GNUNET_TIME_UNIT_FOREVER_REL,
+                                             d, NULL,
+                                             &all_connect_handler, 
+                                             NULL, NULL, NULL, 
+                                             GNUNET_NO, NULL, GNUNET_NO,
+                                             no_handlers);

   new_peer->daemon = d;
   new_peer->next = all_peers;
   all_peers = new_peer;
   new_peer->daemon = d;
   new_peer->next = all_peers;
   all_peers = new_peer;


@@ -859,11 +902,10 @@ peers_started_callback (void *cls,
                   "All %d daemons started, now creating topology!\n",
                   num_peers);
 #endif
                   "All %d daemons started, now creating topology!\n",
                   num_peers);
 #endif

-      GNUNET_SCHEDULER_cancel (sched, die_task);
+      GNUNET_SCHEDULER_cancel (die_task);

       /* Set up task in case topology creation doesn't finish
        * within a reasonable amount of time */
       /* Set up task in case topology creation doesn't finish
        * within a reasonable amount of time */

-      die_task = GNUNET_SCHEDULER_add_delayed (sched,
-                                               GNUNET_TIME_relative_multiply
+      die_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply

                                                (GNUNET_TIME_UNIT_MINUTES, 5),
                                                &end_badly, "from peers_started_callback");
 
                                                (GNUNET_TIME_UNIT_MINUTES, 5),
                                                &end_badly, "from peers_started_callback");
 


@@ -903,21 +945,19 @@ void hostkey_callback (void *cls,
                     "All %d hostkeys created, now creating topology!\n",
                     num_peers);
 #endif
                     "All %d hostkeys created, now creating topology!\n",
                     num_peers);
 #endif

-        GNUNET_SCHEDULER_cancel (sched, die_task);
+        GNUNET_SCHEDULER_cancel (die_task);

         /* Set up task in case topology creation doesn't finish
          * within a reasonable amount of time */
         /* Set up task in case topology creation doesn't finish
          * within a reasonable amount of time */

-        die_task = GNUNET_SCHEDULER_add_delayed (sched,
-                                                 GNUNET_TIME_relative_multiply
+        die_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply

                                                  (GNUNET_TIME_UNIT_MINUTES, 5),
                                                  &end_badly, "from hostkey_callback");
                                                  (GNUNET_TIME_UNIT_MINUTES, 5),
                                                  &end_badly, "from hostkey_callback");

-        GNUNET_SCHEDULER_add_now(sched, &create_topology, NULL);
+        GNUNET_SCHEDULER_add_now(&create_topology, NULL);

         ok = 0;
       }
 }
 
 static void
 run (void *cls,
         ok = 0;
       }
 }
 
 static void
 run (void *cls,

-     struct GNUNET_SCHEDULER_Handle *s,

      char *const *args,
      const char *cfgfile, const struct GNUNET_CONFIGURATION_Handle *cfg)
 {
      char *const *args,
      const char *cfgfile, const struct GNUNET_CONFIGURATION_Handle *cfg)
 {


@@ -926,7 +966,6 @@ run (void *cls,
   char * blacklist_topology_str;
   char * connect_topology_option_str;
   char * connect_topology_option_modifier_string;
   char * blacklist_topology_str;
   char * connect_topology_option_str;
   char * connect_topology_option_modifier_string;

-  sched = s;

   ok = 1;
 
   dotOutFile = fopen (dotOutFileName, "w");
   ok = 1;
 
   dotOutFile = fopen (dotOutFileName, "w");


@@ -1005,18 +1044,23 @@ run (void *cls,
                                              &num_peers))
     num_peers = DEFAULT_NUM_PEERS;
 
                                              &num_peers))
     num_peers = DEFAULT_NUM_PEERS;
 

+  if (GNUNET_SYSERR ==
+      GNUNET_CONFIGURATION_get_value_number (cfg, "testing", "additional_messages",
+                                             &num_additional_messages))
+    num_additional_messages = DEFAULT_ADDITIONAL_MESSAGES;
+

   main_cfg = cfg;
 
   main_cfg = cfg;
 

+  GNUNET_assert(num_peers > 0 && num_peers < (unsigned int)-1);

   peers_left = num_peers;
 
   /* Set up a task to end testing if peer start fails */
   peers_left = num_peers;
 
   /* Set up a task to end testing if peer start fails */

-  die_task = GNUNET_SCHEDULER_add_delayed (sched,
-                                           GNUNET_TIME_relative_multiply
+  die_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply

                                            (GNUNET_TIME_UNIT_MINUTES, 5),
                                            &end_badly, "didn't start all daemons in reasonable amount of time!!!");
 
   peer_daemon_hash = GNUNET_CONTAINER_multihashmap_create(peers_left);
                                            (GNUNET_TIME_UNIT_MINUTES, 5),
                                            &end_badly, "didn't start all daemons in reasonable amount of time!!!");
 
   peer_daemon_hash = GNUNET_CONTAINER_multihashmap_create(peers_left);

-  pg = GNUNET_TESTING_daemons_start (sched, cfg,
+  pg = GNUNET_TESTING_daemons_start (cfg,

                                      peers_left, TIMEOUT, &hostkey_callback, NULL, &peers_started_callback, NULL,
                                      &topology_callback, NULL, NULL);
 
                                      peers_left, TIMEOUT, &hostkey_callback, NULL, &peers_started_callback, NULL,
                                      &topology_callback, NULL, NULL);
 


@@ -1060,7 +1104,6 @@ main (int argc, char *argv[])
 #endif
                     NULL);
   ret = check ();
 #endif
                     NULL);
   ret = check ();

-

   /**
    * Need to remove base directory, subdirectories taken care
    * of by the testing framework.
   /**
    * Need to remove base directory, subdirectories taken care
    * of by the testing framework.


@@ -1072,4 +1115,4 @@ main (int argc, char *argv[])
   return ret;
 }
 
   return ret;
 }
 

-/* end of test_testing_topology.c */
+/* end of test_transport_api_dv.c */