- Remove printf, use GNUNET_log INFO

[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 9fafb10ded15eb61c50e38a324e224f674a6917c..ab96fb47e926ca9ec22908157db1379ddfa41dca 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


@@ -20,9 +20,6 @@
 /**
  * @file core/test_core_api.c
  * @brief testcase for core_api.c
 /**
  * @file core/test_core_api.c
  * @brief testcase for core_api.c

- *
- * FIXME:
- * - make sure connect callback is invoked properly as well!

  */
 #include "platform.h"
 #include "gnunet_common.h"
  */
 #include "platform.h"
 #include "gnunet_common.h"


@@ -34,59 +31,69 @@
 #include "gnunet_scheduler_lib.h"
 #include "gnunet_transport_service.h"
 
 #include "gnunet_scheduler_lib.h"
 #include "gnunet_transport_service.h"
 

-#define VERBOSE GNUNET_NO
-
-#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
 {
   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;   
+  struct GNUNET_PeerIdentity id;

   struct GNUNET_TRANSPORT_Handle *th;
   struct GNUNET_TRANSPORT_Handle *th;

+  struct GNUNET_TRANSPORT_GetHelloHandle *ghh;

   struct GNUNET_MessageHeader *hello;
   struct GNUNET_MessageHeader *hello;

-#if START_ARM
-  pid_t arm_pid;
-#endif
+  int connect_status;
+  struct GNUNET_OS_Process *arm_proc;

 };
 
 static struct PeerContext p1;
 
 static struct PeerContext p2;
 
 };
 
 static struct PeerContext p1;
 
 static struct PeerContext p2;
 

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

 
 static int ok;
 
 
 static int ok;
 

-#if VERBOSE
-#define OKPP do { ok++; fprintf (stderr, "Now at stage %u at %s:%u\n", ok, __FILE__, __LINE__); } while (0)
-#else
-#define OKPP do { ok++; } while (0)
-#endif
+#define OKPP do { ok++; GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Now at stage %u at %s:%u\n", ok, __FILE__, __LINE__); } while (0)
+
+
+static void
+process_hello (void *cls, const struct GNUNET_MessageHeader *message)
+{
+  struct PeerContext *p = cls;

 
 

+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Received (my) `%s' from transport service\n", "HELLO");
+  GNUNET_assert (message != NULL);
+  if ((p == &p1) && (p2.th != NULL))
+    GNUNET_TRANSPORT_offer_hello (p2.th, message, NULL, NULL);
+  if ((p == &p2) && (p1.th != NULL))
+    GNUNET_TRANSPORT_offer_hello (p1.th, message, NULL, NULL);
+}

 
 
 static void
 terminate_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   GNUNET_assert (ok == 6);
 
 
 static void
 terminate_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   GNUNET_assert (ok == 6);

-#if VERBOSE
-  fprintf(stderr, "ENDING WELL %u\n", ok);
-#endif

   GNUNET_CORE_disconnect (p1.ch);
   GNUNET_CORE_disconnect (p1.ch);

+  p1.ch = NULL;

   GNUNET_CORE_disconnect (p2.ch);
   GNUNET_CORE_disconnect (p2.ch);

+  p2.ch = NULL;
+  GNUNET_TRANSPORT_get_hello_cancel (p1.ghh);
+  p1.ghh = NULL;
+  GNUNET_TRANSPORT_get_hello_cancel (p2.ghh);
+  p2.ghh = NULL;

   GNUNET_TRANSPORT_disconnect (p1.th);
   GNUNET_TRANSPORT_disconnect (p1.th);

+  p1.th = NULL;

   GNUNET_TRANSPORT_disconnect (p2.th);
   GNUNET_TRANSPORT_disconnect (p2.th);

-  GNUNET_ARM_stop_services (p1.cfg, sched, "core", NULL);
-  GNUNET_ARM_stop_services (p2.cfg, sched, "core", NULL);
+  p2.th = NULL;
+  if (GNUNET_SCHEDULER_NO_TASK != con_task)
+  {
+    GNUNET_SCHEDULER_cancel (con_task);
+    con_task = GNUNET_SCHEDULER_NO_TASK;
+  }

   ok = 0;
 }
 
   ok = 0;
 }
 


@@ -94,48 +101,115 @@ 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_log (GNUNET_ERROR_TYPE_DEBUG,
+             "ENDING ANGRILY %u\n", ok);

   GNUNET_break (0);
   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);
+  if (NULL != p1.ch)
+  {
+    GNUNET_CORE_disconnect (p1.ch);
+    p1.ch = NULL;
+  }
+  if (NULL != p2.ch)
+  {
+    GNUNET_CORE_disconnect (p2.ch);
+    p2.ch = NULL;
+  }
+  if (p1.th != NULL)
+  {
+    GNUNET_TRANSPORT_get_hello_cancel (p1.ghh);
+    GNUNET_TRANSPORT_disconnect (p1.th);
+    p1.th = NULL;
+  }
+  if (p2.th != NULL)
+  {
+    GNUNET_TRANSPORT_get_hello_cancel (p2.ghh);
+    GNUNET_TRANSPORT_disconnect (p2.th);
+    p2.th = NULL;
+  }
+  if (GNUNET_SCHEDULER_NO_TASK != con_task)
+  {
+    GNUNET_SCHEDULER_cancel (con_task);
+    con_task = GNUNET_SCHEDULER_NO_TASK;
+  }

   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));
+  return sizeof (struct GNUNET_MessageHeader);
+}
+
+

 static void
 static void

-connect_notify (void *cls,
-                const struct GNUNET_PeerIdentity *peer,
-               struct GNUNET_TIME_Relative latency,
-               uint32_t distance)
+connect_notify (void *cls, const struct GNUNET_PeerIdentity *peer,
+                const struct GNUNET_ATS_Information *atsi,
+                unsigned int atsi_count)

 {
 {

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

   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "Encrypted connection established to peer `%4s'\n",
               GNUNET_i2s (peer));
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "Encrypted connection established to peer `%4s'\n",
               GNUNET_i2s (peer));

