Don't shadow the system() function

[oweals/gnunet.git] / src / util / test_service.c

diff --git a/src/util/test_service.c b/src/util/test_service.c
index e9070a912191d68fa9a86d36efd30f5a8a71340d..2c5ee467274ef24274fca127976451ce5bdfb22f 100644 (file)
--- a/src/util/test_service.c
+++ b/src/util/test_service.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)
+     Copyright (C) 2009, 2013 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,110 +20,115 @@
 /**
  * @file util/test_service.c
  * @brief tests for service.c
 /**
  * @file util/test_service.c
  * @brief tests for service.c

+ * @author Christian Grothoff

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

-#include "gnunet_common.h"
-#include "gnunet_client_lib.h"
-#include "gnunet_getopt_lib.h"
-#include "gnunet_program_lib.h"
-#include "gnunet_service_lib.h"
-#include "gnunet_scheduler_lib.h"
-#include "gnunet_time_lib.h"
+#include "gnunet_util_lib.h"

 
 

-#define VERBOSE GNUNET_NO

 
 #define PORT 12435
 
 
 #define PORT 12435
 

+/**
+ * Message type we use for testing.
+ */

 #define MY_TYPE 256
 
 #define MY_TYPE 256
 

-static struct GNUNET_SCHEDULER_Handle *sched;
-

 static struct GNUNET_SERVICE_Context *sctx;
 
 static struct GNUNET_SERVICE_Context *sctx;
 

+static int ok = 1;
+
+static struct GNUNET_CLIENT_Connection *client;
+
+

 static void
 static void

-end_it (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+do_stop (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)

 {
 {

-  struct GNUNET_CLIENT_Connection *client = cls;
-
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Shutting down service\n");
-  GNUNET_CLIENT_service_shutdown (client);
-  GNUNET_CLIENT_disconnect (client);
-  if (sctx != NULL)
+  if (NULL != client)
+  {
+    GNUNET_CLIENT_disconnect (client);
+    client = NULL;
+  }
+  if (NULL != sctx)
+  {

     GNUNET_SERVICE_stop (sctx);
     GNUNET_SERVICE_stop (sctx);

+    sctx = NULL;
+  }
+  else
+  {
+    GNUNET_SCHEDULER_shutdown ();
+  }

 }
 
 
 static size_t
 build_msg (void *cls, size_t size, void *buf)
 {
 }
 
 
 static size_t
 build_msg (void *cls, size_t size, void *buf)
 {

-  struct GNUNET_CLIENT_Connection *client = cls;

   struct GNUNET_MessageHeader *msg = buf;
 
   struct GNUNET_MessageHeader *msg = buf;
 

+  if (size < sizeof (struct GNUNET_MessageHeader))
+  {
+    /* timeout */
+    GNUNET_break (0);
+    GNUNET_SCHEDULER_add_now (&do_stop, NULL);
+    ok = 1;
+    return 0;
+  }
+

   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Client connected, transmitting\n");
   GNUNET_assert (size >= sizeof (struct GNUNET_MessageHeader));
   msg->type = htons (MY_TYPE);
   msg->size = htons (sizeof (struct GNUNET_MessageHeader));
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Client connected, transmitting\n");
   GNUNET_assert (size >= sizeof (struct GNUNET_MessageHeader));
   msg->type = htons (MY_TYPE);
   msg->size = htons (sizeof (struct GNUNET_MessageHeader));

-  GNUNET_SCHEDULER_add_continuation (sched,
-                                     GNUNET_YES,
-                                     &end_it,
-                                     client,
-                                     GNUNET_SCHEDULER_REASON_PREREQ_DONE);

   return sizeof (struct GNUNET_MessageHeader);
 }
 
   return sizeof (struct GNUNET_MessageHeader);
 }
 

+

 static void
 static void

-ready (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+ready (void *cls,
+       int result)

 {
   const struct GNUNET_CONFIGURATION_Handle *cfg = cls;
 {
   const struct GNUNET_CONFIGURATION_Handle *cfg = cls;

-  struct GNUNET_CLIENT_Connection *client;

 
 

+  GNUNET_assert (GNUNET_YES == result);

   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Service confirmed running\n");
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Service confirmed running\n");

-  sched = tc->sched;
-  GNUNET_assert (0 != (tc->reason & GNUNET_SCHEDULER_REASON_PREREQ_DONE));
-  client = GNUNET_CLIENT_connect (tc->sched, "test_service", cfg);
+  client = GNUNET_CLIENT_connect ("test_service", cfg);

   GNUNET_assert (client != NULL);
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "Client connecting, waiting to transmit\n");
   GNUNET_CLIENT_notify_transmit_ready (client,
                                        sizeof (struct GNUNET_MessageHeader),
   GNUNET_assert (client != NULL);
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "Client connecting, waiting to transmit\n");
   GNUNET_CLIENT_notify_transmit_ready (client,
                                        sizeof (struct GNUNET_MessageHeader),

-                                       GNUNET_TIME_UNIT_SECONDS,
-                                       &build_msg, client);
+                                       GNUNET_TIME_UNIT_SECONDS, GNUNET_NO,
+                                       &build_msg, NULL);

 }
 
 }
 

