6 files changed, 545 insertions, 560 deletions

diff --git a/src/lib/about.c b/src/lib/about.c
index e75e11dc..095ce21a 100644
--- a/src/lib/about.c
+++ b/src/lib/about.c
@@ -33,8 +33,7 @@
  * @param dialogname name of the about dialog in the file
  */
 void
-GNUNET_GTK_display_about (const char *dialogfile,
-                          const char *dialogname)
+GNUNET_GTK_display_about (const char *dialogfile, const char *dialogname)
 {
   GtkBuilder *builder;
   GtkWidget *ad;
@@ -42,8 +41,7 @@ GNUNET_GTK_display_about (const char *dialogfile,
   builder = GNUNET_GTK_get_new_builder (dialogfile);
   if (builder == NULL)
     return;
-  ad = GTK_WIDGET (gtk_builder_get_object (builder,
-                                           dialogname));
+  ad = GTK_WIDGET (gtk_builder_get_object (builder, dialogname));
   gtk_dialog_run (GTK_DIALOG (ad));
   gtk_widget_destroy (ad);
   g_object_unref (G_OBJECT (builder));
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)
diff --git a/src/lib/glade.c b/src/lib/glade.c
index 3853ea93..b230bd1c 100644
--- a/src/lib/glade.c
+++ b/src/lib/glade.c
@@ -74,21 +74,16 @@ GNUNET_GTK_get_new_builder (const char *filename)
 
   ret = gtk_builder_new ();
   gtk_builder_set_translation_domain (ret, "gnunet-gtk");
-  GNUNET_asprintf (&glade_path,
-                   "%s%s",
-                   GNUNET_GTK_get_data_dir (),
-                   filename);
+  GNUNET_asprintf (&glade_path, "%s%s", GNUNET_GTK_get_data_dir (), filename);
   error = NULL;
   if (0 == gtk_builder_add_from_file (ret, glade_path, &error))
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                  _("Failed to load `%s': %s\n"),
-                  glade_path,
-                  error->message);
-      g_error_free (error);
-      GNUNET_free (glade_path);
-      return NULL;
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR, _("Failed to load `%s': %s\n"),
+                glade_path, error->message);
+    g_error_free (error);
+    GNUNET_free (glade_path);
+    return NULL;
+  }
   gtk_builder_connect_signals (ret, NULL);
   GNUNET_free (glade_path);
   return ret;
diff --git a/src/lib/nls.c b/src/lib/nls.c
index 96e44a99..a040f8e5 100644
--- a/src/lib/nls.c
+++ b/src/lib/nls.c
@@ -40,10 +40,8 @@ GNUNET_GTK_setup_nls ()
   char *path;
 
   setlocale (LC_ALL, "");
-  GNUNET_asprintf (&path,
-                   "%s/%s/locale/",
-                   GNUNET_GTK_get_data_dir (),
-                   PACKAGE_NAME);
+  GNUNET_asprintf (&path, "%s/%s/locale/", GNUNET_GTK_get_data_dir (),
+                   PACKAGE_NAME);
   bindtextdomain ("gnunet-gtk", path);
   textdomain ("gnunet-gtk");
   bind_textdomain_codeset ("GNUnet", "UTF-8");
@@ -51,7 +49,7 @@ GNUNET_GTK_setup_nls ()
   GNUNET_free (path);
 #else
   fprintf (stderr,
-           "WARNING: gnunet-gtk was compiled without i18n support (did CFLAGS contain -Werror?).\n");
+           "WARNING: gnunet-gtk was compiled without i18n support (did CFLAGS contain -Werror?).\n");
 #endif
 }
 
diff --git a/src/lib/os_installation.c b/src/lib/os_installation.c
index 9a884f27..b6927874 100644
--- a/src/lib/os_installation.c
+++ b/src/lib/os_installation.c
@@ -50,25 +50,21 @@ get_path_from_proc_maps ()
   FILE *f;
   char *lgu;
 