+  if (GNUNET_SCHEDULER_NO_TASK != con_task)
+  {
+    GNUNET_SCHEDULER_cancel (con_task);
+    con_task = GNUNET_SCHEDULER_NO_TASK;
+  }
+  pc->connect_status = 1;
+  if (pc == &p1)
+  {
+    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, 145),
+                                           &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 void
 }
 
 
 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;
+
+  if (0 == memcmp (&pc->id, peer, sizeof (struct GNUNET_PeerIdentity)))
+    return;
+  pc->connect_status = 0;
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Encrypted connection to `%4s' cut\n",
+              GNUNET_i2s (peer));

 }
 
 
 static int
 }
 
 
 static int

-inbound_notify (void *cls,
-                const struct GNUNET_PeerIdentity *other,
+inbound_notify (void *cls, const struct GNUNET_PeerIdentity *other,

                 const struct GNUNET_MessageHeader *message,
                 const struct GNUNET_MessageHeader *message,

-               struct GNUNET_TIME_Relative latency,
-               uint32_t distance)
+                const struct GNUNET_ATS_Information *atsi,
+                unsigned int atsi_count)

 {
   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));


@@ -144,11 +218,10 @@ inbound_notify (void *cls,
 
 
 static int
 
 
 static int

-outbound_notify (void *cls,
-                 const struct GNUNET_PeerIdentity *other,
+outbound_notify (void *cls, const struct GNUNET_PeerIdentity *other,

                  const struct GNUNET_MessageHeader *message,
                  const struct GNUNET_MessageHeader *message,

-                struct GNUNET_TIME_Relative latency,
-                uint32_t distance)
+                 const struct GNUNET_ATS_Information *atsi,
+                 unsigned int atsi_count)

 {
   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",


@@ -157,22 +230,19 @@ outbound_notify (void *cls,
 }
 
 
 }
 
 

-static GNUNET_SCHEDULER_TaskIdentifier err_task;
-

 
 static int
 
 static int

-process_mtype (void *cls,
-               const struct GNUNET_PeerIdentity *peer,
+process_mtype (void *cls, const struct GNUNET_PeerIdentity *peer,

                const struct GNUNET_MessageHeader *message,
                const struct GNUNET_MessageHeader *message,

-              struct GNUNET_TIME_Relative latency,
-              uint32_t distance)
+               const struct GNUNET_ATS_Information *atsi,
+               unsigned int atsi_count)

 {
 {

-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Receiving message from `%4s'.\n", GNUNET_i2s (peer));
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Receiving message from `%4s'.\n",
+              GNUNET_i2s (peer));

   GNUNET_assert (ok == 5);
   OKPP;
   GNUNET_assert (ok == 5);
   OKPP;

-  GNUNET_SCHEDULER_cancel (sched, err_task);
-  GNUNET_SCHEDULER_add_now (sched, &terminate_task, NULL);
+  GNUNET_SCHEDULER_cancel (err_task);
+  err_task = GNUNET_SCHEDULER_add_now (&terminate_task, NULL);

   return GNUNET_OK;
 }
 
   return GNUNET_OK;
 }
 


@@ -183,186 +253,124 @@ static struct GNUNET_CORE_MessageHandler handlers[] = {
 };
 
 
 };
 
 

-static size_t
-transmit_ready (void *cls, size_t size, void *buf)
+static void
+connect_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)

 {
 {

-  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_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 120), &terminate_task_error, NULL);
-
-  return sizeof (struct GNUNET_MessageHeader);
+  if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN))
+  {
+    con_task = GNUNET_SCHEDULER_NO_TASK;
+    return;
+  }
+  con_task =
+      GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS, &connect_task,
+                                    NULL);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Asking transport (1) to connect to peer `%4s'\n",
+              GNUNET_i2s (&p2.id));
+  GNUNET_TRANSPORT_try_connect (p1.th, &p2.id, NULL, NULL); /*FIXME TRY_CONNECT change */

 }
 
 
 }
 
 

