1 files changed, 400 insertions, 392 deletions

diff --git a/src/lib/eventloop.c b/src/lib/eventloop.c
index a1f8d44b..6f5595e6 100644
--- a/src/lib/eventloop.c
+++ b/src/lib/eventloop.c
@@ -55,11 +55,11 @@ struct GNUNET_GTK_MainLoop
    * Initial task to run to setup the system.
    */
   GNUNET_SCHEDULER_Task main_task;
-  
+
   /**
    * Builder for the main window.
    */
-  GtkBuilder *builder; 
+  GtkBuilder *builder;
 
   /**
    * Gib's Main loop.
@@ -192,7 +192,7 @@ GNUNET_GTK_main_loop_quit (struct GNUNET_GTK_MainLoop *ml)
  */
 GObject *
 GNUNET_GTK_main_loop_get_object (struct GNUNET_GTK_MainLoop *ml,
-                                 const char *name)
+                                 const char *name)
 {
   return gtk_builder_get_object (ml->builder, name);
 }
@@ -205,10 +205,10 @@ GNUNET_GTK_main_loop_get_object (struct GNUNET_GTK_MainLoop *ml,
  * @param tc scheduler context
  */
 static void
-dispatch_gtk_task (void *cls,
-                   const struct GNUNET_SCHEDULER_TaskContext *tc)
+dispatch_gtk_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   struct GNUNET_GTK_MainLoop *ml = cls;
+
   g_main_context_dispatch (ml->gmc);
 }
 
@@ -220,8 +220,7 @@ dispatch_gtk_task (void *cls,
  * @param new_size desired size of the cached poll array
  */
 static void
-resize_cached_poll_array (struct GNUNET_GTK_MainLoop *ml,
-                          guint new_size)
+resize_cached_poll_array (struct GNUNET_GTK_MainLoop *ml, guint new_size)
 {
   if (NULL == ml->cached_poll_array)
     ml->cached_poll_array = g_new (GPollFD, new_size);
@@ -235,16 +234,14 @@ resize_cached_poll_array (struct GNUNET_GTK_MainLoop *ml,
  * Dummy task to keep our scheduler running.
  */
 static void
-keepalive_task (void *cls,
-                const struct GNUNET_SCHEDULER_TaskContext *tc)
+keepalive_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   struct GNUNET_GTK_MainLoop *ml = cls;
 
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Dummy task was scheduled\n");
-  ml->dummy_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_FOREVER_REL,
-                                                 &keepalive_task,
-                                                 ml);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Dummy task was scheduled\n");
+  ml->dummy_task =
+      GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_FOREVER_REL,
+                                    &keepalive_task, ml);
 }
 
 
