fixing leak

[oweals/gnunet.git] / src / core / test_core_api.c

diff --git a/src/core/test_core_api.c b/src/core/test_core_api.c
index e8b7fbe3b9ce6081af720a3ebf6eadab1dff7709..38aaf63b175afdb1944448fa8e20d73d47d4ede1 100644 (file)
--- a/src/core/test_core_api.c
+++ b/src/core/test_core_api.c
@@ -1,10 +1,10 @@
 /*
      This file is part of GNUnet.
 /*
      This file is part of GNUnet.

-     (C) 2009 Christian Grothoff (and other contributing authors)
+     (C) 2009, 2010 Christian Grothoff (and other contributing authors)

 
      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


@@ -18,7 +18,7 @@
      Boston, MA 02111-1307, USA.
 */
 /**
      Boston, MA 02111-1307, USA.
 */
 /**

- * @file transport/test_core_api.c
+ * @file core/test_core_api.c

  * @brief testcase for core_api.c
  *
  * FIXME:
  * @brief testcase for core_api.c
  *
  * FIXME:


@@ -35,26 +35,20 @@
 #include "gnunet_transport_service.h"
 
 #define VERBOSE GNUNET_NO
 #include "gnunet_transport_service.h"
 
 #define VERBOSE GNUNET_NO

-

 #define START_ARM GNUNET_YES
 
 #define START_ARM GNUNET_YES
 

-
-/**
- * How long until we give up on transmitting the message?
- */
-#define TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 15)
-

 #define MTYPE 12345
 
 struct PeerContext
 {
   struct GNUNET_CONFIGURATION_Handle *cfg;
   struct GNUNET_CORE_Handle *ch;
 #define MTYPE 12345
 
 struct PeerContext
 {
   struct GNUNET_CONFIGURATION_Handle *cfg;
   struct GNUNET_CORE_Handle *ch;

-  struct GNUNET_PeerIdentity id;        /* FIXME: this is always all-zeros! */
+  struct GNUNET_PeerIdentity id;   

   struct GNUNET_TRANSPORT_Handle *th;
   struct GNUNET_MessageHeader *hello;
   struct GNUNET_TRANSPORT_Handle *th;
   struct GNUNET_MessageHeader *hello;

+  int connect_status;

 #if START_ARM
 #if START_ARM

-  pid_t arm_pid;
+  struct GNUNET_OS_Process *arm_proc;

 #endif
 };
 
 #endif
 };
 


@@ -62,7 +56,7 @@ static struct PeerContext p1;
 
 static struct PeerContext p2;
 
 
 static struct PeerContext p2;
 

-static struct GNUNET_SCHEDULER_Handle *sched;
+static GNUNET_SCHEDULER_TaskIdentifier err_task;

 
 static int ok;
 
 
 static int ok;
 


@@ -82,48 +76,104 @@ terminate_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
   GNUNET_CORE_disconnect (p2.ch);
   GNUNET_TRANSPORT_disconnect (p1.th);
   GNUNET_TRANSPORT_disconnect (p2.th);
   GNUNET_CORE_disconnect (p2.ch);
   GNUNET_TRANSPORT_disconnect (p1.th);
   GNUNET_TRANSPORT_disconnect (p2.th);

-  GNUNET_ARM_stop_service ("core", p1.cfg, sched, TIMEOUT, NULL, NULL);
-  GNUNET_ARM_stop_service ("core", p2.cfg, sched, TIMEOUT, NULL, NULL);

   ok = 0;
 }
 
 
 static void
   ok = 0;
 }
 
 
 static void