-

 static void
 static void

-init_notify (void *cls,
-             struct GNUNET_CORE_Handle *server,
-             const struct GNUNET_PeerIdentity *my_identity,
-             const struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *publicKey)
+init_notify (void *cls, struct GNUNET_CORE_Handle *server,
+             const struct GNUNET_PeerIdentity *my_identity)

 {
   struct PeerContext *p = cls;
 
 {
   struct PeerContext *p = cls;
 

-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Core connection to `%4s' established\n",
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Core connection to `%4s' established\n",

               GNUNET_i2s (my_identity));
   GNUNET_assert (server != NULL);
   p->id = *my_identity;
   p->ch = server;
   if (cls == &p1)
               GNUNET_i2s (my_identity));
   GNUNET_assert (server != NULL);
   p->id = *my_identity;
   p->ch = server;
   if (cls == &p1)

-    {
-      GNUNET_assert (ok == 2);
-      OKPP;
-      /* connect p2 */
-      GNUNET_CORE_connect (sched,
-                           p2.cfg,
-                           TIMEOUT,
-                           &p2,
-                           &init_notify,
-                          NULL,
-                           &connect_notify,
-                           &disconnect_notify,
-                           &inbound_notify,
-                           GNUNET_YES,
-                           &outbound_notify, GNUNET_YES, handlers);
-    }
+  {
+    GNUNET_assert (ok == 2);
+    OKPP;
+    /* connect p2 */
+    p2.ch =
+        GNUNET_CORE_connect (p2.cfg, &p2, &init_notify, &connect_notify,
+                             &disconnect_notify, &inbound_notify, GNUNET_YES,
+                             &outbound_notify, GNUNET_YES, handlers);
+  }

   else
   else

-    {
-      GNUNET_assert (ok == 3);
-      OKPP;
-      GNUNET_assert (cls == &p2);
-      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,
-                                         0,
-                                         GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 15),
-                                         &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 void
-process_hello (void *cls,
-               const struct GNUNET_MessageHeader *message)
-{
-  struct PeerContext *p = cls;
-
-  GNUNET_TRANSPORT_get_hello_cancel (p->th, &process_hello, p);
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "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_TRANSPORT_offer_hello (p2.th, message);
-  if ((p == &p2) && (p1.th != NULL))
-    GNUNET_TRANSPORT_offer_hello (p1.th, message);
-
-  if ((p == &p1) && (p2.hello != NULL))
-    GNUNET_TRANSPORT_offer_hello (p1.th, p2.hello);
-  if ((p == &p2) && (p1.hello != NULL))
-    GNUNET_TRANSPORT_offer_hello (p2.th, p1.hello);
+  {
+    GNUNET_assert (ok == 3);
+    OKPP;
+    GNUNET_assert (cls == &p2);
+    con_task = GNUNET_SCHEDULER_add_now (&connect_task, NULL);
+  }

 }
 
 
 }
 
 

