fixes

diff --git a/src/arm/gnunet-service-arm.c b/src/arm/gnunet-service-arm.c
index f38b6b0449f422b98fb264e8424bce1356710805..71a2aa4465f279c47452a78c7e6dd40fdd0d27aa 100644 (file)
--- a/src/arm/gnunet-service-arm.c
+++ b/src/arm/gnunet-service-arm.c
@@ -749,6 +749,7 @@ shutdown_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 #if DEBUG_ARM
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, _("Stopping all services\n"));
 #endif
+  stop_listening (NULL);
   in_shutdown = GNUNET_YES;
   pos = running;
   while (NULL != pos)

diff --git a/src/arm/gnunet-service-manager.c b/src/arm/gnunet-service-manager.c
index c80c12aa5cabfc56f5f0290c056eb9e98af64483..a632fea490a32f66adcbd5a49b8b1cb26f72d471 100644 (file)
--- a/src/arm/gnunet-service-manager.c
+++ b/src/arm/gnunet-service-manager.c
@@ -1,6 +1,6 @@
 /*
      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
@@ -176,26 +176,28 @@ isInDefaultList (const char *serviceName)
 static void
 closeClientAndServiceSockets (struct ForwardedConnection *fc, int reason)
 {
-  if (NULL != fc->armClientSocket)
+  if ( (0 != (REASON_SERVICE & reason)) &&
+       (fc->clientReceivingTask != GNUNET_SCHEDULER_NO_TASK) )
     {
-      if (0 != (REASON_SERVICE & reason))
-       GNUNET_SCHEDULER_cancel (scheduler, fc->clientReceivingTask);
-      if (GNUNET_SYSERR ==
-         GNUNET_NETWORK_socket_close (fc->armClientSocket))
-       GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "close");
-      fc->armClientSocket = NULL;
+      GNUNET_SCHEDULER_cancel (scheduler, fc->clientReceivingTask);    
+      fc->clientReceivingTask = GNUNET_SCHEDULER_NO_TASK;
     }
-  if (NULL != fc->armServiceSocket)
+  if ( (0 != (REASON_CLIENT & reason)) &&
+       (fc->serviceReceivingTask != GNUNET_SCHEDULER_NO_TASK) )
     {
-      if (0 != (REASON_CLIENT & reason))
-       GNUNET_SCHEDULER_cancel (scheduler,
-                                fc->serviceReceivingTask);
-
-      if (GNUNET_SYSERR ==
-         GNUNET_NETWORK_socket_close (fc->armServiceSocket))
-       GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "close");
-      fc->armServiceSocket = NULL;
+      GNUNET_SCHEDULER_cancel (scheduler,
+                              fc->serviceReceivingTask);
+      fc->serviceReceivingTask = GNUNET_SCHEDULER_NO_TASK;
     }
+  if ( (fc->clientReceivingTask != GNUNET_SCHEDULER_NO_TASK) ||
+       (fc->serviceReceivingTask != GNUNET_SCHEDULER_NO_TASK) )
+    return;
+  if (GNUNET_SYSERR ==
+      GNUNET_NETWORK_socket_close (fc->armClientSocket))
+    GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "close");
+  if (GNUNET_SYSERR ==
+      GNUNET_NETWORK_socket_close (fc->armServiceSocket))
+    GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "close");
   GNUNET_free (fc->listen_info->serviceName);             
   GNUNET_free (fc->listen_info->service_addr);
   GNUNET_free (fc->listen_info);       
@@ -222,12 +224,14 @@ forwardToClient (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
   struct ForwardedConnection *fc = cls;
   ssize_t numberOfBytesSent;
 
+  fc->serviceReceivingTask = GNUNET_SCHEDULER_NO_TASK;
   if (0 != (GNUNET_SCHEDULER_REASON_SHUTDOWN & tc->reason))
     {
       /* Ignore shutdown signal, reschedule yourself */
-      GNUNET_SCHEDULER_add_write_net (scheduler, GNUNET_TIME_UNIT_FOREVER_REL,
-                                     fc->armClientSocket,
-                                     &forwardToClient, fc);
+      fc->serviceReceivingTask = 
+       GNUNET_SCHEDULER_add_write_net (scheduler, GNUNET_TIME_UNIT_FOREVER_REL,
+                                       fc->armClientSocket,
+                                       &forwardToClient, fc);
       return;
     }
 