-connect_notify (void *cls,
-                const struct GNUNET_PeerIdentity *peer)
+terminate_task_error (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)

 {
 {

-  GNUNET_assert ((ok == 5) || (ok == 6));
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Encrypted connection established to peer `%4s'\n",
-              GNUNET_i2s (peer));
+#if VERBOSE
+  fprintf(stderr, "ENDING ANGRILY %u\n", ok);
+#endif
+  GNUNET_break (0);
+  GNUNET_CORE_disconnect (p1.ch);
+  GNUNET_CORE_disconnect (p2.ch);
+  GNUNET_TRANSPORT_disconnect (p1.th);
+  GNUNET_TRANSPORT_disconnect (p2.th);
+  ok = 42;
+}
+
+
+static size_t
+transmit_ready (void *cls, size_t size, void *buf)
+{
+  struct PeerContext *p = cls;
+  struct GNUNET_MessageHeader *m;
+
+  GNUNET_assert (ok == 4);
+  OKPP;
+  GNUNET_assert (p == &p1);
+  GNUNET_assert (buf != NULL);
+  m = (struct GNUNET_MessageHeader *) buf;
+  m->type = htons (MTYPE);
+  m->size = htons (sizeof (struct GNUNET_MessageHeader));
+  err_task = 
+    GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 120), 
+                                 &terminate_task_error, NULL);
+
+  return sizeof (struct GNUNET_MessageHeader);

 }
 
 
 static void
 }
 
 
 static void

-disconnect_notify (void *cls,
-                   const struct GNUNET_PeerIdentity *peer)
+connect_notify (void *cls,
+                const struct GNUNET_PeerIdentity *peer,
+               const struct GNUNET_TRANSPORT_ATS_Information *atsi)

 {
 {

-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Encrypted connection to `%4s' cut\n", GNUNET_i2s (peer));
+  struct PeerContext *pc = cls;
+
+  if (0 == memcmp (&pc->id,
+                  peer,
+                  sizeof (struct GNUNET_PeerIdentity)))
+    return;
+  GNUNET_assert (pc->connect_status == 0);
+  pc->connect_status = 1;
+  if (pc == &p1)
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                 "Encrypted connection established to peer `%4s'\n",
+                 GNUNET_i2s (peer));
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                 "Asking core (1) for transmission to peer `%4s'\n",
+                 GNUNET_i2s (&p2.id));
+      if (NULL == GNUNET_CORE_notify_transmit_ready (p1.ch,
+                                                    GNUNET_YES,
+                                                    0,
+                                                    GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 45),
+                                                    &p2.id,
+                                                    sizeof (struct GNUNET_MessageHeader),
+                                                    &transmit_ready, &p1))
+       {
+         GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                     "RECEIVED NULL when asking core (1) for transmission to peer `%4s'\n",
+                     GNUNET_i2s (&p2.id));
+       }  
+    }

 }
 
 
 }
 
 

-static unsigned int
-bfc_callback (void *cls,
-              const struct GNUNET_PeerIdentity *receiver,
-              void *position, unsigned int padding)
+static void
+disconnect_notify (void *cls,
+                   const struct GNUNET_PeerIdentity *peer)

 {
 {

+  struct PeerContext *pc = cls;
+
+  if (0 == memcmp (&pc->id,
+                  peer,
+                  sizeof (struct GNUNET_PeerIdentity)))
+    return;
+  pc->connect_status = 0;

   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,

-              "Core requests data for `%4s', I have none.\n",
-              GNUNET_i2s (receiver));
-  return 0;
+              "Encrypted connection to `%4s' cut\n", GNUNET_i2s (peer));

 }
 
 
 static int
 inbound_notify (void *cls,
                 const struct GNUNET_PeerIdentity *other,
 }
 
 
 static int
 inbound_notify (void *cls,
                 const struct GNUNET_PeerIdentity *other,

-                const struct GNUNET_MessageHeader *message)
+                const struct GNUNET_MessageHeader *message,
+               const struct GNUNET_TRANSPORT_ATS_Information *atsi)

 {
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "Core provides inbound data from `%4s'.\n", GNUNET_i2s (other));
 {
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "Core provides inbound data from `%4s'.\n", GNUNET_i2s (other));