@@ -267,8 +264,7 @@ keepalive_task (void *cls,
  * @return number of selected sockets, GNUNET_SYSERR on error
  */
 static int
-gnunet_gtk_select (void *cls,
-                   struct GNUNET_NETWORK_FDSet *rfds,
+gnunet_gtk_select (void *cls, struct GNUNET_NETWORK_FDSet *rfds,
                    struct GNUNET_NETWORK_FDSet *wfds,
                    struct GNUNET_NETWORK_FDSet *efds,
                    const struct GNUNET_TIME_Relative timeout)
@@ -299,10 +295,7 @@ gnunet_gtk_select (void *cls,
 #endif
 
   if (TRUE != g_main_loop_is_running (ml->gml))
-    return GNUNET_NETWORK_socket_select (rfds, 
-                                         wfds, 
-                                         efds,
-                                         timeout);
+    return GNUNET_NETWORK_socket_select (rfds, wfds, efds, timeout);
   if (NULL != rfds)
     FD_COPY (&rfds->sds, &aread);
   else
@@ -340,249 +333,260 @@ gnunet_gtk_select (void *cls,
 #if !WINDOWS
   fd_counter = 0;
   for (i = 0; i < max_nfds; i++)
-    {
-      int isset[3];
-          
-      isset[0] = (rfds == NULL) ? 0 : FD_ISSET (i, &rfds->sds);
-      isset[1] = (wfds == NULL) ? 0 : FD_ISSET (i, &wfds->sds);
-      isset[2] = (efds == NULL) ? 0 : FD_ISSET (i, &efds->sds);
-      if ((! isset[0]) && (! isset[1]) && (! isset[2]))
-        continue;
-      if (fd_counter >= ml->cached_poll_array_size)
-        resize_cached_poll_array (ml, ml->cached_poll_array_size * 2);
-      ml->cached_poll_array[fd_counter].fd = i;
-      ml->cached_poll_array[fd_counter].events 
-        = (isset[0] ? G_IO_IN | G_IO_HUP | G_IO_ERR : 0)
-        | (isset[1] ? G_IO_OUT | G_IO_ERR : 0) 
-        | (isset[2] ? G_IO_ERR : 0);
-      fd_counter++;
-    }
+  {
+    int isset[3];
+
+    isset[0] = (rfds == NULL) ? 0 : FD_ISSET (i, &rfds->sds);
+    isset[1] = (wfds == NULL) ? 0 : FD_ISSET (i, &wfds->sds);
+    isset[2] = (efds == NULL) ? 0 : FD_ISSET (i, &efds->sds);
+    if ((!isset[0]) && (!isset[1]) && (!isset[2]))
+      continue;
+    if (fd_counter >= ml->cached_poll_array_size)
+      resize_cached_poll_array (ml, ml->cached_poll_array_size * 2);
+    ml->cached_poll_array[fd_counter].fd = i;
+    ml->cached_poll_array[fd_counter].events =
+        (isset[0] ? G_IO_IN | G_IO_HUP | G_IO_ERR : 0) | (isset[1] ? G_IO_OUT |
+                                                          G_IO_ERR : 0) |
+        (isset[2] ? G_IO_ERR : 0);
+    fd_counter++;
+  }
 #else
   /* FIXME: why while(1)  here!? */
   while (1)
+  {
+    struct GNUNET_CONTAINER_SList_Iterator *t;
+
+    fd_counter = 0;
+    /* We might overshoot a little, but that won't hurt very much */
+    int need_nfds =
+        (rfds->sds.fd_count + rfds->sds.fd_count + rfds->sds.fd_count >
+         0 ? 3 : 0) + (rfds ==
+                       NULL ? 0 : GNUNET_CONTAINER_slist_count (rfds->handles))
+        + (wfds == NULL ? 0 : 1) + 1;
+    if (need_nfds >= ml->cached_poll_array_size)
+      resize_cached_poll_array (ml, need_nfds * 2);
+    /* Since there are also gmainloop's own fds, just need_nfds won't be
+     * enough, so make it twice as long.
+     */
+    if (ml->read_array_length < GNUNET_CONTAINER_slist_count (rfds->handles))
+    {
+      ml->read_array =
+          GNUNET_realloc (ml->read_array,
+                          GNUNET_CONTAINER_slist_count (rfds->handles) *
+                          sizeof (struct GNUNET_DISK_FileHandle *));
+      ml->read_array_length = GNUNET_CONTAINER_slist_count (rfds->handles);
+    }
+    if (rfds != NULL)
     {
-      struct GNUNET_CONTAINER_SList_Iterator *t;
-
-      fd_counter = 0;
-      /* We might overshoot a little, but that won't hurt very much */
-      int need_nfds = (rfds->sds.fd_count + rfds->sds.fd_count + rfds->sds.fd_count > 0 ? 3 : 0)
-        + (rfds == NULL ? 0 : GNUNET_CONTAINER_slist_count (rfds->handles))
-        + (wfds == NULL ? 0 : 1)
-        + 1;
-      if (need_nfds >= ml->cached_poll_array_size)
-        resize_cached_poll_array (ml, need_nfds * 2);
-          /* Since there are also gmainloop's own fds, just need_nfds won't be
-           * enough, so make it twice as long.
-           */
-      if (ml->read_array_length < GNUNET_CONTAINER_slist_count (rfds->handles))
-        {
-          ml->read_array = GNUNET_realloc (ml->read_array, 
-                                           GNUNET_CONTAINER_slist_count (rfds->handles) * sizeof (struct GNUNET_DISK_FileHandle *));
-          ml->read_array_length = GNUNET_CONTAINER_slist_count (rfds->handles);
-        }
-      if (rfds != NULL)
-        {
-          for (t = GNUNET_CONTAINER_slist_begin (rfds->handles), i = 0;
-               GNUNET_CONTAINER_slist_end (t) != GNUNET_YES;
-               GNUNET_CONTAINER_slist_next (t), i += 1)
-            {
-              struct GNUNET_DISK_FileHandle *fh = GNUNET_CONTAINER_slist_get (t, NULL);
-              if (fh->type == GNUNET_PIPE)
-                {
-                  if (!ReadFile (fh->h, NULL, 0, NULL, fh->oOverlapRead))
-                    {
-                      DWORD error_code = GetLastError();
-                      if (error_code == ERROR_IO_PENDING)
-                        {
+      for (t = GNUNET_CONTAINER_slist_begin (rfds->handles), i = 0;
+           GNUNET_CONTAINER_slist_end (t) != GNUNET_YES;
+           GNUNET_CONTAINER_slist_next (t), i += 1)
+      {
+        struct GNUNET_DISK_FileHandle *fh =
+            GNUNET_CONTAINER_slist_get (t, NULL);
+        if (fh->type == GNUNET_PIPE)
+        {
+          if (!ReadFile (fh->h, NULL, 0, NULL, fh->oOverlapRead))
+          {
+            DWORD error_code = GetLastError ();
+
+            if (error_code == ERROR_IO_PENDING)
+            {
 #if DEBUG_EVENTLOOP
-                          GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                                      "Adding the pipe's 0x%x overlapped event to the array as %d\n", 
-                                      fh->h, nhandles);
+              GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                          "Adding the pipe's 0x%x overlapped event to the array as %d\n",
+                          fh->h, nhandles);
 #endif
-                          ml->cached_poll_array[fd_counter].fd = (intptr_t) fh->oOverlapRead->hEvent;
-                          /* On W32 .events makes no sense - g_poll will just OR its
-                           * contents into .revents when the .fd event fires.
-                           * So we'll use it in the way that suits us the best.
-                           */
-                          ml->cached_poll_array[fd_counter].events = G_IO_IN;
-                          fd_counter += 1;
-                          ml->read_array[read_handles] = fh;
-                          read_handles += 1;
-                        }
-                      else
-                        {
-                          ml->cached_poll_array[fd_counter].fd = (intptr_t) ml->hEventReadReady;
-                          ml->cached_poll_array[fd_counter].events = G_IO_HUP;
-                          fd_counter += 1;
-                          ml->read_array[read_handles] = fh;
-                          read_handles += 1;
-                        }
-                    }
-                  else
-                    {
+              ml->cached_poll_array[fd_counter].fd =
+                  (intptr_t) fh->oOverlapRead->hEvent;
+              /* On W32 .events makes no sense - g_poll will just OR its
+               * contents into .revents when the .fd event fires.
+               * So we'll use it in the way that suits us the best.
+               */
+              ml->cached_poll_array[fd_counter].events = G_IO_IN;
+              fd_counter += 1;
+              ml->read_array[read_handles] = fh;
+              read_handles += 1;
+            }
+            else
+            {
+              ml->cached_poll_array[fd_counter].fd =
+                  (intptr_t) ml->hEventReadReady;
+              ml->cached_poll_array[fd_counter].events = G_IO_HUP;
+              fd_counter += 1;
+              ml->read_array[read_handles] = fh;
+              read_handles += 1;
+            }
+          }
+          else
+          {
 #if DEBUG_EVENTLOOP
-                      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                                  "Adding the read ready event to the array as %d\n",
-                                  nhandles);
+            GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                        "Adding the read ready event to the array as %d\n",
+                        nhandles);
 #endif
-                      ml->cached_poll_array[fd_counter].fd = (intptr_t) ml->hEventReadReady;
-                      ml->cached_poll_array[fd_counter].events = G_IO_IN;
-                      fd_counter += 1;
-                      ml->read_array[read_handles] = fh;
-                      read_handles += 1;
-                    }
-                }
-              else
-                {
-                  GNUNET_CONTAINER_slist_add (ml->handles_read,
-                                              GNUNET_CONTAINER_SLIST_DISPOSITION_TRANSIENT,
-                                              fh, sizeof (struct GNUNET_DISK_FileHandle));
-                  pre_ret++;
-                }
-            }
-        }
-      if ( (wfds != NULL) && (GNUNET_CONTAINER_slist_count (wfds->handles) > 0) )
-        {
-          ml->cached_poll_array[fd_counter].fd = (intptr_t) ml->hEventPipeWrite;
-          ml->cached_poll_array[fd_counter].events = G_IO_OUT;
-          always_ready_write_fd = fd_counter;
-          fd_counter += 1;
-        }
-      if (efds != NULL)
-        {
-          for (t = GNUNET_CONTAINER_slist_begin (efds->handles), i = 0;
-               GNUNET_CONTAINER_slist_end (t) != GNUNET_YES;
-               GNUNET_CONTAINER_slist_next (t), i += 1)
-            {
-              struct GNUNET_DISK_FileHandle *fh = GNUNET_CONTAINER_slist_get (t, NULL);
-
-              DWORD dwBytes;
-              if (fh->type == GNUNET_PIPE)
-                {
-                  if (!PeekNamedPipe (fh->h, NULL, 0, NULL, &dwBytes, NULL))
-                    {
-                      GNUNET_CONTAINER_slist_add (ml->handles_except,
-                                                  GNUNET_CONTAINER_SLIST_DISPOSITION_TRANSIENT,
-                                                  fh, sizeof (struct GNUNET_DISK_FileHandle));
-                      pre_ret++;
-                    }
-                }
-            }
-        }
-      GNUNET_CONTAINER_slist_iter_destroy (t);
-      
-      if ( (rfds != NULL) && (rfds->sds.fd_count > 0) )
-        {
+            ml->cached_poll_array[fd_counter].fd =
+                (intptr_t) ml->hEventReadReady;
+            ml->cached_poll_array[fd_counter].events = G_IO_IN;
+            fd_counter += 1;
+            ml->read_array[read_handles] = fh;
+            read_handles += 1;
+          }
+        }
+        else
+        {
+          GNUNET_CONTAINER_slist_add (ml->handles_read,
+                                      GNUNET_CONTAINER_SLIST_DISPOSITION_TRANSIENT,
+                                      fh,
+                                      sizeof (struct GNUNET_DISK_FileHandle));
+          pre_ret++;
+        }
+      }
+    }
+    if ((wfds != NULL) && (GNUNET_CONTAINER_slist_count (wfds->handles) > 0))
+    {
+      ml->cached_poll_array[fd_counter].fd = (intptr_t) ml->hEventPipeWrite;
+      ml->cached_poll_array[fd_counter].events = G_IO_OUT;
+      always_ready_write_fd = fd_counter;
+      fd_counter += 1;
+    }
+    if (efds != NULL)
+    {
+      for (t = GNUNET_CONTAINER_slist_begin (efds->handles), i = 0;
+           GNUNET_CONTAINER_slist_end (t) != GNUNET_YES;
+           GNUNET_CONTAINER_slist_next (t), i += 1)
+      {
+        struct GNUNET_DISK_FileHandle *fh =
+            GNUNET_CONTAINER_slist_get (t, NULL);
+
+        DWORD dwBytes;
+
+        if (fh->type == GNUNET_PIPE)
+        {
+          if (!PeekNamedPipe (fh->h, NULL, 0, NULL, &dwBytes, NULL))
+          {
+            GNUNET_CONTAINER_slist_add (ml->handles_except,
+                                        GNUNET_CONTAINER_SLIST_DISPOSITION_TRANSIENT,
+                                        fh,
+                                        sizeof (struct GNUNET_DISK_FileHandle));
+            pre_ret++;
+          }
+        }
+      }
+    }
+    GNUNET_CONTAINER_slist_iter_destroy (t);
+
+    if ((rfds != NULL) && (rfds->sds.fd_count > 0))
+    {
 #if DEBUG_EVENTLOOP
-          GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, 
-                      "Adding the socket read event to the array as %d\n",
-                      fd_counter);
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "Adding the socket read event to the array as %d\n",
+                  fd_counter);
 #endif
-          ml->cached_poll_array[fd_counter].fd = (intptr_t) ml->hEventRead;
-          ml->cached_poll_array[fd_counter].events = G_IO_IN;
-          for (i = 0; i < rfds->sds.fd_count; i++)
-            WSAEventSelect (rfds->sds.fd_array[i], ml->hEventRead, FD_ACCEPT | FD_READ | FD_CLOSE);
-          fd_counter += 1;
-          sock_read = rfds->sds.fd_count;
-        }
-      if ( (wfds != NULL) && (wfds->sds.fd_count > 0) )
-        {
-          int wakeup = 0;
+      ml->cached_poll_array[fd_counter].fd = (intptr_t) ml->hEventRead;
+      ml->cached_poll_array[fd_counter].events = G_IO_IN;
+      for (i = 0; i < rfds->sds.fd_count; i++)
+        WSAEventSelect (rfds->sds.fd_array[i], ml->hEventRead,
+                        FD_ACCEPT | FD_READ | FD_CLOSE);
+      fd_counter += 1;
+      sock_read = rfds->sds.fd_count;
+    }
+    if ((wfds != NULL) && (wfds->sds.fd_count > 0))
+    {
+      int wakeup = 0;
+
 #if DEBUG_EVENTLOOP
-          GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                      "Adding the socket write event to the array as %d\n", 
-                      fd_counter);
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "Adding the socket write event to the array as %d\n",
+                  fd_counter);
 #endif
