X-Git-Url: https://git.librecmc.org/?a=blobdiff_plain;f=src%2Fcore%2Ftest_core_api_send_to_self.c;h=5cfc8b35f780ed668ebb5054b07e0eca760c317b;hb=4b766fd267ca83a8faa4e22353d5942074d6f2b7;hp=4346acbd78fbf057c5ce98793b9f9d670a158366;hpb=18357100980d3ca6c417bfb975a57b13c6d1263d;p=oweals%2Fgnunet.git

diff --git a/src/core/test_core_api_send_to_self.c b/src/core/test_core_api_send_to_self.c
index 4346acbd7..5cfc8b35f 100644
--- a/src/core/test_core_api_send_to_self.c
+++ b/src/core/test_core_api_send_to_self.c
@@ -1,6 +1,6 @@
 /*
      This file is part of GNUnet.
-     (C) 2010 Christian Grothoff
+     Copyright (C) 2010, 2016 GNUnet e.V.
 
      GNUnet is free software; you can redistribute it and/or modify
      it under the terms of the GNU General Public License as published
@@ -14,21 +14,22 @@
 
      You should have received a copy of the GNU General Public License
      along with GNUnet; see the file COPYING.  If not, write to the
-     Free Software Foundation, Inc., 59 Temple Place - Suite 330,
-     Boston, MA 02111-1307, USA.
+     Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+     Boston, MA 02110-1301, USA.
 */
 
 /**
  * @file core/test_core_api_send_to_self.c
- * @brief
+ * @brief test that sending a message to ourselves via CORE works
  * @author Philipp Toelke
+ * @author Christian Grothoff
  */
-#include <platform.h>
-#include <gnunet_common.h>
-#include <gnunet_program_lib.h>
-#include <gnunet_protocols.h>
-#include <gnunet_core_service.h>
-#include <gnunet_constants.h>
+#include "platform.h"
+#include "gnunet_util_lib.h"
+#include "gnunet_testing_lib.h"
+#include "gnunet_protocols.h"
+#include "gnunet_core_service.h"
+#include "gnunet_constants.h"
 
 /**
  * Final status code.
@@ -38,115 +39,103 @@ static int ret;
 /**
  * Handle to the cleanup task.
  */
-GNUNET_SCHEDULER_TaskIdentifier die_task;
-
-static struct GNUNET_PeerIdentity myself;
+static struct GNUNET_SCHEDULER_Task *die_task;
 
 /**
- * Configuration to load for the new peer.
+ * Identity of this peer.
  */
-struct GNUNET_CONFIGURATION_Handle *core_cfg;
+static struct GNUNET_PeerIdentity myself;
 
 /**
  * The handle to core
  */
-struct GNUNET_CORE_Handle *core;
+static struct GNUNET_CORE_Handle *core;
 
-/**
- * Handle to gnunet-service-arm.
- */
-struct GNUNET_OS_Process *arm_proc;
 
 /**
  * Function scheduled as very last function, cleans up after us
  */
 static void
-cleanup (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tskctx)
+cleanup (void *cls)
 {
-  die_task = GNUNET_SCHEDULER_NO_TASK;
-
-  if (core != NULL)
+  if (NULL != die_task)
+  {
+    GNUNET_SCHEDULER_cancel (die_task);
+    die_task = NULL;
+  }
+  if (NULL != core)
   {
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Disconnecting core.\n");
     GNUNET_CORE_disconnect (core);
     core = NULL;
   }
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Ending test.\n");
+}
 
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Stopping peer\n");
-  if (0 != GNUNET_OS_process_kill (arm_proc, SIGTERM))
-    GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "kill");
-
-  if (GNUNET_OS_process_wait (arm_proc) != GNUNET_OK)
-    GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "waitpid");
-
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "ARM process %u stopped\n",
-              GNUNET_OS_process_get_pid (arm_proc));
-  GNUNET_OS_process_close (arm_proc);
-  arm_proc = NULL;
 
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Ending test.\n");
+/**
+ * Function scheduled as very last function, cleans up after us
+ */
+static void
+do_timeout (void *cls)
+{
+  GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+              "Test timeout.\n");
+  die_task = NULL;
+  GNUNET_SCHEDULER_shutdown ();
 }
 
-static int
-receive (void *cls, const struct GNUNET_PeerIdentity *other,
-         const struct GNUNET_MessageHeader *message,
-         const struct GNUNET_ATS_Information *atsi, unsigned int atsi_count)
+
+static void
+handle_test (void *cls,
+	     const struct GNUNET_MessageHeader *message)
 {
-  if (die_task != GNUNET_SCHEDULER_NO_TASK)
-    GNUNET_SCHEDULER_cancel (die_task);
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Received message from peer %s\n",
-              GNUNET_i2s (other));
-  GNUNET_SCHEDULER_add_now (&cleanup, NULL);
+  GNUNET_SCHEDULER_shutdown ();
   ret = 0;
-  return GNUNET_OK;
 }
 
-static size_t
-send_message (void *cls, size_t size, void *buf)
-{
-  if (size == 0 || buf == NULL)
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Could not send; got 0 buffer\n");
-    return 0;
-  }
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sending!\n");
-  struct GNUNET_MessageHeader *hdr = buf;
-
-  hdr->size = htons (sizeof (struct GNUNET_MessageHeader));
-  hdr->type = htons (GNUNET_MESSAGE_TYPE_VPN_UDP_TO_SERVICE);
-  return ntohs (hdr->size);
-}
 
 static void