-  GNUNET_snprintf (fn,
-                   sizeof(fn), 
-                   "/proc/%u/maps", 
-                   getpid ());
+  GNUNET_snprintf (fn, sizeof (fn), "/proc/%u/maps", getpid ());
   f = fopen (fn, "r");
   if (f == NULL)
     return NULL;
-  while (NULL != fgets (line, sizeof(line), f))
+  while (NULL != fgets (line, sizeof (line), f))
+  {
+    if ((1 ==
+         sscanf (line, "%*x-%*x %*c%*c%*c%*c %*x %*2u:%*2u %*u%*[ ]%s", dir)) &&
+        (NULL != (lgu = strstr (dir, "gnunet-gtk"))))
     {
-      if ((1 == sscanf (line,
-                        "%*x-%*x %*c%*c%*c%*c %*x %*2u:%*2u %*u%*[ ]%s",
-                        dir)) &&
-          (NULL != (lgu = strstr (dir, "gnunet-gtk"))))
-        {
-          lgu[0] = '\0';
-          fclose (f);
-          return GNUNET_strdup (dir);
-        }
+      lgu[0] = '\0';
+      fclose (f);
+      return GNUNET_strdup (dir);
     }
+  }
   fclose (f);
   return NULL;
 }
@@ -83,23 +79,22 @@ get_path_from_proc_exe ()
   char lnk[1024];
   ssize_t size;
 
-  GNUNET_snprintf (fn, 
-                   sizeof(fn), "/proc/%u/exe", getpid ());
-  size = readlink (fn, lnk, sizeof (lnk)-1);
+  GNUNET_snprintf (fn, sizeof (fn), "/proc/%u/exe", getpid ());
+  size = readlink (fn, lnk, sizeof (lnk) - 1);
   if (size <= 0)
-    {
-      GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_ERROR, "readlink", fn);
-      return NULL;
-    }
+  {
+    GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_ERROR, "readlink", fn);
+    return NULL;
+  }
   GNUNET_assert (size < sizeof (lnk));
   lnk[size] = '\0';
   while ((lnk[size] != '/') && (size > 0))
     size--;
   if ((size < 4) || (lnk[size - 4] != '/'))
-    {
-      /* not installed in "/bin/" -- binary path probably useless */
-      return NULL;
-    }
+  {
+    /* not installed in "/bin/" -- binary path probably useless */
+    return NULL;
+  }
   lnk[size] = '\0';
   return GNUNET_strdup (lnk);
 }
@@ -115,7 +110,7 @@ get_path_from_module_filename ()
   char path[4097];
   char *idx;
 
-  GetModuleFileName (NULL, path, sizeof(path)-1);
+  GetModuleFileName (NULL, path, sizeof (path) - 1);
   idx = path + strlen (path);
   while ((idx > path) && (*idx != '\\') && (*idx != '/'))
     idx--;
@@ -138,7 +133,7 @@ get_path_from_NSGetExecutablePath ()
 
   path = NULL;
   func =
-    (MyNSGetExecutablePathProto) dlsym (RTLD_DEFAULT, "_NSGetExecutablePath");
+      (MyNSGetExecutablePathProto) dlsym (RTLD_DEFAULT, "_NSGetExecutablePath");
   if (!func)
     return NULL;
   path = &zero;
@@ -150,10 +145,10 @@ get_path_from_NSGetExecutablePath ()
   path = GNUNET_malloc (len);
   ret = func (path, &len);
   if (ret != 0)
-    {
-      GNUNET_free (path);
-      return NULL;
-    }
+  {
+    GNUNET_free (path);
+    return NULL;
+  }
   len = strlen (path);
   while ((path[len] != '/') && (len > 0))
     len--;
@@ -172,22 +167,22 @@ get_path_from_dyld_image ()
   p = NULL;
   c = _dyld_image_count ();
   for (i = 0; i < c; i++)