-          ml->cached_poll_array[fd_counter].fd = (intptr_t) ml->hEventWrite;
-          ml->cached_poll_array[fd_counter].events = G_IO_OUT;
-          for (i = 0; i < wfds->sds.fd_count; i++)
-            {
-              DWORD error;
-              int status;
-              status = send (wfds->sds.fd_array[i], NULL, 0, 0);
-              error = GetLastError ();
+      ml->cached_poll_array[fd_counter].fd = (intptr_t) ml->hEventWrite;
+      ml->cached_poll_array[fd_counter].events = G_IO_OUT;
+      for (i = 0; i < wfds->sds.fd_count; i++)
+      {
+        DWORD error;
+        int status;
+
+        status = send (wfds->sds.fd_array[i], NULL, 0, 0);
+        error = GetLastError ();
 #if DEBUG_EVENTLOOP
-              GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, 
-                          "pre-send to the socket %d returned %d (%u)\n", 
-                          i, status, error);
+        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                    "pre-send to the socket %d returned %d (%u)\n", i, status,
+                    error);
 #endif
-              if (status == 0 || (error != WSAEWOULDBLOCK && error != WSAENOTCONN))
-                wakeup = 1;
-              WSAEventSelect (wfds->sds.fd_array[i], ml->hEventWrite, FD_WRITE | FD_CONNECT | FD_CLOSE);
-            }
-          if (wakeup)
-            SetEvent (ml->hEventWrite);
-          fd_counter += 1;
-          sock_write = wfds->sds.fd_count;
-        }
-      if ( (efds != NULL) && (efds->sds.fd_count > 0) )
-        {
+        if (status == 0 || (error != WSAEWOULDBLOCK && error != WSAENOTCONN))
+          wakeup = 1;
+        WSAEventSelect (wfds->sds.fd_array[i], ml->hEventWrite,
+                        FD_WRITE | FD_CONNECT | FD_CLOSE);
+      }
+      if (wakeup)
+        SetEvent (ml->hEventWrite);
+      fd_counter += 1;
+      sock_write = wfds->sds.fd_count;
+    }
+    if ((efds != NULL) && (efds->sds.fd_count > 0))
+    {
 #if DEBUG_EVENTLOOP
-          GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, 
-                      "Adding the socket error event to the array as %d\n",
-                      fd_counter);
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "Adding the socket error event to the array as %d\n",
+                  fd_counter);
 #endif