@@ -250,9 +254,10 @@ forwardToClient (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
       fc->serviceBufferDataLength -= numberOfBytesSent;
 
       /* Scheduling writing again for completing the remaining data to be sent */
-      GNUNET_SCHEDULER_add_write_net (scheduler, GNUNET_TIME_UNIT_FOREVER_REL,
-                                     fc->armClientSocket,
-                                     &forwardToClient, fc);
+      fc->serviceReceivingTask = 
+       GNUNET_SCHEDULER_add_write_net (scheduler, GNUNET_TIME_UNIT_FOREVER_REL,
+                                       fc->armClientSocket,
+                                       &forwardToClient, fc);
     }
   else
     {
@@ -279,6 +284,7 @@ receiveFromService (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   struct ForwardedConnection *fc = cls;
 
+  fc->serviceReceivingTask = GNUNET_SCHEDULER_NO_TASK;
   if (0 != (GNUNET_SCHEDULER_REASON_SHUTDOWN & tc->reason))
     {
       /* Neglect shutdown signal, reschedule yourself */
@@ -304,19 +310,21 @@ receiveFromService (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
                      fc->listen_info->serviceName);
        }
       else
-       {
+       {         
          GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                      _("Error receiving from service: %s\n"), 
                      STRERROR (errno));
+         abort ();
        }
       closeClientAndServiceSockets (fc, REASON_SERVICE);
       return;
     }
 
   /* Forwarding Service data to Client */
-  GNUNET_SCHEDULER_add_write_net (scheduler, GNUNET_TIME_UNIT_FOREVER_REL,
-                                 fc->armClientSocket,
-                                 &forwardToClient, fc);
+  fc->serviceReceivingTask = 
+    GNUNET_SCHEDULER_add_write_net (scheduler, GNUNET_TIME_UNIT_FOREVER_REL,
+                                   fc->armClientSocket,
+                                   &forwardToClient, fc);
 }
 
 
