implementing new scheduler shutdown semantics

1 files changed, 129 insertions, 89 deletions

diff --git a/src/util/connection.c b/src/util/connection.c
index b3ea3b5af..95fbb13f8 100644
--- a/src/util/connection.c
+++ b/src/util/connection.c
@@ -217,7 +217,7 @@ struct GNUNET_CONNECTION_Handle
   struct GNUNET_RESOLVER_RequestHandle *dns_active;
 
   /**
-   * The handle we return for GNUNET_CONNECTION_notify_transmit_ready.
+   * The handle we return for #GNUNET_CONNECTION_notify_transmit_ready().
    */
   struct GNUNET_CONNECTION_TransmitHandle nth;
 
@@ -344,7 +344,9 @@ GNUNET_CONNECTION_create_from_accept (GNUNET_CONNECTION_AccessCheck access_cb,
 
   addrlen = sizeof (addr);
   sock =
-      GNUNET_NETWORK_socket_accept (lsock, (struct sockaddr *) &addr, &addrlen);
+      GNUNET_NETWORK_socket_accept (lsock,
+                                    (struct sockaddr *) &addr,
+                                    &addrlen);
   if (NULL == sock)
   {
     if (EAGAIN != errno)
@@ -360,7 +362,8 @@ GNUNET_CONNECTION_create_from_accept (GNUNET_CONNECTION_AccessCheck access_cb,
 
   sa = (struct sockaddr *) addr;
   v6 = (struct sockaddr_in6 *) addr;
-  if ((AF_INET6 == sa->sa_family) && (IN6_IS_ADDR_V4MAPPED (&v6->sin6_addr)))
+  if ( (AF_INET6 == sa->sa_family) &&
+       (IN6_IS_ADDR_V4MAPPED (&v6->sin6_addr)) )
   {
     /* convert to V4 address */
     v4 = GNUNET_new (struct sockaddr_in);
@@ -389,15 +392,21 @@ GNUNET_CONNECTION_create_from_accept (GNUNET_CONNECTION_AccessCheck access_cb,
   {
 #if HAVE_GETPEEREID
     /* most BSDs */
-    if (0 == getpeereid (GNUNET_NETWORK_get_fd (sock), &gc.uid, &gc.gid))
+    if (0 == getpeereid (GNUNET_NETWORK_get_fd (sock),
+                         &gc.uid,
+                         &gc.gid))
       gcp = &gc;
 #else
 #ifdef SO_PEERCRED
     /* largely traditional GNU/Linux */
     olen = sizeof (uc);
-    if ((0 ==
-         getsockopt (GNUNET_NETWORK_get_fd (sock), SOL_SOCKET, SO_PEERCRED, &uc,
-                     &olen)) && (olen == sizeof (uc)))
+    if ( (0 ==
+          getsockopt (GNUNET_NETWORK_get_fd (sock),
+                      SOL_SOCKET,
+                      SO_PEERCRED,
+                      &uc,
+                      &olen)) &&
+         (olen == sizeof (uc)) )
     {
       gc.uid = uc.uid;
       gc.gid = uc.gid;
@@ -421,8 +430,11 @@ GNUNET_CONNECTION_create_from_accept (GNUNET_CONNECTION_AccessCheck access_cb,
 #endif
   }
 
-  if ((NULL != access_cb) &&
-      (GNUNET_YES != (aret = access_cb (access_cb_cls, gcp, uaddr, addrlen))))
+  if ( (NULL != access_cb) &&
+       (GNUNET_YES != (aret = access_cb (access_cb_cls,
+                                         gcp,
+                                         uaddr,
+                                         addrlen))) )
   {
     if (GNUNET_NO == aret)
       LOG (GNUNET_ERROR_TYPE_INFO,
@@ -444,7 +456,9 @@ GNUNET_CONNECTION_create_from_accept (GNUNET_CONNECTION_AccessCheck access_cb,
   connection->sock = sock;
   LOG (GNUNET_ERROR_TYPE_INFO,
        _("Accepting connection from `%s': %p\n"),
-       GNUNET_a2s (uaddr, addrlen), connection);
+       GNUNET_a2s (uaddr,
+                   addrlen),
+       connection);
   return connection;
 }
 
@@ -554,7 +568,9 @@ signal_transmit_error (struct GNUNET_CONNECTION_Handle *connection,
     return;                     /* nobody to tell about it */
   notify = connection->nth.notify_ready;
   connection->nth.notify_ready = NULL;
-  notify (connection->nth.notify_ready_cls, 0, NULL);
+  notify (connection->nth.notify_ready_cls,
+          0,
+          NULL);
 }
 
 
@@ -631,7 +647,8 @@ connect_success_continuation (struct GNUNET_CONNECTION_Handle *connection)
 {
   LOG (GNUNET_ERROR_TYPE_DEBUG,
        "Connection to `%s' succeeded! (%p)\n",
-       GNUNET_a2s (connection->addr, connection->addrlen),
+       GNUNET_a2s (connection->addr,
+                   connection->addrlen),
        connection);
   /* trigger jobs that waited for the connection */
   if (NULL != connection->receiver)
@@ -642,7 +659,8 @@ connect_success_continuation (struct GNUNET_CONNECTION_Handle *connection)
     GNUNET_assert (NULL == connection->read_task);
     connection->read_task =
       GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_absolute_get_remaining
-                                     (connection->receive_timeout), connection->sock,
+                                     (connection->receive_timeout),
+                                     connection->sock,
                                      &receive_ready, connection);
   }
   if (NULL != connection->nth.notify_ready)
@@ -679,21 +697,28 @@ connect_probe_continuation (void *cls)
   socklen_t len;
 
   GNUNET_assert (NULL != ap->sock);
-  GNUNET_CONTAINER_DLL_remove (connection->ap_head, connection->ap_tail, ap);
+  GNUNET_CONTAINER_DLL_remove (connection->ap_head,
+                               connection->ap_tail,
+                               ap);
   len = sizeof (error);
   errno = 0;
   error = 0;
   tc = GNUNET_SCHEDULER_get_task_context ();
-  if ((0 == (tc->reason & GNUNET_SCHEDULER_REASON_WRITE_READY)) ||
-      (GNUNET_OK !=
-       GNUNET_NETWORK_socket_getsockopt (ap->sock, SOL_SOCKET, SO_ERROR, &error,
-                                         &len)) || (0 != error))
+  if ( (0 == (tc->reason & GNUNET_SCHEDULER_REASON_WRITE_READY)) ||
+       (GNUNET_OK !=
+        GNUNET_NETWORK_socket_getsockopt (ap->sock,
+                                          SOL_SOCKET,
+                                          SO_ERROR,
+                                          &error,
+                                          &len)) ||
+       (0 != error) )
   {
-    GNUNET_break (GNUNET_OK == GNUNET_NETWORK_socket_close (ap->sock));
+    GNUNET_break (GNUNET_OK ==
+                  GNUNET_NETWORK_socket_close (ap->sock));
     GNUNET_free (ap);
-    if ((NULL == connection->ap_head) &&
-        (GNUNET_NO == connection->dns_active) &&
-        (NULL == connection->proxy_handshake))
+    if ( (NULL == connection->ap_head) &&
+         (GNUNET_NO == connection->dns_active) &&
+         (NULL == connection->proxy_handshake) )
       connect_fail_continuation (connection);
     return;
   }
@@ -709,7 +734,9 @@ connect_probe_continuation (void *cls)
   {
     GNUNET_break (GNUNET_OK == GNUNET_NETWORK_socket_close (pos->sock));
     GNUNET_SCHEDULER_cancel (pos->task);
-    GNUNET_CONTAINER_DLL_remove (connection->ap_head, connection->ap_tail, pos);
+    GNUNET_CONTAINER_DLL_remove (connection->ap_head,
+                                 connection->ap_tail,
+                                 pos);
     GNUNET_free (pos);
   }
   connect_success_continuation (connection);
@@ -771,7 +798,8 @@ try_connect_using_address (void *cls,
     GNUNET_free (ap);
     return;                     /* not supported by us */
   }
-  ap->sock = GNUNET_NETWORK_socket_create (ap->addr->sa_family, SOCK_STREAM, 0);
+  ap->sock = GNUNET_NETWORK_socket_create (ap->addr->sa_family,
+                                           SOCK_STREAM, 0);
   if (NULL == ap->sock)
   {
     GNUNET_free (ap);
@@ -782,7 +810,9 @@ try_connect_using_address (void *cls,
        GNUNET_a2s (ap->addr, ap->addrlen),
        connection);
   if ((GNUNET_OK !=
-       GNUNET_NETWORK_socket_connect (ap->sock, ap->addr, ap->addrlen)) &&
+       GNUNET_NETWORK_socket_connect (ap->sock,
+                                      ap->addr,
+                                      ap->addrlen)) &&
       (EINPROGRESS != errno))
   {
     /* maybe refused / unsupported address, try next */
@@ -794,17 +824,15 @@ try_connect_using_address (void *cls,
   GNUNET_CONTAINER_DLL_insert (connection->ap_head, connection->ap_tail, ap);
   delay = GNUNET_CONNECTION_CONNECT_RETRY_TIMEOUT;
   if (NULL != connection->nth.notify_ready)
-    delay =
-        GNUNET_TIME_relative_min (delay,
-                                  GNUNET_TIME_absolute_get_remaining (connection->nth.transmit_timeout));
+    delay = GNUNET_TIME_relative_min (delay,
+                                      GNUNET_TIME_absolute_get_remaining (connection->nth.transmit_timeout));
   if (NULL != connection->receiver)
-    delay =
-        GNUNET_TIME_relative_min (delay,
-                                  GNUNET_TIME_absolute_get_remaining
-                                  (connection->receive_timeout));
-  ap->task =
-      GNUNET_SCHEDULER_add_write_net (delay, ap->sock,
-                                      &connect_probe_continuation, ap);
+    delay = GNUNET_TIME_relative_min (delay,
+                                      GNUNET_TIME_absolute_get_remaining (connection->receive_timeout));
+  ap->task = GNUNET_SCHEDULER_add_write_net (delay,
+                                             ap->sock,
+                                             &connect_probe_continuation,
+                                             ap);
 }
 
 
@@ -833,9 +861,11 @@ GNUNET_CONNECTION_create_from_connect (const struct GNUNET_CONFIGURATION_Handle
   connection->port = port;
   connection->hostname = GNUNET_strdup (hostname);
   connection->dns_active =
-      GNUNET_RESOLVER_ip_get (connection->hostname, AF_UNSPEC,
+      GNUNET_RESOLVER_ip_get (connection->hostname,
+                              AF_UNSPEC,
                               GNUNET_CONNECTION_CONNECT_RETRY_TIMEOUT,
-                              &try_connect_using_address, connection);
+                              &try_connect_using_address,
+                              connection);
   return connection;
 }
 
@@ -865,7 +895,8 @@ GNUNET_CONNECTION_create_from_connect_to_unixpath (const struct GNUNET_CONFIGURA
   {
     int abstract;
 
-    abstract = GNUNET_CONFIGURATION_get_value_yesno (cfg, "TESTING",
+    abstract = GNUNET_CONFIGURATION_get_value_yesno (cfg,
+                                                     "TESTING",
                                                      "USE_ABSTRACT_SOCKETS");
     if (GNUNET_YES == abstract)
       un->sun_path[0] = '\0';
@@ -882,7 +913,9 @@ GNUNET_CONNECTION_create_from_connect_to_unixpath (const struct GNUNET_CONFIGURA
   connection->hostname = NULL;
   connection->addr = (struct sockaddr *) un;
   connection->addrlen = sizeof (struct sockaddr_un);
-  connection->sock = GNUNET_NETWORK_socket_create (AF_UNIX, SOCK_STREAM, 0);
+  connection->sock = GNUNET_NETWORK_socket_create (AF_UNIX,
+                                                   SOCK_STREAM,
+                                                   0);
   if (NULL == connection->sock)
   {
     GNUNET_free (connection->addr);
@@ -891,11 +924,14 @@ GNUNET_CONNECTION_create_from_connect_to_unixpath (const struct GNUNET_CONFIGURA
     return NULL;
   }
   if ( (GNUNET_OK !=
-        GNUNET_NETWORK_socket_connect (connection->sock, connection->addr, connection->addrlen)) &&
+        GNUNET_NETWORK_socket_connect (connection->sock,
+                                       connection->addr,
+                                       connection->addrlen)) &&
        (EINPROGRESS != errno) )
   {
     /* Just return; we expect everything to work eventually so don't fail HARD */
-    GNUNET_break (GNUNET_OK == GNUNET_NETWORK_socket_close (connection->sock));
+    GNUNET_break (GNUNET_OK ==
+                  GNUNET_NETWORK_socket_close (connection->sock));
     connection->sock = NULL;
     return connection;
   }
@@ -971,10 +1007,13 @@ GNUNET_CONNECTION_create_from_sockaddr (int af_family,
   s = GNUNET_NETWORK_socket_create (af_family, SOCK_STREAM, 0);
   if (NULL == s)
   {
-    LOG_STRERROR (GNUNET_ERROR_TYPE_WARNING | GNUNET_ERROR_TYPE_BULK, "socket");
+    LOG_STRERROR (GNUNET_ERROR_TYPE_WARNING | GNUNET_ERROR_TYPE_BULK,
+                  "socket");
     return NULL;
   }
-  return GNUNET_CONNECTION_connect_socket (s, serv_addr, addrlen);
+  return GNUNET_CONNECTION_connect_socket (s,
+                                           serv_addr, 
+                                           addrlen);
 }
 
 
@@ -1054,7 +1093,9 @@ GNUNET_CONNECTION_destroy (struct GNUNET_CONNECTION_Handle *connection)
   {
     GNUNET_break (GNUNET_OK == GNUNET_NETWORK_socket_close (pos->sock));
     GNUNET_SCHEDULER_cancel (pos->task);
-    GNUNET_CONTAINER_DLL_remove (connection->ap_head, connection->ap_tail, pos);
+    GNUNET_CONTAINER_DLL_remove (connection->ap_head,
+                                 connection->ap_tail,
+                                 pos);
     GNUNET_free (pos);
   }
   if ( (NULL != connection->sock) &&
@@ -1105,21 +1146,14 @@ receive_ready (void *cls)
 
   connection->read_task = NULL;
   tc = GNUNET_SCHEDULER_get_task_context ();
-  if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN))
-  {
-    /* ignore shutdown request, go again immediately */
-    connection->read_task =
-        GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_absolute_get_remaining
-                                       (connection->receive_timeout), connection->sock,
-                                       &receive_ready, connection);
-    return;
-  }
   if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_TIMEOUT))
   {
     LOG (GNUNET_ERROR_TYPE_DEBUG,
          "Receive from `%s' encounters error: timeout (%s, %p)\n",
-         GNUNET_a2s (connection->addr, connection->addrlen),
-         GNUNET_STRINGS_relative_time_to_string (GNUNET_TIME_absolute_get_duration (connection->receive_timeout), GNUNET_YES),
+         GNUNET_a2s (connection->addr,
+                     connection->addrlen),
+         GNUNET_STRINGS_relative_time_to_string (GNUNET_TIME_absolute_get_duration (connection->receive_timeout),
+                                                 GNUNET_YES),
          connection);
     signal_receive_timeout (connection);
     return;
@@ -1130,7 +1164,8 @@ receive_ready (void *cls)
     signal_receive_error (connection, ECONNREFUSED);
     return;
   }
-  GNUNET_assert (GNUNET_NETWORK_fdset_isset (tc->read_ready, connection->sock));
+  GNUNET_assert (GNUNET_NETWORK_fdset_isset (tc->read_ready,
+                                             connection->sock));
 RETRY:
   ret = GNUNET_NETWORK_socket_recv (connection->sock,
                                     buffer,
@@ -1161,8 +1196,8 @@ RETRY:
 
 
 /**
- * Receive data from the given connection.  Note that this function will
- * call @a receiver asynchronously using the scheduler.  It will
+ * Receive data from the given connection.  Note that this function
+ * will call @a receiver asynchronously using the scheduler.  It will
  * "immediately" return.  Note that there MUST only be one active
  * receive call per connection at any given point in time (so do not
  * call receive again until the receiver callback has been invoked).
@@ -1202,7 +1237,10 @@ GNUNET_CONNECTION_receive (struct GNUNET_CONNECTION_Handle *connection,
       (NULL == connection->proxy_handshake))
   {
     connection->receiver = NULL;
-    receiver (receiver_cls, NULL, 0, NULL, 0, ETIMEDOUT);
+    receiver (receiver_cls,
+              NULL, 0,
+              NULL, 0,
+              ETIMEDOUT);
     return;
   }
 }
@@ -1312,7 +1350,9 @@ transmit_timeout (void *cls)
   notify = connection->nth.notify_ready;
   GNUNET_assert (NULL != notify);
   connection->nth.notify_ready = NULL;
-  notify (connection->nth.notify_ready_cls, 0, NULL);
+  notify (connection->nth.notify_ready_cls,
+          0,
+          NULL);
 }
 
 
@@ -1339,7 +1379,9 @@ connect_error (void *cls)
   connection->write_task = NULL;
   notify = connection->nth.notify_ready;
   connection->nth.notify_ready = NULL;
-  notify (connection->nth.notify_ready_cls, 0, NULL);
+  notify (connection->nth.notify_ready_cls,
+          0,
+          NULL);
 }
 
 
@@ -1364,21 +1406,6 @@ transmit_ready (void *cls)
   connection->write_task = NULL;
   GNUNET_assert (NULL == connection->nth.timeout_task);
   tc = GNUNET_SCHEDULER_get_task_context ();
-  if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN))
-  {
-    if (NULL != connection->sock)
-      goto SCHEDULE_WRITE;      /* ignore shutdown, go again immediately */
-    LOG (GNUNET_ERROR_TYPE_DEBUG,
-         "Transmit to `%s' fails, shutdown happened (%p).\n",
-         GNUNET_a2s (connection->addr, connection->addrlen), connection);
-    notify = connection->nth.notify_ready;
-    if (NULL != notify)
-    {
-      connection->nth.notify_ready = NULL;
-      notify (connection->nth.notify_ready_cls, 0, NULL);
-    }
-    return;
-  }
   if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_TIMEOUT))
   {
     LOG (GNUNET_ERROR_TYPE_DEBUG,
@@ -1400,7 +1427,8 @@ transmit_ready (void *cls)
      * Hence retry.  */
     goto SCHEDULE_WRITE;
   }
-  if (!GNUNET_NETWORK_fdset_isset (tc->write_ready, connection->sock))
+  if (! GNUNET_NETWORK_fdset_isset (tc->write_ready,
+                                    connection->sock))
   {
     GNUNET_assert (NULL == connection->write_task);
     /* special circumstances (in particular, shutdown): not yet ready
@@ -1444,7 +1472,11 @@ RETRY:
   }
   LOG (GNUNET_ERROR_TYPE_DEBUG,
        "Connection transmitted %u/%u bytes to `%s' (%p)\n",
-       (unsigned int) ret, have, GNUNET_a2s (connection->addr, connection->addrlen), connection);
+       (unsigned int) ret,
+       have,
+       GNUNET_a2s (connection->addr,
+                   connection->addrlen),
+       connection);
   connection->write_buffer_pos += ret;
   if (connection->write_buffer_pos == connection->write_buffer_off)
   {
@@ -1452,21 +1484,25 @@ RETRY:
     connection->write_buffer_pos = 0;
     connection->write_buffer_off = 0;
   }
-  if ((0 == connection->write_buffer_off) && (NULL == connection->nth.notify_ready))
+  if ( (0 == connection->write_buffer_off) &&
+       (NULL == connection->nth.notify_ready) )
     return;                     /* all data sent! */
   /* not done writing, schedule more */
 SCHEDULE_WRITE:
   LOG (GNUNET_ERROR_TYPE_DEBUG,
-       "Re-scheduling transmit_ready (more to do) (%p).\n", connection);
+       "Re-scheduling transmit_ready (more to do) (%p).\n",
+       connection);
   have = connection->write_buffer_off - connection->write_buffer_pos;
-  GNUNET_assert ((NULL != connection->nth.notify_ready) || (have > 0));
+  GNUNET_assert ( (NULL != connection->nth.notify_ready) ||
+                  (have > 0) );
   if (NULL == connection->write_task)
     connection->write_task =
         GNUNET_SCHEDULER_add_write_net ((connection->nth.notify_ready ==
                                          NULL) ? GNUNET_TIME_UNIT_FOREVER_REL :
                                         GNUNET_TIME_absolute_get_remaining
                                         (connection->nth.transmit_timeout),
-                                        connection->sock, &transmit_ready, connection);
+                                        connection->sock,
+                                        &transmit_ready, connection);
 }
 
 
@@ -1488,8 +1524,8 @@ struct GNUNET_CONNECTION_TransmitHandle *
 GNUNET_CONNECTION_notify_transmit_ready (struct GNUNET_CONNECTION_Handle *connection,
                                          size_t size,
                                          struct GNUNET_TIME_Relative timeout,
-                                         GNUNET_CONNECTION_TransmitReadyNotify
-                                         notify, void *notify_cls)
+                                         GNUNET_CONNECTION_TransmitReadyNotify notify,
+                                         void *notify_cls)
 {
   if (NULL != connection->nth.notify_ready)
   {
@@ -1529,7 +1565,8 @@ GNUNET_CONNECTION_notify_transmit_ready (struct GNUNET_CONNECTION_Handle *connec
     connection->write_task =
         GNUNET_SCHEDULER_add_write_net (GNUNET_TIME_absolute_get_remaining
                                         (connection->nth.transmit_timeout),
-                                        connection->sock, &transmit_ready, connection);
+                                        connection->sock,
+                                        &transmit_ready, connection);
     return &connection->nth;
   }
   /* not yet connected, wait for connection */
@@ -1538,7 +1575,8 @@ GNUNET_CONNECTION_notify_transmit_ready (struct GNUNET_CONNECTION_Handle *connec
        connection);
   connection->nth.timeout_task =
     GNUNET_SCHEDULER_add_delayed (timeout,
-                                  &transmit_timeout, connection);
+                                  &transmit_timeout,
+                                  connection);
   return &connection->nth;
 }
 
@@ -1575,7 +1613,8 @@ GNUNET_CONNECTION_notify_transmit_ready_cancel (struct GNUNET_CONNECTION_Transmi
 struct GNUNET_CONNECTION_Handle *
 GNUNET_CONNECTION_create_proxied_from_handshake (struct GNUNET_CONNECTION_Handle *cph)
 {
-  struct GNUNET_CONNECTION_Handle * proxied = GNUNET_CONNECTION_create_from_existing(NULL);
+  struct GNUNET_CONNECTION_Handle *proxied = GNUNET_CONNECTION_create_from_existing (NULL);
+
   proxied->proxy_handshake = cph;
   return proxied;
 }
@@ -1592,11 +1631,12 @@ void
 GNUNET_CONNECTION_acivate_proxied (struct GNUNET_CONNECTION_Handle *proxied)
 {
   struct GNUNET_CONNECTION_Handle *cph = proxied->proxy_handshake;
+
   GNUNET_assert (NULL != cph);
   GNUNET_assert (NULL == proxied->sock);
   GNUNET_assert (NULL != cph->sock);
-  proxied->sock=cph->sock;
-  cph->sock=NULL;
+  proxied->sock = cph->sock;
+  cph->sock = NULL;
   GNUNET_CONNECTION_destroy (cph);
   connect_success_continuation (proxied);
 }