-          ml->cached_poll_array[fd_counter].fd = (intptr_t) ml->hEventException;
-          ml->cached_poll_array[fd_counter].events = G_IO_ERR;
-          for (i = 0; i < efds->sds.fd_count; i++)
-            WSAEventSelect (efds->sds.fd_array[i], ml->hEventException, FD_OOB | FD_CLOSE);
-          fd_counter++;
-          sock_err = efds->sds.fd_count;
-        }
-      break;
+      ml->cached_poll_array[fd_counter].fd = (intptr_t) ml->hEventException;
+      ml->cached_poll_array[fd_counter].events = G_IO_ERR;
+      for (i = 0; i < efds->sds.fd_count; i++)
+        WSAEventSelect (efds->sds.fd_array[i], ml->hEventException,
+                        FD_OOB | FD_CLOSE);
+      fd_counter++;
+      sock_err = efds->sds.fd_count;
     }
+    break;
+  }
   socks = sock_read + sock_write + sock_err;
 #endif
 
   /* combine with Gtk events */
   g_main_context_prepare (ml->gmc, &max_priority);
   while (1)
-    {
-      need_gfds = g_main_context_query (ml->gmc,
-                                        max_priority,
-                                        &delay,
-                                        &ml->cached_poll_array[fd_counter], 
-                                        ml->cached_poll_array_size - fd_counter);
-      if (ml->cached_poll_array_size >= need_gfds + fd_counter)
-        break;
-      resize_cached_poll_array (ml,
-                                fd_counter + need_gfds);
-    }
+  {
+    need_gfds =
+        g_main_context_query (ml->gmc, max_priority, &delay,
+                              &ml->cached_poll_array[fd_counter],
+                              ml->cached_poll_array_size - fd_counter);
+    if (ml->cached_poll_array_size >= need_gfds + fd_counter)
+      break;
+    resize_cached_poll_array (ml, fd_counter + need_gfds);
+  }
 
   if (timeout.rel_value != GNUNET_TIME_UNIT_FOREVER_REL.rel_value)
