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 6ad3964155a99a7455194b29460fb7c953858032..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


@@ -35,15 +35,8 @@
 #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, 60)
-

 #define MTYPE 12345
 
 struct PeerContext
 #define MTYPE 12345
 
 struct PeerContext


@@ -53,8 +46,9 @@ struct PeerContext
   struct GNUNET_PeerIdentity id;   
   struct GNUNET_TRANSPORT_Handle *th;
   struct GNUNET_MessageHeader *hello;
   struct GNUNET_PeerIdentity id;   
   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,8 +76,6 @@ 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_services (p1.cfg, sched, "core", NULL);
-  GNUNET_ARM_stop_services (p2.cfg, sched, "core", NULL);

   ok = 0;
 }
 
   ok = 0;
 }
 


@@ -91,25 +83,73 @@ terminate_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 static void
 terminate_task_error (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
 static void
 terminate_task_error (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {

+#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);
   GNUNET_break (0);
   GNUNET_CORE_disconnect (p1.ch);
   GNUNET_CORE_disconnect (p2.ch);
   GNUNET_TRANSPORT_disconnect (p1.th);
   GNUNET_TRANSPORT_disconnect (p2.th);

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

   ok = 42;
 }
 
 
   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
 connect_notify (void *cls,
 static void
 connect_notify (void *cls,

-                const struct GNUNET_PeerIdentity *peer)
+                const struct GNUNET_PeerIdentity *peer,
+               const struct GNUNET_TRANSPORT_ATS_Information *atsi)

 {
 {

-  GNUNET_assert ((ok == 5) || (ok == 6));
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Encrypted connection established to peer `%4s'\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));
+       }  
+    }

 }
 
 
 }
 
 


@@ -117,28 +157,23 @@ static void
 disconnect_notify (void *cls,
                    const struct GNUNET_PeerIdentity *peer)
 {
 disconnect_notify (void *cls,
                    const struct GNUNET_PeerIdentity *peer)
 {

-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Encrypted connection to `%4s' cut\n", GNUNET_i2s (peer));
-}
-
+  struct PeerContext *pc = cls;

 
 

-static unsigned int
-bfc_callback (void *cls,
-              const struct GNUNET_PeerIdentity *receiver,
-              void *position, 
-             size_t padding)
-{
+  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));


@@ -149,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",


@@ -158,21 +194,19 @@ outbound_notify (void *cls,
 }
 
 
 }
 
 

-static GNUNET_SCHEDULER_TaskIdentifier err_task;
-

 
 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_cancel (sched, err_task);
-  GNUNET_SCHEDULER_add_delayed (sched,
-                                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;
 }
 


@@ -183,28 +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));
-  err_task = 
-    GNUNET_SCHEDULER_add_delayed (sched,
-                                 GNUNET_TIME_UNIT_MINUTES, &terminate_task_error, NULL);
-
-  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,


@@ -224,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);


@@ -242,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);

 }
 
 
 }
 
 


@@ -288,7 +293,7 @@ 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",
                                         "gnunet-service-arm",
 #if VERBOSE
                                         "-L", "DEBUG",


@@ -296,48 +301,44 @@ setup_peer (struct PeerContext *p, const char *cfgname)
                                         "-c", cfgname, NULL);
 #endif
   GNUNET_assert (GNUNET_OK == GNUNET_CONFIGURATION_load (p->cfg, cfgname));
                                         "-c", cfgname, NULL);
 #endif
   GNUNET_assert (GNUNET_OK == GNUNET_CONFIGURATION_load (p->cfg, cfgname));

-  GNUNET_ARM_start_services (p->cfg, sched, "core", 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,
      const char *cfgfile,
      const struct GNUNET_CONFIGURATION_Handle *cfg)
 {
   GNUNET_assert (ok == 1);
   OKPP;
      char *const *args,
      const char *cfgfile,
      const struct GNUNET_CONFIGURATION_Handle *cfg)
 {
   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 (GNUNET_OS_process_wait(p->arm_pid) != GNUNET_OK)
+  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);
 }


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

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

 
   return ret;
 }
 
   return ret;
 }