+  {
+    if (_dyld_get_image_header (i) == &_mh_dylib_header)
     {
-      if (_dyld_get_image_header (i) == &_mh_dylib_header)
-        {
-          path = _dyld_get_image_name (i);
-          if (path != NULL && strlen (path) > 0)
-            {
-              p = strdup (path);
-              s = p + strlen (p);
-              while ((s > p) && (*s != '/'))
-                s--;
-              s++;
-              *s = '\0';
-            }
-          break;
-        }
+      path = _dyld_get_image_name (i);
+      if (path != NULL && strlen (path) > 0)
+      {
+        p = strdup (path);
+        s = p + strlen (p);
+        while ((s > p) && (*s != '/'))
+          s--;
+        s++;
+        *s = '\0';
+      }
+      break;
     }
+  }
   return p;
 }
 #endif
@@ -209,26 +204,26 @@ get_path_from_PATH ()
   pos = path;
 
   while (NULL != (end = strchr (pos, ':')))
-    {
-      *end = '\0';
-      sprintf (buf, "%s/%s", pos, "gnunet-gtk");
-      if (GNUNET_DISK_file_test (buf) == GNUNET_YES)
-        {
-          pos = GNUNET_strdup (pos);
-          GNUNET_free (buf);
-          GNUNET_free (path);
-          return pos;
-        }
-      pos = end + 1;
-    }
-  sprintf (buf, "%s/%s", pos, "gnunet-gtk");
-  if (GNUNET_DISK_file_test (buf) == GNUNET_YES)
+  {
+    *end = '\0';
+    sprintf (buf, "%s/%s", pos, "gnunet-gtk");
+    if (GNUNET_DISK_file_test (buf) == GNUNET_YES)
     {
       pos = GNUNET_strdup (pos);
       GNUNET_free (buf);
       GNUNET_free (path);
       return pos;
     }
+    pos = end + 1;
+  }
+  sprintf (buf, "%s/%s", pos, "gnunet-gtk");
+  if (GNUNET_DISK_file_test (buf) == GNUNET_YES)
+  {
+    pos = GNUNET_strdup (pos);
+    GNUNET_free (buf);
+    GNUNET_free (path);
+    return pos;
+  }
   GNUNET_free (buf);
   GNUNET_free (path);
   return NULL;
@@ -290,8 +285,7 @@ os_get_gnunet_path ()
   GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
               _
               ("Could not determine installation path for %s.  Set `%s' environment variable.\n"),
-              "gnunet-gtk",
-              "GNUNET_GTK_PREFIX");
+              "gnunet-gtk", "GNUNET_GTK_PREFIX");
   return NULL;
 }
 
@@ -357,11 +351,11 @@ GNUNET_GTK_installation_get_path (enum GNUNET_OS_InstallationPathKind dirkind)
 
   n = strlen (execpath);
   if (n == 0)
-    {
-      /* should never happen, but better safe than sorry */
-      GNUNET_free (execpath);
-      return NULL;
-    }
+  {
+    /* should never happen, but better safe than sorry */
+    GNUNET_free (execpath);
+    return NULL;
+  }
   /* remove filename itself */
   while ((n > 1) && (execpath[n - 1] == DIR_SEPARATOR))
     execpath[--n] = '\0';
@@ -370,62 +364,61 @@ GNUNET_GTK_installation_get_path (enum GNUNET_OS_InstallationPathKind dirkind)
   if ((n > 5) &&
       ((0 == strcasecmp (&execpath[n - 5], "lib32")) ||
        (0 == strcasecmp (&execpath[n - 5], "lib64"))))
+  {
+    if (dirkind != GNUNET_OS_IPK_LIBDIR)
     {
-      if (dirkind != GNUNET_OS_IPK_LIBDIR)
-        {
-          /* strip '/lib32' or '/lib64' */
-          execpath[n - 5] = '\0';
-          n -= 5;
-        }
-      else
-        isbasedir = 0;
+      /* strip '/lib32' or '/lib64' */
+      execpath[n - 5] = '\0';
+      n -= 5;
     }
+    else
+      isbasedir = 0;
+  }
   else if ((n > 3) &&
            ((0 == strcasecmp (&execpath[n - 3], "bin")) ||
             (0 == strcasecmp (&execpath[n - 3], "lib"))))