-

 static void
 setup_peer (struct PeerContext *p, const char *cfgname)
 {
 static void
 setup_peer (struct PeerContext *p, const char *cfgname)
 {

+  char *binary;
+
+  binary = GNUNET_OS_get_libexec_binary_path ("gnunet-service-arm");

   p->cfg = GNUNET_CONFIGURATION_create ();
   p->cfg = GNUNET_CONFIGURATION_create ();

-#if START_ARM
-  p->arm_pid = GNUNET_OS_start_process ("gnunet-service-arm",
-                                        "gnunet-service-arm",
-#if VERBOSE
-                                        "-L", "DEBUG",
-#endif
-                                        "-c", cfgname, NULL);
-#endif
+  p->arm_proc =
+    GNUNET_OS_start_process (GNUNET_YES, GNUNET_OS_INHERIT_STD_OUT_AND_ERR, 
+                            NULL, NULL, 
+                            binary,
+                            "gnunet-service-arm",
+                               "-c", cfgname, NULL);

   GNUNET_assert (GNUNET_OK == GNUNET_CONFIGURATION_load (p->cfg, cfgname));
   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, &process_hello, p);
+  p->ghh = GNUNET_TRANSPORT_get_hello (p->th, &process_hello, p);
+  GNUNET_free (binary);

 }
 
 
 static void
 }
 
 
 static void

-run (void *cls,
-     struct GNUNET_SCHEDULER_Handle *s,
-     char *const *args,
-     const char *cfgfile,
+run (void *cls, char *const *args, const char *cfgfile,

      const struct GNUNET_CONFIGURATION_Handle *cfg)
 {
   GNUNET_assert (ok == 1);
   OKPP;
      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,
-                       &p1,
-                       &init_notify,
-                      NULL,
-                       &connect_notify,
-                       &disconnect_notify,
-                       &inbound_notify,
-                       GNUNET_YES, &outbound_notify, GNUNET_YES, handlers);
+  err_task =
+      GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply
+                                    (GNUNET_TIME_UNIT_SECONDS, 300),
+                                    &terminate_task_error, NULL);
+  p1.ch =
+      GNUNET_CORE_connect (p1.cfg, &p1, &init_notify, &connect_notify,
+                           &disconnect_notify, &inbound_notify, GNUNET_YES,
+                           &outbound_notify, GNUNET_YES, handlers);

 }
 
 
 static void
 stop_arm (struct PeerContext *p)
 {
 }
 
 
 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_strerror (GNUNET_ERROR_TYPE_WARNING, "waitpid");

-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "ARM process %u stopped\n", p->arm_pid);
-#endif
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "ARM process %u stopped\n",
+              GNUNET_OS_process_get_pid (p->arm_proc));
+  GNUNET_OS_process_destroy (p->arm_proc);
+  p->arm_proc = NULL;

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

+

 static int
 check ()
 {
   char *const argv[] = { "test-core-api",
     "-c",
     "test_core_api_data.conf",
 static int
 check ()
 {
   char *const argv[] = { "test-core-api",
     "-c",
     "test_core_api_data.conf",

-#if VERBOSE
-    "-L", "DEBUG",
-#endif

     NULL
   };
   struct GNUNET_GETOPT_CommandLineOption options[] = {
     GNUNET_GETOPT_OPTION_END
   };
   ok = 1;
     NULL
   };
   struct GNUNET_GETOPT_CommandLineOption options[] = {
     GNUNET_GETOPT_OPTION_END
   };
   ok = 1;

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

   stop_arm (&p1);
   stop_arm (&p2);
   return ok;
   stop_arm (&p1);
   stop_arm (&p2);
   return ok;


@@ -374,14 +382,10 @@ main (int argc, char *argv[])
   int ret;
 
   GNUNET_log_setup ("test-core-api",
   int ret;
 
   GNUNET_log_setup ("test-core-api",

-#if VERBOSE
-                    "DEBUG",
-#else

                     "WARNING",
                     "WARNING",

-#endif

                     NULL);
   ret = check ();
                     NULL);
   ret = check ();

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

   GNUNET_DISK_directory_remove ("/tmp/test-gnunet-core-peer-2");
 
   return ret;
   GNUNET_DISK_directory_remove ("/tmp/test-gnunet-core-peer-2");
 
   return ret;