-    {
-      if (delay >= 0)
-        delay = GNUNET_MIN (timeout.rel_value / GNUNET_TIME_UNIT_MILLISECONDS.rel_value, 
-                            delay);
-      else
-        delay = timeout.rel_value / GNUNET_TIME_UNIT_MILLISECONDS.rel_value;
-    }
+  {
+    if (delay >= 0)
+      delay =
+          GNUNET_MIN (timeout.rel_value /
+                      GNUNET_TIME_UNIT_MILLISECONDS.rel_value, delay);
+    else
+      delay = timeout.rel_value / GNUNET_TIME_UNIT_MILLISECONDS.rel_value;
+  }
 
 #if WINDOWS
   if (pre_ret > 0)
-    {
+  {
 #if DEBUG_EVENTLOOP
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "pre_ret is %d, setting delay to 0\n",
-                  pre_ret);
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "pre_ret is %d, setting delay to 0\n",
+                pre_ret);
 #endif
-      delay = 0;
-    }
+    delay = 0;
+  }
 #endif
 
 #if DEBUG_EVENTLOOP
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, 
-              "We have %d of our FDs and %d of GMC ones, going to wait %6dms\n",
-              fd_counter, need_gfds, delay);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "We have %d of our FDs and %d of GMC ones, going to wait %6dms\n",
+              fd_counter, need_gfds, delay);
 #endif
 
-  poll_result = g_poll (ml->cached_poll_array,
-                        fd_counter + need_gfds, 
-                        delay);
+  poll_result = g_poll (ml->cached_poll_array, fd_counter + need_gfds, delay);
 #if DEBUG_EVENTLOOP
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "g_poll returned : %d\n", 
-              poll_result);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "g_poll returned : %d\n", poll_result);
 #endif
 
   /* Take care of GUI events.
@@ -590,12 +594,11 @@ gnunet_gtk_select (void *cls,
    * from within a task (currently we're not in a task, but in a select() call, remember)
    * Startup reason is used to pass the scheduler sanity check.
    */
-  if (TRUE == g_main_context_check (ml->gmc, 
-                                    max_priority,
-                                    &ml->cached_poll_array[fd_counter],
-                                    need_gfds))
+  if (TRUE ==
+      g_main_context_check (ml->gmc, max_priority,
+                            &ml->cached_poll_array[fd_counter], need_gfds))
     GNUNET_SCHEDULER_add_continuation (&dispatch_gtk_task, ml,
-                                       GNUNET_SCHEDULER_REASON_STARTUP);
+                                       GNUNET_SCHEDULER_REASON_STARTUP);
 
   /* Now map back GNUnet scheduler events ... */
 #if !WINDOWS
@@ -606,167 +609,177 @@ gnunet_gtk_select (void *cls,
   if (NULL != efds)
     GNUNET_NETWORK_fdset_zero (efds);
   for (i = 0; i < fd_counter; i++)
-    {
-      int set = 0;
-
-      if ( (NULL != rfds) &&
-           (set |= (FD_ISSET (ml->cached_poll_array[i].fd, &aread) &&
-                    (0 != (ml->cached_poll_array[i].revents & (G_IO_IN | G_IO_HUP | G_IO_ERR))))))
-        GNUNET_NETWORK_fdset_set_native (rfds, ml->cached_poll_array[i].fd);
-      if ( (NULL != wfds) &&
-           (set |= (FD_ISSET (ml->cached_poll_array[i].fd, &awrite) &&
-                    (0 != (ml->cached_poll_array[i].revents & (G_IO_OUT | G_IO_ERR))))))
-        GNUNET_NETWORK_fdset_set_native (wfds, ml->cached_poll_array[i].fd);
-      if ( (NULL != efds) &&
-           (set |= (FD_ISSET (ml->cached_poll_array[i].fd, &aexcept) &&
-                    (0 != (ml->cached_poll_array[i].revents & G_IO_ERR)))))
-        GNUNET_NETWORK_fdset_set_native (efds, ml->cached_poll_array[i].fd);
-      if (set)
-        result++;
-    }
+  {
+    int set = 0;
+
+    if ((NULL != rfds) &&
+        (set |=
+         (FD_ISSET (ml->cached_poll_array[i].fd, &aread) &&
+          (0 !=
+           (ml->
+            cached_poll_array[i].revents & (G_IO_IN | G_IO_HUP | G_IO_ERR))))))
+      GNUNET_NETWORK_fdset_set_native (rfds, ml->cached_poll_array[i].fd);
+    if ((NULL != wfds) &&
+        (set |=
+         (FD_ISSET (ml->cached_poll_array[i].fd, &awrite) &&
+          (0 != (ml->cached_poll_array[i].revents & (G_IO_OUT | G_IO_ERR))))))
+      GNUNET_NETWORK_fdset_set_native (wfds, ml->cached_poll_array[i].fd);
+    if ((NULL != efds) &&
+        (set |=
+         (FD_ISSET (ml->cached_poll_array[i].fd, &aexcept) &&
+          (0 != (ml->cached_poll_array[i].revents & G_IO_ERR)))))
+      GNUNET_NETWORK_fdset_set_native (efds, ml->cached_poll_array[i].fd);
+    if (set)
+      result++;
+  }
 #else
   if (socks > 0)
-    {
-      struct timeval tvslice;
-      tvslice.tv_sec = 0;
-      tvslice.tv_usec = 0;
-      select_ret = select (max_nfds, &aread, &awrite, &aexcept, &tvslice);
-      if (select_ret == -1)
-        select_ret = 0;
+  {
+    struct timeval tvslice;
+
+    tvslice.tv_sec = 0;
+    tvslice.tv_usec = 0;
+    select_ret = select (max_nfds, &aread, &awrite, &aexcept, &tvslice);
+    if (select_ret == -1)
+      select_ret = 0;
 #if DEBUG_EVENTLOOP
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, 
-                  "select() returned %d\n", 
-                  select_ret);
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "select() returned %d\n", select_ret);
 #endif
-    }
-  if (always_ready_write_fd >= 0 && ml->cached_poll_array[always_ready_write_fd].revents & G_IO_OUT)
-    {
-      GNUNET_CONTAINER_slist_append (ml->handles_write, wfds->handles);
-      result += GNUNET_CONTAINER_slist_count (ml->handles_write);
+  }
+  if (always_ready_write_fd >= 0 &&
+      ml->cached_poll_array[always_ready_write_fd].revents & G_IO_OUT)
+  {
+    GNUNET_CONTAINER_slist_append (ml->handles_write, wfds->handles);
+    result += GNUNET_CONTAINER_slist_count (ml->handles_write);
 #if DEBUG_EVENTLOOP
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Added write pipe\n");
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Added write pipe\n");
 #endif
-    }
+  }
   for (i = 0; i < read_handles; i++)