+

 static void
 static void

-recv_cb (void *cls,
-         struct GNUNET_SERVER_Client *client,
+recv_cb (void *cls, struct GNUNET_SERVER_Client *sc,

          const struct GNUNET_MessageHeader *message)
 {
          const struct GNUNET_MessageHeader *message)
 {

+  GNUNET_assert (NULL != message);

   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Receiving client message...\n");
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Receiving client message...\n");

-  GNUNET_SERVER_receive_done (client, GNUNET_OK);
+  GNUNET_SERVER_receive_done (sc, GNUNET_OK);
+  GNUNET_SCHEDULER_add_now (&do_stop, NULL);
+  ok = 0;

 }
 
 }
 

+

 static struct GNUNET_SERVER_MessageHandler myhandlers[] = {
   {&recv_cb, NULL, MY_TYPE, sizeof (struct GNUNET_MessageHeader)},
   {NULL, NULL, 0, 0}
 };
 
 static struct GNUNET_SERVER_MessageHandler myhandlers[] = {
   {&recv_cb, NULL, MY_TYPE, sizeof (struct GNUNET_MessageHeader)},
   {NULL, NULL, 0, 0}
 };
 

+

 static void
 static void

-runner (void *cls,
-        struct GNUNET_SCHEDULER_Handle *sched,
-        struct GNUNET_SERVER_Handle *server,
+runner (void *cls, struct GNUNET_SERVER_Handle *server,

         const struct GNUNET_CONFIGURATION_Handle *cfg)
 {
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Service initializing\n");
   GNUNET_SERVER_add_handlers (server, myhandlers);
         const struct GNUNET_CONFIGURATION_Handle *cfg)
 {
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Service initializing\n");
   GNUNET_SERVER_add_handlers (server, myhandlers);

-  GNUNET_CLIENT_service_test (sched,
-                              "test_service",
-                              cfg, GNUNET_TIME_UNIT_SECONDS, &ready, (void*) cfg);
+  GNUNET_CLIENT_service_test ("test_service", cfg, GNUNET_TIME_UNIT_SECONDS,
+                              &ready, (void *) cfg);

 }
 
 }
 