@@ -134,7 +184,8 @@ inbound_notify (void *cls,
 static int
 outbound_notify (void *cls,
                  const struct GNUNET_PeerIdentity *other,
 static int
 outbound_notify (void *cls,
                  const struct GNUNET_PeerIdentity *other,

-                 const struct GNUNET_MessageHeader *message)
+                 const struct GNUNET_MessageHeader *message,
+                const struct GNUNET_TRANSPORT_ATS_Information *atsi)

 {
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "Core notifies about outbound data for `%4s'.\n",
 {
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "Core notifies about outbound data for `%4s'.\n",


@@ -143,20 +194,19 @@ outbound_notify (void *cls,
 }
 
 
 }
 
 

+

 static int
 process_mtype (void *cls,
                const struct GNUNET_PeerIdentity *peer,
 static int
 process_mtype (void *cls,
                const struct GNUNET_PeerIdentity *peer,

-               const struct GNUNET_MessageHeader *message)
+               const struct GNUNET_MessageHeader *message,
+              const struct GNUNET_TRANSPORT_ATS_Information *atsi)

 {
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "Receiving message from `%4s'.\n", GNUNET_i2s (peer));
   GNUNET_assert (ok == 5);
   OKPP;
 {
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "Receiving message from `%4s'.\n", GNUNET_i2s (peer));
   GNUNET_assert (ok == 5);
   OKPP;

-  GNUNET_SCHEDULER_add_delayed (sched,
-                                GNUNET_NO,
-                                GNUNET_SCHEDULER_PRIORITY_KEEP,
-                                GNUNET_SCHEDULER_NO_PREREQUISITE_TASK,
-                                GNUNET_TIME_UNIT_ZERO, &terminate_task, NULL);
+  GNUNET_SCHEDULER_cancel (err_task);
+  GNUNET_SCHEDULER_add_now (&terminate_task, NULL);

   return GNUNET_OK;
 }
 
   return GNUNET_OK;
 }
 


@@ -167,24 +217,6 @@ static struct GNUNET_CORE_MessageHandler handlers[] = {
 };
 
 
 };
 
 

-static size_t
-transmit_ready (void *cls, size_t size, void *buf)
-{
-  struct PeerContext *p = cls;
-  struct GNUNET_MessageHeader *m;
-
-  GNUNET_assert (ok == 4);
-  OKPP;
-  GNUNET_assert (p == &p1);
-  GNUNET_assert (buf != NULL);
-  m = (struct GNUNET_MessageHeader *) buf;
-  m->type = htons (MTYPE);
-  m->size = htons (sizeof (struct GNUNET_MessageHeader));
-  return sizeof (struct GNUNET_MessageHeader);
-}
-
-
-

 static void
 init_notify (void *cls,
              struct GNUNET_CORE_Handle *server,
 static void
 init_notify (void *cls,
              struct GNUNET_CORE_Handle *server,


@@ -204,14 +236,12 @@ init_notify (void *cls,
       GNUNET_assert (ok == 2);
       OKPP;
       /* connect p2 */
       GNUNET_assert (ok == 2);
       OKPP;
       /* connect p2 */

-      GNUNET_CORE_connect (sched,
-                           p2.cfg,
-                           TIMEOUT,
+      GNUNET_CORE_connect (p2.cfg, 1,

                            &p2,
                            &p2,

-                           &init_notify,
+                           &init_notify,                        

                            &connect_notify,
                            &disconnect_notify,
                            &connect_notify,
                            &disconnect_notify,

-                           &bfc_callback,
+                          NULL,

                            &inbound_notify,
                            GNUNET_YES,
                            &outbound_notify, GNUNET_YES, handlers);
                            &inbound_notify,
                            GNUNET_YES,
                            &outbound_notify, GNUNET_YES, handlers);


@@ -222,43 +252,38 @@ init_notify (void *cls,
       OKPP;
       GNUNET_assert (cls == &p2);
       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
       OKPP;
       GNUNET_assert (cls == &p2);
       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,

-                  "Asking core (1) for transmission to peer `%4s'\n",
+                  "Asking core (1) to connect to peer `%4s'\n",

                   GNUNET_i2s (&p2.id));
                   GNUNET_i2s (&p2.id));

-      GNUNET_CORE_notify_transmit_ready (p1.ch,
-                                         0,
-                                         TIMEOUT,
-                                         &p2.id,
-                                         sizeof (struct GNUNET_MessageHeader),
-                                         &transmit_ready, &p1);
-
+      GNUNET_CORE_peer_request_connect (p1.ch,
+                                       GNUNET_TIME_UNIT_SECONDS,
+                                       &p2.id,
+                                       NULL, NULL);

     }
 }
 
 
 static void
 process_hello (void *cls,
     }
 }
 
 
 static void
 process_hello (void *cls,

-               struct GNUNET_TIME_Relative latency,
-               const struct GNUNET_PeerIdentity *peer,

                const struct GNUNET_MessageHeader *message)
 {
   struct PeerContext *p = cls;
 
                const struct GNUNET_MessageHeader *message)
 {
   struct PeerContext *p = cls;
 

-  GNUNET_assert (peer != NULL);
+  GNUNET_TRANSPORT_get_hello_cancel (p->th, &process_hello, p);

   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,

-              "Received (my) `%s' from transport service of `%4s'\n",
-              "HELLO", GNUNET_i2s (peer));
+              "Received (my) `%s' from transport service\n",
+              "HELLO");

   GNUNET_assert (message != NULL);
   p->hello = GNUNET_malloc (ntohs (message->size));
   memcpy (p->hello, message, ntohs (message->size));
   if ((p == &p1) && (p2.th != NULL))
   GNUNET_assert (message != NULL);
   p->hello = GNUNET_malloc (ntohs (message->size));
   memcpy (p->hello, message, ntohs (message->size));
   if ((p == &p1) && (p2.th != NULL))