-    {
-      DWORD error;
-      BOOL bret;
-      if (!(ml->cached_poll_array[i].revents & (G_IO_IN | G_IO_HUP | G_IO_ERR)))
-        continue;
-      SetLastError (0);
-      waitstatus = 0;
-      bret = PeekNamedPipe (ml->read_array[i]->h, NULL, 0, NULL, &waitstatus, NULL);
-      error = GetLastError ();
+  {
+    DWORD error;
+    BOOL bret;
+
+    if (!(ml->cached_poll_array[i].revents & (G_IO_IN | G_IO_HUP | G_IO_ERR)))
+      continue;
+    SetLastError (0);
+    waitstatus = 0;
+    bret =
+        PeekNamedPipe (ml->read_array[i]->h, NULL, 0, NULL, &waitstatus, NULL);
+    error = GetLastError ();
 #if DEBUG_EVENTLOOP
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, 
-                  "Peek at read pipe %d (0x%x) returned %d (%d bytes available) GLE %u\n", 
-                  i, ml->read_array[i]->h, bret, waitstatus, error);
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Peek at read pipe %d (0x%x) returned %d (%d bytes available) GLE %u\n",
+                i, ml->read_array[i]->h, bret, waitstatus, error);
 #endif
-      if (bret == 0 || (ml->cached_poll_array[i].revents & G_IO_ERR))
-        {
-          if (efds != NULL)
-            {
-              struct GNUNET_CONTAINER_SList_Iterator *t;
-              for (t = GNUNET_CONTAINER_slist_begin (efds->handles), i = 0;
-                   GNUNET_CONTAINER_slist_end (t) != GNUNET_YES;
-                   GNUNET_CONTAINER_slist_next (t), i += 1)
-                {
-                  struct GNUNET_DISK_FileHandle *fh = GNUNET_CONTAINER_slist_get (t, NULL);
-                  if (fh == ml->read_array[i])
-                    {
-                      GNUNET_CONTAINER_slist_add (ml->handles_except,
-                                                  GNUNET_CONTAINER_SLIST_DISPOSITION_TRANSIENT,
-                                                  fh, sizeof (struct GNUNET_DISK_FileHandle));
-                      break;
-                    }
-                }
-              GNUNET_CONTAINER_slist_iter_destroy (t);
-            }
-        }
-      else if (waitstatus <= 0)
-        continue;
-      GNUNET_CONTAINER_slist_add (ml->handles_read,
-                                  GNUNET_CONTAINER_SLIST_DISPOSITION_TRANSIENT,
-                                  ml->read_array[i], sizeof (struct GNUNET_DISK_FileHandle));
-      result += 1;
+    if (bret == 0 || (ml->cached_poll_array[i].revents & G_IO_ERR))
+    {
+      if (efds != NULL)
+      {
+        struct GNUNET_CONTAINER_SList_Iterator *t;
+
+        for (t = GNUNET_CONTAINER_slist_begin (efds->handles), i = 0;
+             GNUNET_CONTAINER_slist_end (t) != GNUNET_YES;
+             GNUNET_CONTAINER_slist_next (t), i += 1)
+        {
+          struct GNUNET_DISK_FileHandle *fh =
+              GNUNET_CONTAINER_slist_get (t, NULL);
+          if (fh == ml->read_array[i])
+          {
+            GNUNET_CONTAINER_slist_add (ml->handles_except,
+                                        GNUNET_CONTAINER_SLIST_DISPOSITION_TRANSIENT,
+                                        fh,
+                                        sizeof (struct GNUNET_DISK_FileHandle));
+            break;
+          }
+        }
+        GNUNET_CONTAINER_slist_iter_destroy (t);
+      }
+    }
+    else if (waitstatus <= 0)
+      continue;
+    GNUNET_CONTAINER_slist_add (ml->handles_read,
+                                GNUNET_CONTAINER_SLIST_DISPOSITION_TRANSIENT,
+                                ml->read_array[i],
+                                sizeof (struct GNUNET_DISK_FileHandle));
+    result += 1;
 #if DEBUG_EVENTLOOP
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, 
-                  "Added read Pipe 0x%x (0x%x)\n", 
-                  ml->read_array[i],
-                  ml->read_array[i]->h);
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Added read Pipe 0x%x (0x%x)\n",
+                ml->read_array[i], ml->read_array[i]->h);
 #endif