-init (void *cls, struct GNUNET_CORE_Handle *core,
+init (void *cls,
       const struct GNUNET_PeerIdentity *my_identity)
 {
-  if (core == NULL)
+  if (NULL == my_identity)
   {
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Could NOT connect to CORE;\n");
+    GNUNET_break (0);
     return;
   }
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "Correctly connected to CORE; we are the peer %s.\n",
               GNUNET_i2s (my_identity));
-  memcpy (&myself, my_identity, sizeof (struct GNUNET_PeerIdentity));
+  GNUNET_memcpy (&myself,
+		 my_identity,
+		 sizeof (struct GNUNET_PeerIdentity));
 }
 
-static void
-connect_cb (void *cls, const struct GNUNET_PeerIdentity *peer,
-            const struct GNUNET_ATS_Information *atsi, unsigned int atsi_count)
+
+static void *
+connect_cb (void *cls,
+            const struct GNUNET_PeerIdentity *peer,
+	    struct GNUNET_MQ_Handle *mq)
 {
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Connected to peer %s.\n",
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Connected to peer %s.\n",
               GNUNET_i2s (peer));
-  if (0 == memcmp (peer, &myself, sizeof (struct GNUNET_PeerIdentity)))
+  if (0 == memcmp (peer,
+                   &myself,
+                   sizeof (struct GNUNET_PeerIdentity)))
   {
+    struct GNUNET_MQ_Envelope *env;
+    struct GNUNET_MessageHeader *msg;
+
     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                 "Connected to myself; sending message!\n");
-    GNUNET_CORE_notify_transmit_ready (core, GNUNET_YES, 0,
-                                       GNUNET_TIME_UNIT_FOREVER_REL, peer,
-                                       sizeof (struct GNUNET_MessageHeader),
-                                       send_message, NULL);
+    env = GNUNET_MQ_msg (msg,
+			 GNUNET_MESSAGE_TYPE_DUMMY);
+    GNUNET_MQ_send (mq,
+		    env);
   }
+  return NULL;
 }
 
 
@@ -154,71 +143,38 @@ connect_cb (void *cls, const struct GNUNET_PeerIdentity *peer,
  * Main function that will be run by the scheduler.
  *
  * @param cls closure
- * @param args remaining command-line arguments
- * @param cfgfile name of the configuration file used (for saving, can be NULL!)
  * @param cfg configuration
  */
 static void
-run (void *cls, char *const *args, const char *cfgfile,
-     const struct GNUNET_CONFIGURATION_Handle *cfg)
+run (void *cls,
+     const struct GNUNET_CONFIGURATION_Handle *cfg,
+     struct GNUNET_TESTING_Peer *peer)
 {
-  const static struct GNUNET_CORE_MessageHandler handlers[] = {
-    {&receive, GNUNET_MESSAGE_TYPE_VPN_UDP_TO_SERVICE, 0},
-    {NULL, 0, 0}
+  struct GNUNET_MQ_MessageHandler handlers[] = {
+    GNUNET_MQ_hd_fixed_size (test,
+                             GNUNET_MESSAGE_TYPE_DUMMY,
+                             struct GNUNET_MessageHeader,
+                             NULL),
+    GNUNET_MQ_handler_end ()
   };
 
-  core_cfg = GNUNET_CONFIGURATION_create ();
-
-  arm_proc =
-      GNUNET_OS_start_process (NULL, NULL, "gnunet-service-arm",
-                               "gnunet-service-arm",
-#if VERBOSE
-                               "-L", "DEBUG",
-#endif
-                               "-c", "test_core_api_peer1.conf", NULL);
-
-  GNUNET_assert (GNUNET_OK ==
-                 GNUNET_CONFIGURATION_load (core_cfg,
-                                            "test_core_api_peer1.conf"));
-
   core =
-      GNUNET_CORE_connect (core_cfg, 42, NULL, &init, &connect_cb, NULL, NULL,
-                           0, NULL, 0, handlers);
-
-  die_task =
-      GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply
-                                    (GNUNET_TIME_UNIT_SECONDS, 60), &cleanup,
-                                    cls);
+    GNUNET_CORE_connect (cfg,
+			 NULL,
+			 &init,
+                         &connect_cb,
+			 NULL,
+			 handlers);
+  GNUNET_SCHEDULER_add_shutdown (&cleanup,
+                                 NULL);
+  die_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_MINUTES,
+                                           &do_timeout,
+                                           NULL);
 }
 
 
-static int
-check ()
-{
-  char *const argv[] = { "test-core-api-send-to-self",
-    "-c",
-    "test_core_api_data.conf",
-#if VERBOSE
-    "-L", "DEBUG",
-#endif
-    NULL
-  };
-
-  static const struct GNUNET_GETOPT_CommandLineOption options[] = {
-    GNUNET_GETOPT_OPTION_END
-  };
-
-  ret = 1;
-
-  return (GNUNET_OK ==
-          GNUNET_PROGRAM_run ((sizeof (argv) / sizeof (char *)) - 1, argv,
-                              "test_core_api_send_to_self",
-                              gettext_noop ("help text"), options, &run,
-                              NULL)) ? ret : 1;
-}
-
 /**
- * The main function to obtain template from gnunetd.
+ * The main function to test sending a message to the local peer via core
  *
  * @param argc number of arguments from the command line
  * @param argv command line arguments
@@ -227,15 +183,11 @@ check ()
 int
 main (int argc, char *argv[])
 {
-  GNUNET_log_setup ("test-core-api-send-to-self",
-#if VERBOSE
-                    "DEBUG",
-#else
-                    "WARNING",
-#endif
-                    NULL);
-  ret = check ();
-  GNUNET_DISK_directory_remove ("/tmp/test-gnunet-core-peer-1");
+  ret = 1;
+  if (0 != GNUNET_TESTING_peer_run ("test-core-api-send-to-self",
+				    "test_core_api_peer1.conf",
+				    &run, NULL))
+    return 1;
   return ret;
 }