-    GNUNET_TRANSPORT_offer_hello (p2.th, message);
+    GNUNET_TRANSPORT_offer_hello (p2.th, message, NULL, NULL);

   if ((p == &p2) && (p1.th != NULL))
   if ((p == &p2) && (p1.th != NULL))

-    GNUNET_TRANSPORT_offer_hello (p1.th, message);
+    GNUNET_TRANSPORT_offer_hello (p1.th, message, NULL, NULL);

 
   if ((p == &p1) && (p2.hello != NULL))
 
   if ((p == &p1) && (p2.hello != NULL))

-    GNUNET_TRANSPORT_offer_hello (p1.th, p2.hello);
+    GNUNET_TRANSPORT_offer_hello (p1.th, p2.hello, NULL, NULL);

   if ((p == &p2) && (p1.hello != NULL))
   if ((p == &p2) && (p1.hello != NULL))

-    GNUNET_TRANSPORT_offer_hello (p2.th, p1.hello);
+    GNUNET_TRANSPORT_offer_hello (p2.th, p1.hello, NULL, NULL);

 }
 
 
 }
 
 


@@ -268,56 +293,52 @@ setup_peer (struct PeerContext *p, const char *cfgname)
 {
   p->cfg = GNUNET_CONFIGURATION_create ();
 #if START_ARM
 {
   p->cfg = GNUNET_CONFIGURATION_create ();
 #if START_ARM

-  p->arm_pid = GNUNET_OS_start_process ("gnunet-service-arm",
+  p->arm_proc = GNUNET_OS_start_process (NULL, NULL, "gnunet-service-arm",

                                         "gnunet-service-arm",
 #if VERBOSE
                                         "-L", "DEBUG",
 #endif
                                         "-c", cfgname, NULL);
                                         "gnunet-service-arm",
 #if VERBOSE
                                         "-L", "DEBUG",
 #endif
                                         "-c", cfgname, NULL);

-  sleep (1);                    /* allow ARM to start */

 #endif
   GNUNET_assert (GNUNET_OK == GNUNET_CONFIGURATION_load (p->cfg, cfgname));
 #endif
   GNUNET_assert (GNUNET_OK == GNUNET_CONFIGURATION_load (p->cfg, cfgname));

-  GNUNET_ARM_start_service ("core", p->cfg, sched, TIMEOUT, NULL, NULL);
-  p->th = GNUNET_TRANSPORT_connect (sched, p->cfg, p, NULL, NULL, NULL);
+  p->th = GNUNET_TRANSPORT_connect (p->cfg, NULL, p, NULL, NULL, NULL);

   GNUNET_assert (p->th != NULL);
   GNUNET_assert (p->th != NULL);

-  GNUNET_TRANSPORT_get_hello (p->th, TIMEOUT, &process_hello, p);
+  GNUNET_TRANSPORT_get_hello (p->th, &process_hello, p);

 }
 
 
 static void
 run (void *cls,
 }
 
 
 static void
 run (void *cls,

-     struct GNUNET_SCHEDULER_Handle *s,

      char *const *args,
      char *const *args,

-     const char *cfgfile, struct GNUNET_CONFIGURATION_Handle *cfg)
+     const char *cfgfile,
+     const struct GNUNET_CONFIGURATION_Handle *cfg)

 {
   GNUNET_assert (ok == 1);
   OKPP;
 {
   GNUNET_assert (ok == 1);
   OKPP;

-  sched = s;

   setup_peer (&p1, "test_core_api_peer1.conf");
   setup_peer (&p2, "test_core_api_peer2.conf");
   setup_peer (&p1, "test_core_api_peer1.conf");
   setup_peer (&p2, "test_core_api_peer2.conf");

-  GNUNET_CORE_connect (sched,
-                       p1.cfg,
-                       TIMEOUT,
+  GNUNET_CORE_connect (p1.cfg, 1,

                        &p1,
                        &init_notify,
                        &p1,
                        &init_notify,

-                       &connect_notify,
+                      &connect_notify,

                        &disconnect_notify,
                        &disconnect_notify,

-                       &bfc_callback,
+                      NULL,

                        &inbound_notify,
                        GNUNET_YES, &outbound_notify, GNUNET_YES, handlers);
 }
 
                        &inbound_notify,
                        GNUNET_YES, &outbound_notify, GNUNET_YES, handlers);
 }
 