-    {
-      /* strip '/bin' or '/lib' */
-      execpath[n - 3] = '\0';
-      n -= 3;
-    }
+  {
+    /* strip '/bin' or '/lib' */
+    execpath[n - 3] = '\0';
+    n -= 3;
+  }
   /* in case this was a directory named foo-bin, remove "foo-" */
   while ((n > 1) && (execpath[n - 1] == DIR_SEPARATOR))
     execpath[--n] = '\0';
   switch (dirkind)
-    {
-    case GNUNET_OS_IPK_PREFIX:
-    case GNUNET_OS_IPK_SELF_PREFIX:
-      dirname = DIR_SEPARATOR_STR;
-      break;
-    case GNUNET_OS_IPK_BINDIR:
-      dirname = DIR_SEPARATOR_STR "bin" DIR_SEPARATOR_STR;
-      break;
-    case GNUNET_OS_IPK_LIBDIR:
-      if (isbasedir)
-        dirname =
+  {
+  case GNUNET_OS_IPK_PREFIX:
+  case GNUNET_OS_IPK_SELF_PREFIX:
+    dirname = DIR_SEPARATOR_STR;
+    break;
+  case GNUNET_OS_IPK_BINDIR:
+    dirname = DIR_SEPARATOR_STR "bin" DIR_SEPARATOR_STR;
+    break;
+  case GNUNET_OS_IPK_LIBDIR:
+    if (isbasedir)
+      dirname =
           DIR_SEPARATOR_STR "lib" DIR_SEPARATOR_STR "gnunet-gtk"
           DIR_SEPARATOR_STR;
-      else
-        dirname = DIR_SEPARATOR_STR "gnunet-gtk" DIR_SEPARATOR_STR;
-      break;
-    case GNUNET_OS_IPK_DATADIR:
-      dirname =
+    else
+      dirname = DIR_SEPARATOR_STR "gnunet-gtk" DIR_SEPARATOR_STR;
+    break;
+  case GNUNET_OS_IPK_DATADIR:
+    dirname =
         DIR_SEPARATOR_STR "share" DIR_SEPARATOR_STR "gnunet-gtk"
         DIR_SEPARATOR_STR;
-      break;
-    case GNUNET_OS_IPK_ICONDIR:
-      dirname =
+    break;
+  case GNUNET_OS_IPK_ICONDIR:
+    dirname =
         DIR_SEPARATOR_STR "share" DIR_SEPARATOR_STR "icons" DIR_SEPARATOR_STR;
-      break;
-   case GNUNET_OS_IPK_LOCALEDIR:
-      dirname =
-        DIR_SEPARATOR_STR "share" DIR_SEPARATOR_STR "locale"
-        DIR_SEPARATOR_STR;
-      break;
-    default:
-      GNUNET_free (execpath);
-      return NULL;
-    }
+    break;
+  case GNUNET_OS_IPK_LOCALEDIR:
+    dirname =
+        DIR_SEPARATOR_STR "share" DIR_SEPARATOR_STR "locale" DIR_SEPARATOR_STR;
+    break;
+  default:
+    GNUNET_free (execpath);
+    return NULL;
+  }
   tmp = GNUNET_malloc (strlen (execpath) + strlen (dirname) + 1);
   sprintf (tmp, "%s%s", execpath, dirname);
   GNUNET_free (execpath);
diff --git a/src/lib/trayicon.c b/src/lib/trayicon.c
index 200c9068..899f6db0 100644
--- a/src/lib/trayicon.c
+++ b/src/lib/trayicon.c
@@ -42,9 +42,8 @@ static GtkWindow *main_window;
  * We got a click on our tray icon. Toggle visibility of the main
  * window.
  */