-static void
-term (void *cls, 
-      const struct GNUNET_CONFIGURATION_Handle *cfg)
-{
-  int *ok = cls;
-  *ok = 0;
-}

 
 /**
  * Main method, starts scheduler with task1,
 
 /**
  * Main method, starts scheduler with task1,


@@ -132,60 +137,51 @@ term (void *cls,
 static int
 check ()
 {
 static int
 check ()
 {

-  int ok = 1;
+  ok = 1;

   char *const argv[] = {
     "test_service",
     "-c",
     "test_service_data.conf",
   char *const argv[] = {
     "test_service",
     "-c",
     "test_service_data.conf",

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

     NULL
   };
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Starting service\n");
   GNUNET_assert (GNUNET_OK ==
     NULL
   };
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Starting service\n");
   GNUNET_assert (GNUNET_OK ==

-                 GNUNET_SERVICE_run (5,
-                                     argv,
-                                     "test_service",
-                                     &runner, &ok, &term, &ok));
+                 GNUNET_SERVICE_run (3, argv, "test_service",
+                                     GNUNET_SERVICE_OPTION_NONE, &runner, &ok));

   GNUNET_assert (0 == ok);
   return ok;
 }
 
   GNUNET_assert (0 == ok);
   return ok;
 }
 

+

 static void
 static void

-ready6 (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+ready6 (void *cls,
+       int result)

 {
   const struct GNUNET_CONFIGURATION_Handle *cfg = cls;
 {
   const struct GNUNET_CONFIGURATION_Handle *cfg = cls;

-  struct GNUNET_CLIENT_Connection *client;

 
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "V6 ready\n");
 
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "V6 ready\n");

-  sched = tc->sched;
-  GNUNET_assert (0 != (tc->reason & GNUNET_SCHEDULER_REASON_PREREQ_DONE));
-  client = GNUNET_CLIENT_connect (tc->sched, "test_service6", cfg);
+  GNUNET_assert (GNUNET_YES == result);
+  client = GNUNET_CLIENT_connect ("test_service6", cfg);

   GNUNET_assert (client != NULL);
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "V6 client connected\n");
   GNUNET_CLIENT_notify_transmit_ready (client,
                                        sizeof (struct GNUNET_MessageHeader),
   GNUNET_assert (client != NULL);
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "V6 client connected\n");
   GNUNET_CLIENT_notify_transmit_ready (client,
                                        sizeof (struct GNUNET_MessageHeader),

-                                       GNUNET_TIME_UNIT_SECONDS,
-                                       &build_msg, client);
+                                       GNUNET_TIME_UNIT_SECONDS, GNUNET_NO,
+                                       &build_msg, NULL);

 }
 
 }
 

+

 static void
 static void

-runner6 (void *cls,
-         struct GNUNET_SCHEDULER_Handle *sched,
-         struct GNUNET_SERVER_Handle *server,
+runner6 (void *cls, struct GNUNET_SERVER_Handle *server,

          const struct GNUNET_CONFIGURATION_Handle *cfg)
 {
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Initializing v6 service\n");
   GNUNET_SERVER_add_handlers (server, myhandlers);
          const struct GNUNET_CONFIGURATION_Handle *cfg)
 {
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Initializing v6 service\n");
   GNUNET_SERVER_add_handlers (server, myhandlers);

-  GNUNET_CLIENT_service_test (sched,
-                              "test_service6",
-                              cfg, GNUNET_TIME_UNIT_SECONDS, &ready6, (void*) cfg);
+  GNUNET_CLIENT_service_test ("test_service6", cfg, GNUNET_TIME_UNIT_SECONDS,
+                              &ready6, (void *) cfg);

 }
 
 }
 

+

 /**
  * Main method, starts scheduler with task1,
  * checks that "ok" is correct at the end.
 /**
  * Main method, starts scheduler with task1,
  * checks that "ok" is correct at the end.


@@ -193,74 +189,32 @@ runner6 (void *cls,
 static int
 check6 ()
 {
 static int
 check6 ()
 {

-  int ok = 1;

   char *const argv[] = {
     "test_service6",
     "-c",
     "test_service_data.conf",
   char *const argv[] = {
     "test_service6",
     "-c",
     "test_service_data.conf",

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

     NULL
   };
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Starting v6 service\n");
   GNUNET_assert (GNUNET_OK ==
     NULL
   };
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Starting v6 service\n");
   GNUNET_assert (GNUNET_OK ==

-                 GNUNET_SERVICE_run (5,
-                                     argv,
-                                     "test_service6",
-                                     &runner6, &ok, &term, &ok));
+                 GNUNET_SERVICE_run (3, argv, "test_service6",
+                                     GNUNET_SERVICE_OPTION_NONE, &runner6,
+                                     &ok));

   GNUNET_assert (0 == ok);
   return ok;
 }
 
 
   GNUNET_assert (0 == ok);
   return ok;
 }
 
 

-/**
- * Main method, starts scheduler with task1,
- * checks that "ok" is correct at the end.
- */
-static int
-check6d ()
-{
-  int ok = 1;
-  char *const argv[] = {
-    "test_service6",
-    "-c",
-    "test_service_data.conf",
-    "-L",
-#if VERBOSE
-    "DEBUG",
-#else
-    "WARNING",
-#endif
-    "-d",
-    NULL
-  };
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Starting V6 as daemon\n");
-  GNUNET_assert (GNUNET_OK ==
-                 GNUNET_SERVICE_run (6,
-                                     argv,
-                                     "test_service6",
-                                     &runner6, &ok, &term, &ok));
-  GNUNET_break (0 == ok);
-  return ok;
-}
-
-

 static void
 static void

