fixes

3 files changed, 165 insertions, 87 deletions

diff --git a/src/arm/gnunet-service-arm.c b/src/arm/gnunet-service-arm.c
index f38b6b044..71a2aa446 100644
--- 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 c80c12aa5..a632fea49 100644
--- 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 2d39e392a..d0c29ded5 100644
--- 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;
 }