-static void 
-tray_icon_on_click(GtkStatusIcon *status_icon, 
-                   gpointer user_data)
+static void
+tray_icon_on_click (GtkStatusIcon * status_icon, gpointer user_data)
 {
   if (gtk_window_is_active (main_window))
     gtk_widget_hide (GTK_WIDGET (main_window));
@@ -57,28 +56,27 @@ tray_icon_on_click(GtkStatusIcon *status_icon,
  * We got a right-click on the tray icon. Display the context
  * menu (which should have a 'quit' button).
  */
-static int 
-tray_icon_on_menu(GtkWidget *widget, 
-                  GdkEvent *event,
-                  gpointer user_data)
+static int
+tray_icon_on_menu (GtkWidget * widget, GdkEvent * event, gpointer user_data)
 {
   GtkMenu *tray_menu;
   GdkEventButton *event_button;
   GtkBuilder *builder;
- 
+
   if (event->type == GDK_BUTTON_PRESS)
+  {
+    event_button = (GdkEventButton *) event;
+    if (event_button->button == 3)
     {
-      event_button = (GdkEventButton *) event;      
-      if (event_button->button == 3)
-        {
-          builder = GNUNET_GTK_get_new_builder ("gnunet_gtk_status_bar_menu.glade");
-          tray_menu = GTK_MENU (gtk_builder_get_object (builder,
-                                                        "GNUNET_GTK_status_bar_popup_menu"));
-          gtk_menu_popup (tray_menu, NULL, NULL, NULL, NULL,
-                          event_button->button, event_button->time);
-          g_object_unref (builder);
-        }
+      builder = GNUNET_GTK_get_new_builder ("gnunet_gtk_status_bar_menu.glade");
+      tray_menu =
+          GTK_MENU (gtk_builder_get_object
+                    (builder, "GNUNET_GTK_status_bar_popup_menu"));
+      gtk_menu_popup (tray_menu, NULL, NULL, NULL, NULL, event_button->button,
+                      event_button->time);
+      g_object_unref (builder);
     }
+  }
   return FALSE;
 }
 
@@ -91,35 +89,30 @@ tray_icon_on_menu(GtkWidget *widget,
  * @param tooltip tooltip for the tray icon
  */
 void
-GNUNET_GTK_tray_icon_create (GtkWindow *main,
-                             const char *icon_name,
-                             const char *tooltip)
+GNUNET_GTK_tray_icon_create (GtkWindow * main, const char *icon_name,
+                             const char *tooltip)
 {
   if (NULL != tray_icon)
-    {
-      GNUNET_break (0);
-      return;
-    }
+  {
+    GNUNET_break (0);
+    return;
+  }
   main_window = main;
-  tray_icon = gtk_status_icon_new();
-  g_signal_connect(G_OBJECT(tray_icon), "activate", 
-                   G_CALLBACK(tray_icon_on_click), NULL);
-  g_signal_connect (G_OBJECT(tray_icon), 
-                    "button_press_event",
-                    G_CALLBACK(tray_icon_on_menu), 
-                    tray_icon);
-  gtk_status_icon_set_from_icon_name (tray_icon, 
-                                      icon_name);
-  gtk_status_icon_set_tooltip(tray_icon, 
-                              tooltip);
-  gtk_status_icon_set_visible(tray_icon, TRUE); 
+  tray_icon = gtk_status_icon_new ();
+  g_signal_connect (G_OBJECT (tray_icon), "activate",
+                    G_CALLBACK (tray_icon_on_click), NULL);
+  g_signal_connect (G_OBJECT (tray_icon), "button_press_event",
+                    G_CALLBACK (tray_icon_on_menu), tray_icon);
+  gtk_status_icon_set_from_icon_name (tray_icon, icon_name);
+  gtk_status_icon_set_tooltip (tray_icon, tooltip);
+  gtk_status_icon_set_visible (tray_icon, TRUE);
 }
 
 
 /**
  * Destroy the tray icon.
  */
-void 
+void
 GNUNET_GTK_tray_icon_destroy ()
 {
   if (tray_icon == NULL)