-    }
+  }
   waitstatus = WaitForSingleObject (ml->hEventWrite, 0);
 #if DEBUG_EVENTLOOP
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Wait for the write event returned %d\n", 
-              waitstatus);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Wait for the write event returned %d\n",
+              waitstatus);
 #endif
   if (waitstatus == WAIT_OBJECT_0)
+  {
+    for (i = 0; i < wfds->sds.fd_count; i++)
     {
-      for (i = 0; i < wfds->sds.fd_count; i++)
-        {
-          DWORD error;
-          int status;
-          int so_error = 0;
-          int sizeof_so_error = sizeof (so_error);
-          int gso_result = getsockopt (wfds->sds.fd_array[i], 
-                                       SOL_SOCKET, SO_ERROR,
-                                       (char *) &so_error, &sizeof_so_error);
-          status = send (wfds->sds.fd_array[i], NULL, 0, 0);
-          error = GetLastError ();
+      DWORD error;
+      int status;
+      int so_error = 0;
+      int sizeof_so_error = sizeof (so_error);
+      int gso_result = getsockopt (wfds->sds.fd_array[i],
+                                   SOL_SOCKET, SO_ERROR,
+                                   (char *) &so_error, &sizeof_so_error);
+
+      status = send (wfds->sds.fd_array[i], NULL, 0, 0);
+      error = GetLastError ();
 #if DEBUG_EVENTLOOP
-          GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, 
-                      "send to the socket %d returned %d (%u)\n", 
-                      i, status, error);
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "send to the socket %d returned %d (%u)\n", i, status, error);
 #endif
-          if (status == 0
-              || (error != WSAEWOULDBLOCK && error != WSAENOTCONN)
-              || (status == -1 && gso_result == 0 && error == WSAENOTCONN && so_error == WSAECONNREFUSED))
-            {
-              FD_SET (wfds->sds.fd_array[i], &awrite);
-              result += 1;
-            }
-        }
+      if (status == 0 || (error != WSAEWOULDBLOCK && error != WSAENOTCONN) ||
+          (status == -1 && gso_result == 0 && error == WSAENOTCONN &&
+           so_error == WSAECONNREFUSED))
+      {
+        FD_SET (wfds->sds.fd_array[i], &awrite);
+        result += 1;
+      }
     }
+  }
   if (rfds)
+  {
+    struct GNUNET_CONTAINER_SList_Iterator *t;
+
+    for (i = 0; i < rfds->sds.fd_count; i++)
+      WSAEventSelect (rfds->sds.fd_array[i], ml->hEventRead, 0);
+    for (t = GNUNET_CONTAINER_slist_begin (rfds->handles);
+         GNUNET_CONTAINER_slist_end (t) != GNUNET_YES;
+         GNUNET_CONTAINER_slist_next (t))
     {
-      struct GNUNET_CONTAINER_SList_Iterator *t;
-      for (i = 0; i < rfds->sds.fd_count; i++)
-        WSAEventSelect (rfds->sds.fd_array[i], ml->hEventRead, 0);
-      for (t = GNUNET_CONTAINER_slist_begin (rfds->handles);
-           GNUNET_CONTAINER_slist_end (t) != GNUNET_YES;
-           GNUNET_CONTAINER_slist_next (t))
-        {
-          struct GNUNET_DISK_FileHandle *fh = GNUNET_CONTAINER_slist_get (t, NULL);
-          if (fh->type == GNUNET_PIPE)
-            CancelIo (fh->h);
-        }
-      GNUNET_CONTAINER_slist_iter_destroy (t);
-      GNUNET_NETWORK_fdset_zero (rfds);
-      if (select_ret != -1 && socks > 0)
-        GNUNET_NETWORK_fdset_copy_native (rfds, &aread, select_ret);
-      GNUNET_CONTAINER_slist_append (rfds->handles, ml->handles_read);
+      struct GNUNET_DISK_FileHandle *fh = GNUNET_CONTAINER_slist_get (t, NULL);
+
+      if (fh->type == GNUNET_PIPE)
+        CancelIo (fh->h);
     }
+    GNUNET_CONTAINER_slist_iter_destroy (t);
+    GNUNET_NETWORK_fdset_zero (rfds);
+    if (select_ret != -1 && socks > 0)
+      GNUNET_NETWORK_fdset_copy_native (rfds, &aread, select_ret);
+    GNUNET_CONTAINER_slist_append (rfds->handles, ml->handles_read);
+  }
   if (wfds)