-start_stop_main (void *cls,
-                 struct GNUNET_SCHEDULER_Handle *sched,
-                 char *const *args,
-                 const char *cfgfile, 
-                const struct GNUNET_CONFIGURATION_Handle *cfg)
+start_stop_main (void *cls, char *const *args, const char *cfgfile,
+                 const struct GNUNET_CONFIGURATION_Handle *cfg)

 {
   int *ret = cls;
 {
   int *ret = cls;

-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Starting service using start method\n");
-  sctx = GNUNET_SERVICE_start ("test_service", sched, cfg);
-  runner (cls, sched, GNUNET_SERVICE_get_server (sctx), cfg);
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Starting service using start method\n");
+  sctx = GNUNET_SERVICE_start ("test_service", cfg, GNUNET_SERVICE_OPTION_NONE);
+  GNUNET_assert (NULL != sctx);
+  runner (cls, GNUNET_SERVICE_get_server (sctx), cfg);

   *ret = 0;
 }
 
   *ret = 0;
 }
 


@@ -272,23 +226,15 @@ check_start_stop ()
     "test-service-program",
     "-c",
     "test_service_data.conf",
     "test-service-program",
     "-c",
     "test_service_data.conf",

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

     NULL
   };
   const struct GNUNET_GETOPT_CommandLineOption options[] = {
     GNUNET_GETOPT_OPTION_END
   };
   int ret = 1;
     NULL
   };
   const struct GNUNET_GETOPT_CommandLineOption options[] = {
     GNUNET_GETOPT_OPTION_END
   };
   int ret = 1;

+

   GNUNET_assert (GNUNET_OK ==
   GNUNET_assert (GNUNET_OK ==

-                 GNUNET_PROGRAM_run (5,
-                                     argv,
-                                     "test-service-program",
-                                     "no help",
+                 GNUNET_PROGRAM_run (3, argv, "test-service-program", "no help",

                                      options, &start_stop_main, &ret));
 
   GNUNET_break (0 == ret);
                                      options, &start_stop_main, &ret));
 
   GNUNET_break (0 == ret);


@@ -300,38 +246,35 @@ int
 main (int argc, char *argv[])
 {
   int ret = 0;
 main (int argc, char *argv[])
 {
   int ret = 0;

-  struct GNUNET_NETWORK_Handle *s;
+  struct GNUNET_NETWORK_Handle *s = NULL;

 
   GNUNET_log_setup ("test-service",
 
   GNUNET_log_setup ("test-service",

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

                     "WARNING",
                     "WARNING",

-#endif

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

-  s = GNUNET_NETWORK_socket_socket (PF_INET6, SOCK_STREAM, 0);
+  // FIXME
+#ifndef MINGW
+  s = GNUNET_NETWORK_socket_create (PF_INET6, SOCK_STREAM, 0);
+#endif

   if (NULL == s)
   if (NULL == s)

+  {
+    if ((errno == ENOBUFS) || (errno == ENOMEM) || (errno == ENFILE) ||
+        (errno == EACCES))

     {
     {

-      if ((errno == ENOBUFS) ||
-          (errno == ENOMEM) || (errno == ENFILE) || (errno == EACCES))
-        {
-          GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "socket");
-          return 1;
-        }
-      fprintf (stderr,
-               "IPv6 support seems to not be available (%s), not testing it!\n",
-               strerror (errno));
+      GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "socket");
+      return 1;

     }
     }

+    FPRINTF (stderr,
+             "IPv6 support seems to not be available (%s), not testing it!\n",
+             strerror (errno));
+  }

   else
   else

-    {
-      GNUNET_break (GNUNET_OK == GNUNET_NETWORK_socket_close (s));
-      ret += check6 ();
-      ret += check6d ();        /* with daemonization */
-    }
+  {
+    GNUNET_break (GNUNET_OK == GNUNET_NETWORK_socket_close (s));
+    ret += check6 ();
+  }

   ret += check_start_stop ();
   ret += check_start_stop ();

-

   return ret;
 }
 
   return ret;
 }