@@ -332,12 +340,14 @@ forwardToService (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
   struct ForwardedConnection *fc = cls;
   ssize_t numberOfBytesSent;
 
+  fc->clientReceivingTask = GNUNET_SCHEDULER_NO_TASK;
   if (0 != (GNUNET_SCHEDULER_REASON_SHUTDOWN & tc->reason))
     {
       /* Neglect shutdown signal, reschedule ourself */
-      GNUNET_SCHEDULER_add_write_net (scheduler, GNUNET_TIME_UNIT_FOREVER_REL,
-                                     fc->armServiceSocket,
-                                     &forwardToService, fc);
+      fc->clientReceivingTask = 
+       GNUNET_SCHEDULER_add_write_net (scheduler, GNUNET_TIME_UNIT_FOREVER_REL,
+                                       fc->armServiceSocket,
+                                       &forwardToService, fc);
       return;
     }
 
@@ -361,9 +371,10 @@ forwardToService (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
       fc->clientBufferDataLength -= numberOfBytesSent;
 
       /* Scheduling writing again for completing the remaining data to be sent */
-      GNUNET_SCHEDULER_add_write_net (scheduler, GNUNET_TIME_UNIT_FOREVER_REL,
-                                     fc->armServiceSocket,
-                                     &forwardToService, fc);
+      fc->clientReceivingTask = 
+       GNUNET_SCHEDULER_add_write_net (scheduler, GNUNET_TIME_UNIT_FOREVER_REL,
+                                       fc->armServiceSocket,
+                                       &forwardToService, fc);
     }
   else
     {
@@ -392,6 +403,7 @@ receiveFromClient (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   struct ForwardedConnection *fc = cls;
 
+  fc->clientReceivingTask = GNUNET_SCHEDULER_NO_TASK;
   if (0 != (GNUNET_SCHEDULER_REASON_SHUTDOWN & tc->reason))
     {
       /* Neglect the shutdown signal, schedule ourselves */
@@ -424,9 +436,10 @@ receiveFromClient (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
     }
 
   /* Forwarding request to service */
-  GNUNET_SCHEDULER_add_write_net (scheduler, GNUNET_TIME_UNIT_FOREVER_REL,
-                                 fc->armServiceSocket,
-                                 &forwardToService, fc);
+  fc->clientReceivingTask = 
+    GNUNET_SCHEDULER_add_write_net (scheduler, GNUNET_TIME_UNIT_FOREVER_REL,
+                                   fc->armServiceSocket,
+                                   &forwardToService, fc);
 }
 
 
@@ -512,9 +525,12 @@ void stop_listening (const char *serviceName)
   while (NULL != (pos = next))
     {
       next = pos->next;
-      if (strcmp (pos->serviceName, serviceName) != 0)    
+      if ( (serviceName != NULL) &&
+          (strcmp (pos->serviceName, serviceName) != 0) )
        continue;
       GNUNET_SCHEDULER_cancel (scheduler, pos->acceptTask);
+      fprintf (stderr, "Closing listening socket %p\n", 
+              pos->listeningSocket);
       GNUNET_NETWORK_socket_close (pos->listeningSocket);
       GNUNET_CONTAINER_DLL_remove (serviceListeningInfoList_head,
                                   serviceListeningInfoList_tail, 
@@ -565,6 +581,8 @@ acceptConnection (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
                                       serviceListeningInfo);
       return;
     }
+  fprintf (stderr, "Closing listening socket %p\n", 
+          serviceListeningInfo->listeningSocket);
   GNUNET_NETWORK_socket_close (serviceListeningInfo->listeningSocket);
   GNUNET_CONTAINER_DLL_remove (serviceListeningInfoList_head,
                               serviceListeningInfoList_tail, 
@@ -599,9 +617,13 @@ createListeningSocket (struct sockaddr *sa,
     {
     case AF_INET:
       socket = GNUNET_NETWORK_socket_create (PF_INET, SOCK_STREAM, 0);
+      fprintf (stderr, "IPv4 listening at %p\n", 
+              socket);
       break;
     case AF_INET6:
       socket = GNUNET_NETWORK_socket_create (PF_INET6, SOCK_STREAM, 0);
+      fprintf (stderr, "IPv6 listening at %p\n", 
+              socket);
       break;
     default:
       socket = NULL;
@@ -708,3 +730,5 @@ prepareServices (const struct GNUNET_CONFIGURATION_Handle
   /* Spot the services from the configuration and create a listening socket for each */
   GNUNET_CONFIGURATION_iterate (cfg, &checkPortNumberCB, NULL);
 }
+
+/* end of gnunet-service-manager.c */

diff --git a/src/arm/test_gnunet_service_manager.c b/src/arm/test_gnunet_service_manager.c
index 2d39e392a96d159a757657cded5681553ffd20cd..d0c29ded55b0eb9c03f1ce02c71c92762100c183 100644 (file)
--- a/src/arm/test_gnunet_service_manager.c
+++ b/src/arm/test_gnunet_service_manager.c
@@ -27,80 +27,133 @@
 #include "gnunet_resolver_service.h"
 #include "gnunet_program_lib.h"
 
+/**
+ * Timeout for starting services, very short because of the strange way start works
+ * (by checking if running before starting, so really this time is always waited on
+ * startup (annoying)).
+ */
+#define START_TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MILLISECONDS, 50)
+
 #define TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 10)
 
-/* Global Variables */
-static int isOK = GNUNET_OK;
+#define START_ARM GNUNET_YES
+
+static int ret = 1;
+
+static struct GNUNET_SCHEDULER_Handle *sched;
+
+static const struct GNUNET_CONFIGURATION_Handle *cfg;
+
+static struct GNUNET_ARM_Handle *arm;
+
+static void
+arm_stopped (void *cls, int success)
+{
+  if (success != GNUNET_OK)        
+    ret = 4;
+}
 
 static void 
 hostNameResolveCB(void *cls, 
-                                 const struct sockaddr *addr, 
-                                 socklen_t addrlen)
+                 const struct sockaddr *addr, 
+                 socklen_t addrlen)
 {
-       if (NULL == addr)
-               GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Name not resolved!\n");
+  if ( (ret == 0) || (ret == 4) )
+    return;
+  if (NULL == addr)
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_ERROR, 
+                "Name not resolved!\n");
+#if START_ARM
+      GNUNET_ARM_stop_service (arm, "arm", TIMEOUT, &arm_stopped, NULL);
+#endif
+      ret = 3;
+      return;
+    }  
+  ret = 0;
+#if START_ARM
+  GNUNET_ARM_stop_service (arm, "arm", TIMEOUT, &arm_stopped, NULL);
+#endif
+}
+
+
+
+static void
+arm_notify (void *cls, int success)
+{
+  if (success != GNUNET_YES)
+    {
+      GNUNET_break (0);
+      ret = 1;
+      return;
+    }
+  /* connect to the resolver service */
+  if (NULL == GNUNET_RESOLVER_hostname_resolve (sched,
+                                               cfg, AF_UNSPEC,
+                                               TIMEOUT,
+                                               &hostNameResolveCB,
+                                               NULL))
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, 
+                 "Unable to resolve our own hostname!\n");
+      ret = 2;
+#if START_ARM
+      GNUNET_ARM_stop_service (arm, "arm", TIMEOUT, &arm_stopped, NULL);
+#endif
+    }
 }
 
 
 static void
 run(void *cls, 
-       struct GNUNET_SCHEDULER_Handle *sched, 
-       char * const *args,
+    struct GNUNET_SCHEDULER_Handle *s, 
+    char * const *args,
     const char *cfgfile, 
-    const struct GNUNET_CONFIGURATION_Handle *cfg)
+    const struct GNUNET_CONFIGURATION_Handle *c)
 {
-       struct GNUNET_RESOLVER_RequestHandle *resolveRet;
-       
-       /* connect to the resolver service */
-       resolveRet =
-       GNUNET_RESOLVER_hostname_resolve (sched,
-                                         cfg, AF_UNSPEC,
-                                         TIMEOUT,
-                                         &hostNameResolveCB,
-                                         NULL);
-       if (NULL == resolveRet) {
-               GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Unable to resolve our own hostname!\n");
-               isOK = GNUNET_NO;
-       }
+  cfg = c;
+  sched = s;   
+  arm = GNUNET_ARM_connect (cfg, sched, NULL);
+#if START_ARM
+  GNUNET_ARM_start_service (arm, "arm", START_TIMEOUT, &arm_notify, NULL);
+#else
+  arm_notify (NULL, GNUNET_YES);
+#endif
 }
 
 
-static int
+static void
 check()
 {
-       char *const argv[] = {
-           "test-gnunet-service-manager",
-           "-c", "test_arm_api_data.conf",
-       #if VERBOSE
-           "-L", "DEBUG",
-       #endif
-           NULL
-         };
-         struct GNUNET_GETOPT_CommandLineOption options[] = {
-           GNUNET_GETOPT_OPTION_END
-         };
-         
-         /* Running ARM  and running the do_nothing task */
-         GNUNET_assert (GNUNET_OK ==
-                        GNUNET_PROGRAM_run ((sizeof (argv) / sizeof (char *)) - 1,
-                                            argv,
-                                            "test-gnunet-service-manager",
-                                            "nohelp", options, &run, NULL));
-         return isOK;
+  char *const argv[] = {
+    "test-gnunet-service-manager",
+    "-c", "test_arm_api_data.conf",
+#if VERBOSE
+    "-L", "DEBUG",
+#endif
+    NULL
+  };
+  struct GNUNET_GETOPT_CommandLineOption options[] = {
+    GNUNET_GETOPT_OPTION_END
+  };
+  GNUNET_assert (GNUNET_OK ==
+                GNUNET_PROGRAM_run ((sizeof (argv) / sizeof (char *)) - 1,
+                                    argv,
+                                    "test-gnunet-service-manager",
+                                    "nohelp", options, &run, NULL));
 }
 
 
 int
 main (int argc, char *argv[])
 {
-  int ret;
   GNUNET_log_setup("test-gnunet-service-manager",
-  #if VERBOSE
-        "DEBUG",
-  #else
-        "WARNING",
-  #endif
-        NULL);
-  ret = check();
+#if VERBOSE
+                  "DEBUG",
+#else
+                  "WARNING",
+#endif
+                  NULL);
+  check();
   return ret;
 }