-

 static void
 stop_arm (struct PeerContext *p)
 {
 #if START_ARM
 static void
 stop_arm (struct PeerContext *p)
 {
 #if START_ARM

-  if (0 != PLIBC_KILL (p->arm_pid, SIGTERM))
+  if (0 != GNUNET_OS_process_kill (p->arm_proc, SIGTERM))

     GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "kill");
     GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "kill");

-  if (p->arm_pid != waitpid (p->arm_pid, NULL, 0))
+  if (GNUNET_OS_process_wait(p->arm_proc) != GNUNET_OK)

     GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "waitpid");
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
     GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "waitpid");
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,

-              "ARM process %u stopped\n", p->arm_pid);
+              "ARM process %u stopped\n", GNUNET_OS_process_get_pid (p->arm_proc));
+  GNUNET_OS_process_close (p->arm_proc);
+  p->arm_proc = NULL;

 #endif
   GNUNET_CONFIGURATION_destroy (p->cfg);
 }
 #endif
   GNUNET_CONFIGURATION_destroy (p->cfg);
 }


@@ -336,7 +357,6 @@ check ()
   struct GNUNET_GETOPT_CommandLineOption options[] = {
     GNUNET_GETOPT_OPTION_END
   };
   struct GNUNET_GETOPT_CommandLineOption options[] = {
     GNUNET_GETOPT_OPTION_END
   };

-  // sleep (1); /* for 'make check': allow previous processes to fully terminate */

   ok = 1;
   GNUNET_PROGRAM_run ((sizeof (argv) / sizeof (char *)) - 1,
                       argv, "test-core-api", "nohelp", options, &run, &ok);
   ok = 1;
   GNUNET_PROGRAM_run ((sizeof (argv) / sizeof (char *)) - 1,
                       argv, "test-core-api", "nohelp", options, &run, &ok);


@@ -358,6 +378,8 @@ main (int argc, char *argv[])
 #endif
                     NULL);
   ret = check ();
 #endif
                     NULL);
   ret = check ();

+  GNUNET_DISK_directory_remove ("/tmp/test-gnunet-core-peer-1"); 
+  GNUNET_DISK_directory_remove ("/tmp/test-gnunet-core-peer-2");

 
   return ret;
 }
 
   return ret;
 }