-    {
-      for (i = 0; i < wfds->sds.fd_count; i++)
-        WSAEventSelect (wfds->sds.fd_array[i], ml->hEventWrite, 0);
-      GNUNET_NETWORK_fdset_zero (wfds);
-      if (select_ret != -1 && socks > 0)
-        GNUNET_NETWORK_fdset_copy_native (wfds, &awrite, select_ret);
-      GNUNET_CONTAINER_slist_append (wfds->handles, ml->handles_write);
-    }
+  {
+    for (i = 0; i < wfds->sds.fd_count; i++)
+      WSAEventSelect (wfds->sds.fd_array[i], ml->hEventWrite, 0);
+    GNUNET_NETWORK_fdset_zero (wfds);
+    if (select_ret != -1 && socks > 0)
+      GNUNET_NETWORK_fdset_copy_native (wfds, &awrite, select_ret);
+    GNUNET_CONTAINER_slist_append (wfds->handles, ml->handles_write);
+  }
   if (efds)
-    {
-      for (i = 0; i < efds->sds.fd_count; i++)
-        WSAEventSelect (efds->sds.fd_array[i], ml->hEventException, 0);
-      GNUNET_NETWORK_fdset_zero (efds);
-      if (select_ret != -1 && socks > 0)
-        GNUNET_NETWORK_fdset_copy_native (efds, &aexcept, select_ret);
-      GNUNET_CONTAINER_slist_append (efds->handles, ml->handles_except);
-      result += GNUNET_CONTAINER_slist_count (ml->handles_except);
-    }
+  {
+    for (i = 0; i < efds->sds.fd_count; i++)
+      WSAEventSelect (efds->sds.fd_array[i], ml->hEventException, 0);
+    GNUNET_NETWORK_fdset_zero (efds);
+    if (select_ret != -1 && socks > 0)
+      GNUNET_NETWORK_fdset_copy_native (efds, &aexcept, select_ret);
+    GNUNET_CONTAINER_slist_append (efds->handles, ml->handles_except);
+    result += GNUNET_CONTAINER_slist_count (ml->handles_except);
+  }
   if (fd_counter > 0)
     /* This is not accurate (select_ret counts write-ready sockets,
      * and result does as well. Anything out there actually cares
@@ -789,19 +802,18 @@ gnunet_gtk_select (void *cls,
  * @param args leftover command line arguments (go to gtk)
  * @param cfgfile name of the configuration file
  * @param cfg handle to the configuration
- */                   
+ */
 static void
-run_main_loop (void *cls,
-               char *const *args,
-               const char *cfgfile,
-               const struct GNUNET_CONFIGURATION_Handle *cfg)
+run_main_loop (void *cls, char *const *args, const char *cfgfile,
+               const struct GNUNET_CONFIGURATION_Handle *cfg)
 {
   struct GNUNET_GTK_MainLoop *ml = cls;
   int argc;
- 
+
   /* command-line processing for Gtk arguments */
   argc = 0;
-  while (args[argc] != NULL) argc++;
+  while (args[argc] != NULL)
+    argc++;
   gtk_init (&argc, (char ***) &args);
 
   /* setup main context */
@@ -828,16 +840,16 @@ run_main_loop (void *cls,
 
   /* run main task of the application */
   GNUNET_SCHEDULER_add_continuation (ml->main_task, ml,
-                                     GNUNET_SCHEDULER_REASON_STARTUP);
+                                     GNUNET_SCHEDULER_REASON_STARTUP);
 
   /* start the Gtk event loop */
   GNUNET_assert (TRUE == g_main_context_acquire (ml->gmc));
   GNUNET_SCHEDULER_set_select (&gnunet_gtk_select, ml);
 
   /* keep Gtk event loop running even if there are no GNUnet tasks */
-  ml->dummy_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_FOREVER_REL,
-                                                 &keepalive_task,
-                                                 ml);
+  ml->dummy_task =
+      GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_FOREVER_REL,
+                                    &keepalive_task, ml);
 
 }
 
@@ -855,13 +867,11 @@ run_main_loop (void *cls,
  * @return GNUNET_OK on success, GNUNET_SYSERR on error (i.e. bad command-line options, etc)
  */
 int
-GNUNET_GTK_main_loop_start (const char *binary_name,
-                            const char *binary_help,
-                            int argc,
-                            char *const*argv,
-                            struct GNUNET_GETOPT_CommandLineOption *options,
-                            const char *main_window_file,
-                            GNUNET_SCHEDULER_Task main_task)
+GNUNET_GTK_main_loop_start (const char *binary_name, const char *binary_help,
+                            int argc, char *const *argv,
+                            struct GNUNET_GETOPT_CommandLineOption *options,
+                            const char *main_window_file,
+                            GNUNET_SCHEDULER_Task main_task)
 {
   struct GNUNET_GTK_MainLoop ml;
   int ret;
@@ -869,11 +879,9 @@ GNUNET_GTK_main_loop_start (const char *binary_name,
   memset (&ml, 0, sizeof (ml));
   ml.main_window_file = main_window_file;
   ml.main_task = main_task;
-  ret = GNUNET_PROGRAM_run (argc, argv,
-                            binary_name,
-                            "GTK GUI for GNUnet",
-                            options,
-                            &run_main_loop, &ml);
+  ret =
+      GNUNET_PROGRAM_run (argc, argv, binary_name, "GTK GUI for GNUnet",
+                          options, &run_main_loop, &ml);
   if (NULL != ml.cached_poll_array)
     g_free (ml.cached_poll_array);
   if (NULL != ml.rs)