draft for new libgnunetgtk

8 files changed, 1622 insertions, 0 deletions

diff --git a/src/include/Makefile.am b/src/include/Makefile.am
new file mode 100644
index 00000000..ef58f075
--- /dev/null
+++ b/src/include/Makefile.am
@@ -0,0 +1,6 @@
+SUBDIRS = .
+
+gnunetgtkincludedir = $(includedir)/gnunet
+
+gnunetgtkinclude_HEADERS = \
+  gnunet_gtk.h 
diff --git a/src/include/gnunet_gtk.h b/src/include/gnunet_gtk.h
new file mode 100644
index 00000000..4403ab4b
--- /dev/null
+++ b/src/include/gnunet_gtk.h
@@ -0,0 +1,154 @@
+/*
+     This file is part of GNUnet.
+     (C) 2011 Christian Grothoff (and other contributing authors)
+
+     GNUnet is free software; you can redistribute it and/or modify
+     it under the terms of the GNU General Public License as published
+     by the Free Software Foundation; either version 2, or (at your
+     option) any later version.
+
+     GNUnet is distributed in the hope that it will be useful, but
+     WITHOUT ANY WARRANTY; without even the implied warranty of
+     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+     General Public License for more details.
+
+     You should have received a copy of the GNU General Public License
+     along with GNUnet; see the file COPYING.  If not, write to the
+     Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+     Boston, MA 02111-1307, USA.
+*/
+
+/**
+ * @file src/include/gnunet_gtk.h
+ * @brief Helper library for Gtk user interfaces to GNUnet
+ * @author Christian Grothoff
+ */
+#ifndef GNUNET_GTK_H
+#define GNUNET_GTK_H
+
+#ifndef HAVE_USED_CONFIG_H
+#define HAVE_USED_CONFIG_H
+#if HAVE_CONFIG_H
+#include "gnunet_gtk_config.h"
+#endif
+#endif
+
+#include <gnunet/platform.h>
+#include <gnunet/gnunet_util_lib.h>
+#include <gnunet/gnunet_fs_service.h>
+#include <extractor.h>
+#include <gladeui/glade.h>
+#include <gtk/gtk.h>
+
+
+/**
+ * Initialize natural language support.
+ */
+void
+GNUNET_GTK_setup_nls (void);
+
+
+/**
+ * Get the name of the directory where all of our package
+ * data is stored ($PREFIX/share/)
+ * 
+ * @return name of the data directory
+ */
+const char *
+GNUNET_GTK_get_data_dir (void);
+
+
+/**
+ * @brief get the path to a specific GNUnet installation directory or,
+ * with GNUNET_IPK_SELF_PREFIX, the current running apps installation directory
+ * @author Milan
+ * @return a pointer to the dir path (to be freed by the caller)
+ */
+char *
+GNUNET_GTK_installation_get_path (enum GNUNET_OS_InstallationPathKind dirkind);
+
+
+/**
+ * Create an initialize a new builder based on the GNUnet-GTK glade
+ * file.
+ *
+ * @param filename name of the resource file to load
+ * @return NULL on error
+ */
+GtkBuilder *
+GNUNET_GTK_get_new_builder (const char *filename);
+
+
+/**
+ * This displays an about dialog.
+ *
+ * @param dialogfile name of the glade file containing the dialog
+ * @param dialogname name of the about dialog in the file
+ */
+void
+GNUNET_GTK_display_about (const char *dialogfile,
+                          const char *dialogname);
+
+
+/**
+ * Handle for our main loop.
+ */
+struct GNUNET_GTK_MainLoop;
+
+
+/**
+ * Initialize the main loop.
+ *
+ * @param binary_name binary name
+ * @param binary_help help text for the binary
+ * @param argc number of command line options
+ * @param argv command line options
+ * @param options allowed command line options
+ * @param main_window_file glade file for the main window
+ * @param main_task first task to run, closure will be set to the 'struct GNUNET_GTK_MainLoop'
+ * @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);
+
+
+/**
+ * Get an object from the main window.
+ *
+ * @param ml handle to the main loop
+ * @param name name of the object
+ * @return NULL on error, otherwise the object
+ */
+GObject *
+GNUNET_GTK_main_loop_get_object (struct GNUNET_GTK_MainLoop *ml,
+                                 const char *name);
+
+
+/**
+ * Get the configuration.
+ *
+ * @param ml handle to the main loop
+ * @return handle to the configuration, never NULL
+ */
+const struct GNUNET_CONFIGURATION_Handle *
+GNUNET_GTK_main_loop_get_configuration (struct GNUNET_GTK_MainLoop *ml);
+
+
+/**
+ * Trigger shutdown of the GUI and exit the main loop.
+ *
+ * @param ml handle to the main loop
+ */
+void
+GNUNET_GTK_main_loop_quit (struct GNUNET_GTK_MainLoop *ml);
+                    
+
+
+#endif
+/* end of gnunet_gtk.h */
diff --git a/src/lib/Makefile.am b/src/lib/Makefile.am
new file mode 100644
index 00000000..6a87dc4e
--- /dev/null
+++ b/src/lib/Makefile.am
@@ -0,0 +1,22 @@
+INCLUDES = \
+  -I$(top_srcdir)/ \
+  -I$(top_srcdir)/src/include \
+  @GTK_CFLAGS@ \
+  @GNUNET_CFLAGS@ \
+  @GLADE_CFLAGS@
+
+if MINGW
+  WINFLAGS = -Wl,--no-undefined -Wl,--export-all-symbols
+endif
+
+lib_LTLIBRARIES = libgnunetgtk.la
+
+libgnunetgtk_la_SOURCES = \
+  eventloop.c \
+  glade.c \
+  os_installation.c \
+  nls.c \
+  about.c 
+libgnunetgtk_la_LIBADD = \
+ -lgnunetutil $(XLIB)
+
diff --git a/src/lib/about.c b/src/lib/about.c
new file mode 100644
index 00000000..e75e11dc
--- /dev/null
+++ b/src/lib/about.c
@@ -0,0 +1,53 @@
+/*
+     This file is part of GNUnet
+     (C) 2005, 2006, 2010, 2011 Christian Grothoff (and other contributing authors)
+
+     GNUnet is free software; you can redistribute it and/or modify
+     it under the terms of the GNU General Public License as published
+     by the Free Software Foundation; either version 2, or (at your
+     option) any later version.
+
+     GNUnet is distributed in the hope that it will be useful, but
+     WITHOUT ANY WARRANTY; without even the implied warranty of
+     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+     General Public License for more details.
+
+     You should have received a copy of the GNU General Public License
+     along with GNUnet; see the file COPYING.  If not, write to the
+     Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+     Boston, MA 02111-1307, USA.
+*/
+
+/**
+ * @file src/lib/about.c
+ * @brief code to display an about dialog
+ * @author Christian Grothoff
+ * @author Igor Wronsky
+ */
+#include "gnunet_gtk.h"
+
+/**
+ * This displays an about dialog.
+ *
+ * @param dialogfile name of the glade file containing the dialog
+ * @param dialogname name of the about dialog in the file
+ */
+void
+GNUNET_GTK_display_about (const char *dialogfile,
+                          const char *dialogname)
+{
+  GtkBuilder *builder;
+  GtkWidget *ad;
+
+  builder = GNUNET_GTK_get_new_builder (dialogfile);
+  if (builder == NULL)
+    return;
+  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));
+}
+
+
+/* end of about.c */
diff --git a/src/lib/eventloop.c b/src/lib/eventloop.c
new file mode 100644
index 00000000..7eb7e060
--- /dev/null
+++ b/src/lib/eventloop.c
@@ -0,0 +1,809 @@
+/*
+     This file is part of GNUnet.
+     (C) 2010, 2011 Christian Grothoff (and other contributing authors)
+
+     GNUnet is free software; you can redistribute it and/or modify
+     it under the terms of the GNU General Public License as published
+     by the Free Software Foundation; either version 2, or (at your
+     option) any later version.
+
+     GNUnet is distributed in the hope that it will be useful, but
+     WITHOUT ANY WARRANTY; without even the implied warranty of
+     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+     General Public License for more details.
+
+     You should have received a copy of the GNU General Public License
+     along with GNUnet; see the file COPYING.  If not, write to the
+     Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+     Boston, MA 02111-1307, USA.
+*/
+
+/**
+ * @file src/lib/eventloop.c
+ * @brief code for merging GNUnet scheduler and Gtk Main Loop event loops
+ * @author Christian Grothoff
+ */
+#include "gnunet_gtk.h"
+
+
+/**
+ * Main context for our event loop.
+ */
+struct GNUNET_GTK_MainLoop
+{
+
+  /**
+   * Our configuration.
+   */
+  const struct GNUNET_CONFIGURATION_Handle *cfg;
+
+  /**
+   * Name of the glade file for the main window
+   */
+  const char *main_window_file;
+
+  /**
+   * Initial task to run to setup the system.
+   */
+  GNUNET_SCHEDULER_Task main_task;
+  
+  /**
+   * Builder for the main window.
+   */
+  GtkBuilder *builder; 
+
+  /**
+   * Gib's Main loop.
+   */
+  GMainLoop *gml;
+
+  /**
+   * GTK's main context.
+   */
+  GMainContext *gmc;
+
+  /**
+   * Read set.
+   */
+  struct GNUNET_NETWORK_FDSet *rs;
+
+  /**
+   * Write set.
+   */
+  struct GNUNET_NETWORK_FDSet *ws;
+
+  /**
+   * Recycled array of polling descriptors.
+   */
+  GPollFD *cached_poll_array;
+
+  /**
+   * Size of the 'cached_poll_array'.
+   */
+  guint cached_poll_array_size;
+
+  /**
+   * Return value from last g_main_context_query call.
+   */
+  guint poll_array_active;
+
+  /**
+   * Maximum GTK priority.
+   */
+  gint max_priority;
+
+
+#if WINDOWS
+  /**
+   * Array to hold pipe handles during a select() call
+   */
+  struct GNUNET_DISK_FileHandle **read_array;
+
+  /**
+   * Allocated length of read_array
+   */
+  int read_array_length;
+
+  /**
+   * Event to fire when a socket is ready for reading
+   */
+  HANDLE hEventRead;
+
+  /**
+   * Event to fire when a socket is ready for writing
+   */
+  HANDLE hEventWrite;
+
+  /**
+   * Event to fire when a socket had an error
+   */
+  HANDLE hEventException;
+
+  /**
+   * Event that is permanently enabled and is used to signal a pipe
+   * that is ready for writing (asynchronous pipes are always writable)
+   */
+  HANDLE hEventPipeWrite;
+
+  /**
+   * Event that is permanently enabled and is used to signal a pipe
+   * that is ready for reading (used to wake up early on a pipe that
+   * is known to be readable)
+   */
+  HANDLE hEventReadReady;
+
+  /**
+   * A list to hold file handles that are ready for reading
+   */
+  struct GNUNET_CONTAINER_SList *handles_read;
+
+  /**
+   * A list to hold file handles that are ready for writing
+   */
+  struct GNUNET_CONTAINER_SList *handles_write;
+
+  /**
+   * A list to hold file handles that are broken
+   */
+  struct GNUNET_CONTAINER_SList *handles_except;
+#endif
+
+};
+
+
+/**
+ * Get the configuration.
+ *
+ * @param ml handle to the main loop
+ * @return handle to the configuration, never NULL
+ */
+const struct GNUNET_CONFIGURATION_Handle *
+GNUNET_GTK_main_loop_get_configuration (struct GNUNET_GTK_MainLoop *ml)
+{
+  return ml->cfg;
+}
+
+
+/**
+ * Trigger shutdown of the GUI and exit the main loop.
+ *
+ * @param ml handle to the main loop
+ */
+void
+GNUNET_GTK_main_loop_quit (struct GNUNET_GTK_MainLoop *ml)
+{
+  g_main_loop_quit (ml->gml);
+}
+
+
+/**
+ * Get an object from the main window.
+ *
+ * @param ml handle to the main loop
+ * @param name name of the object
+ * @return NULL on error, otherwise the object
+ */
+GObject *
+GNUNET_GTK_main_loop_get_object (struct GNUNET_GTK_MainLoop *ml,
+                                 const char *name)
+{
+  return gtk_builder_get_object (ml->builder, name);
+}
+
+
+/**
+ * Task to run Gtk events (within a GNUnet scheduler task).
+ *
+ * @param cls the main loop handle
+ * @param tc scheduler context
+ */
+static void
+gnunet_gtk_dispatch_task (void *cls,
+                         const struct GNUNET_SCHEDULER_TaskContext *tc)
+{
+  struct GNUNET_GTK_MainLoop *ml = cls;
+  g_main_context_dispatch (ml->gmc);
+}
+
+
+#ifndef FD_COPY
+#define FD_COPY(s, d) (memcpy ((d), (s), sizeof (fd_set)))
+#endif
+
+/**
+ * Replacement for the GNUnet scheduler's "select" that integrates the
+ * Gtk event loop.  We merge Gtk's events with those from GNUnet's
+ * scheduler and then use 'g_poll' on both.  Then we process the Gtk
+ * events (by adding a task to do so to the GNUnet scheduler), and, if
+ * applicable, return the GNUnet-scheduler events back to GNUnet.
+ *
+ * @param cls the 'struct GNUNET_GTK_MainLoop'
+ * @param rfds set of sockets to be checked for readability
+ * @param wfds set of sockets to be checked for writability
+ * @param efds set of sockets to be checked for exceptions
+ * @param timeout relative value when to return
+ * @return number of selected sockets, GNUNET_SYSERR on error
+ */
+static int
+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)
+{
+  struct GNUNET_GTK_MainLoop *ml = cls;
+  int max_nfds;
+  gint poll_result;
+
+  GPollFD *gfds;
+  gint delay;
+
+  guint i;
+  guint fd_counter = 0;
+
+  guint allocated_nfds, need_gfds;
+
+  fd_set aread, awrite, aexcept;
+  int pre_ret = 0;
+  int result = 0;
+  int socks = 0;
+  int sock_read = 0, sock_write = 0, sock_err = 0;
+
+#if WINDOWS
+  int always_ready_write_fd = -1;
+
+  int select_ret = 0;
+
+  int read_handles = 0;
+  DWORD waitstatus;
+#endif
+
+  if (TRUE != g_main_loop_is_running (ml->gml))
+    return GNUNET_NETWORK_socket_select (rfds, wfds, efds, timeout);
+
+  FD_ZERO (&aread);
+  FD_ZERO (&awrite);
+  FD_ZERO (&aexcept);
+  if (rfds)
+    FD_COPY (&rfds->sds, &aread);
+  if (wfds)
+    FD_COPY (&wfds->sds, &awrite);
+  if (efds)
+    FD_COPY (&efds->sds, &aexcept);
+
+#if WINDOWS
+  ResetEvent (ml->hEventRead);
+  ResetEvent (ml->hEventWrite);
+  ResetEvent (ml->hEventException);
+
+  GNUNET_CONTAINER_slist_clear (ml->handles_read);
+  GNUNET_CONTAINER_slist_clear (ml->handles_write);
+  GNUNET_CONTAINER_slist_clear (ml->handles_except);
+#endif
+
+
+  if (rfds != NULL)
+    max_nfds = rfds->nsds;
+  else
+    max_nfds = -1;
+  if (wfds != NULL && max_nfds < wfds->nsds)
+    max_nfds = wfds->nsds;
+  if (efds != NULL && max_nfds < efds->nsds)
+    max_nfds = efds->nsds;
+
+  allocated_nfds = ml->cached_poll_array_size;
+  gfds = ml->cached_poll_array;
+  if (allocated_nfds == 0)
+  {
+    /* TODO: get some statistics, find the maximum number of fds ever
+     * polled during normal gnunet-gtk operation, and set this to that number.
+     */
+    ml->cached_poll_array = gfds = g_new (GPollFD, 30);
+    ml->cached_poll_array_size = allocated_nfds = 30;
+  }
+
+  while (1)
+  {
+    fd_counter = 0;
+#if !WINDOWS
+    gboolean need_realloc = FALSE;
+    for (i = 0; !need_realloc && i < max_nfds; i += 1)
+    {
+      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 >= allocated_nfds)
+      {
+        need_realloc = TRUE;
+        break;
+      }
+      gfds[fd_counter].fd = i;
+      gfds[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 += 1;
+    }
+    if (need_realloc)
+    {
+      ml->cached_poll_array = gfds = g_renew (GPollFD, gfds, ml->cached_poll_array_size * 2);
+      ml->cached_poll_array_size = allocated_nfds = ml->cached_poll_array_size * 2;
+      fd_counter = 0;
+      need_realloc = FALSE;
+    }
+    else
+      break;  
+#else
+    struct GNUNET_CONTAINER_SList_Iterator *t;
+    /* 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 >= allocated_nfds)
+    {
+      /* Since there are also gmainloop's own fds, just need_nfds won't be
+       * enough, so make it twice as long.
+       */
+      ml->cached_poll_array = gfds = g_renew (GPollFD, gfds, need_nfds * 2);
+      ml->cached_poll_array_size = allocated_nfds = need_nfds * 2;
+    }
+    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;
+        fh = (struct GNUNET_DISK_FileHandle *) 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_NETWORK
+              GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Adding the pipe's 0x%x overlapped event to the array as %d\n", fh->h, nhandles);
+#endif
+              gfds[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.
+               */
+              gfds[fd_counter].events = G_IO_IN;
+              fd_counter += 1;
+              ml->read_array[read_handles] = fh;
+              read_handles += 1;
+            }
+            else
+            {
+              gfds[fd_counter].fd = (intptr_t) ml->hEventReadReady;
+              gfds[fd_counter].events = G_IO_HUP;
+              fd_counter += 1;
+              ml->read_array[read_handles] = fh;
+              read_handles += 1;
+            }
+          }
+          else
+          {
+#if DEBUG_NETWORK
+            GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Adding the read ready event to the array as %d\n", nhandles);
+#endif
+            gfds[fd_counter].fd = (intptr_t) ml->hEventReadReady;
+            gfds[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 += 1;
+        }
+      }
+    }
+    if (wfds != NULL && GNUNET_CONTAINER_slist_count (wfds->handles) > 0)
+    {
+      gfds[fd_counter].fd = (intptr_t) ml->hEventPipeWrite;
+      gfds[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;
+        DWORD dwBytes;
+        fh = (struct GNUNET_DISK_FileHandle *) GNUNET_CONTAINER_slist_get (t, NULL);
+        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 += 1;
+          }
+        }
+      }
+    }
+    GNUNET_CONTAINER_slist_iter_destroy (t);
+
+    if (rfds != NULL && rfds->sds.fd_count > 0)
+    {
+#if DEBUG_NETWORK
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Adding the socket read event to the array as %d\n", fd_counter);
+#endif
+      gfds[fd_counter].fd = (intptr_t) ml->hEventRead;
+      gfds[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_NETWORK
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Adding the socket write event to the array as %d\n", fd_counter);
+#endif
+      gfds[fd_counter].fd = (intptr_t) ml->hEventWrite;
+      gfds[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_NETWORK
+        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 DEBUG_NETWORK
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Adding the socket error event to the array as %d\n", fd_counter);
+#endif
+      gfds[fd_counter].fd = (intptr_t) ml->hEventException;
+      gfds[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 += 1;
+      sock_err = efds->sds.fd_count;
+    }
+    break;
+#endif
+  }
+  socks = sock_read + sock_write + sock_err;
+
+  g_main_context_prepare (ml->gmc, &ml->max_priority);
+  while (allocated_nfds < (need_gfds = g_main_context_query (ml->gmc,
+      ml->max_priority, &delay, &gfds[fd_counter], allocated_nfds - fd_counter)))
+  {
+    ml->cached_poll_array = gfds = g_renew (GPollFD, gfds, allocated_nfds - fd_counter + need_gfds);
+    ml->cached_poll_array_size = allocated_nfds = allocated_nfds - fd_counter + need_gfds;
+  }
+  ml->poll_array_active = fd_counter + need_gfds;
+
+  if (timeout.rel_value != GNUNET_TIME_UNIT_FOREVER_REL.rel_value)
+  {
+    if (delay >= 0)
+      delay = MIN(timeout.rel_value / GNUNET_TIME_UNIT_MILLISECONDS.rel_value, delay);
+    else
+      delay = timeout.rel_value / GNUNET_TIME_UNIT_MILLISECONDS.rel_value;
+  }
+
+  if (pre_ret > 0)
+  {
+#if DEBUG_NETWORK
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "pre_ret is %d, setting delay to 0\n", pre_ret);
+#endif
+    delay = 0;
+  }
+
+#if DEBUG_NETWORK
+  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 (gfds, fd_counter + need_gfds, delay);
+
+#if DEBUG_NETWORK
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "g_poll returned : %d\n", poll_result);
+#endif
+
+  /* Take care of GUI events.
+   * Dispatching the events here will eventually crash the scheduler, must do this
+   * 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, ml->max_priority, &gfds[fd_counter], need_gfds))
+    GNUNET_SCHEDULER_add_continuation (gnunet_gtk_dispatch_task, ml,
+                                       GNUNET_SCHEDULER_REASON_STARTUP);
+
+#if !WINDOWS
+  if (rfds)
+    GNUNET_NETWORK_fdset_zero (rfds);
+  if (wfds)
+    GNUNET_NETWORK_fdset_zero (wfds);
+  if (efds)
+    GNUNET_NETWORK_fdset_zero (efds);
+  for (i = 0; i < fd_counter; i++)
+  {
+    int set[3];
+    if ((set[0] = FD_ISSET (gfds[i].fd, &aread)))
+      FD_SET (gfds[i].fd, &rfds->sds);
+    if ((set[1] = FD_ISSET (gfds[i].fd, &awrite)))
+      FD_SET (gfds[i].fd, &wfds->sds);
+    if ((set[2] = FD_ISSET (gfds[i].fd, &aexcept)))
+      FD_SET (gfds[i].fd, &efds->sds);
+    if (set[0] || set[1] || set[2])
+      result += 1;
+  }
+#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;
+#if DEBUG_NETWORK
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "select() returned %d\n", select_ret);
+#endif
+  }
+  if (always_ready_write_fd >= 0 && gfds[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_NETWORK
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Added write pipe\n");
+#endif
+  }
+  for (i = 0; i < read_handles; i++)
+  {
+    DWORD error;
+    BOOL bret;
+    if (!(gfds[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_NETWORK
+    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 || (gfds[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;
+          fh = (struct GNUNET_DISK_FileHandle *) 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_NETWORK
+    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_NETWORK
+  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++)
+    {
+      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_NETWORK
+      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 (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_DISK_FileHandle *fh;
+      fh = (struct GNUNET_DISK_FileHandle *) 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);
+  }
+  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);
+  }
+  if (fd_counter > 0)
+    /* This is not accurate (select_ret counts write-ready sockets,
+     * and result does as well. Anything out there actually cares
+     * about this?
+     */
+    return select_ret + result;
+  else
+    return 0;
+#endif
+  return result;
+}
+
+
+/**
+ * Actual main function run right after GNUnet's scheduler
+ * is initialized.  Initializes up GTK and Glade and starts the
+ * combined event loop.
+ *
+ * @param cls the 'struct GNUNET_GTK_MainLoop'
+ * @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)
+{
+  struct GNUNET_GTK_MainLoop *ml = cls;
+  int argc;
+ 
+  /* command-line processing for Gtk arguments */
+  argc = 0;
+  while (args[argc] != NULL) argc++;
+  gtk_init (&argc, (char ***) &args);
+
+  /* setup main context */
+  ml->builder = GNUNET_GTK_get_new_builder (ml->main_window_file);
+  if (ml->builder == NULL)
+    return;
+  ml->rs = GNUNET_NETWORK_fdset_create ();
+  ml->ws = GNUNET_NETWORK_fdset_create ();
+  ml->gml = g_main_loop_new (NULL, TRUE);
+  ml->gmc = g_main_loop_get_context (ml->gml);
+  ml->cfg = cfg;
+#if WINDOWS
+  ml->hEventRead = CreateEvent (NULL, TRUE, FALSE, NULL);
+  ml->hEventReadReady = CreateEvent (NULL, TRUE, TRUE, NULL);
+  ml->hEventWrite = CreateEvent (NULL, TRUE, FALSE, NULL);
+  ml->hEventException = CreateEvent (NULL, TRUE, FALSE, NULL);
+  ml->hEventPipeWrite = CreateEvent (NULL, TRUE, TRUE, NULL);
+  ml->handles_read = GNUNET_CONTAINER_slist_create ();
+  ml->handles_write = GNUNET_CONTAINER_slist_create ();
+  ml->handles_except = GNUNET_CONTAINER_slist_create ();
+  ml->read_array = NULL;
+  ml->read_array_length = 0;
+#endif
+
+  /* run main task of the application */
+  GNUNET_SCHEDULER_add_continuation (ml->main_task, ml,
+                                     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);
+}
+
+
+/**
+ * Initialize the main loop.
+ *
+ * @param binary_name binary name
+ * @param binary_help help text for the binary
+ * @param argc number of command line options
+ * @param argv command line options
+ * @param options allowed command line options
+ * @param main_window_file glade file for the main window
+ * @param main_task first task to run, closure will be set to the 'struct GNUNET_GTK_MainLoop'
+ * @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)
+{
+  struct GNUNET_GTK_MainLoop ml;
+  int ret;
+
+  ml.main_window_file = main_window_file;
+  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)
+    GNUNET_NETWORK_fdset_destroy (ml.rs);
+  if (NULL != ml.ws)
+    GNUNET_NETWORK_fdset_destroy (ml.ws);
+  if (NULL != ml.builder)
+    g_object_unref (G_OBJECT (ml.builder));
+  if (NULL != ml.gml)
+    g_main_loop_unref (ml.gml);
+  return ret;
+}
+
+
+/* end of eventloop.c */
diff --git a/src/lib/glade.c b/src/lib/glade.c
new file mode 100644
index 00000000..386a676b
--- /dev/null
+++ b/src/lib/glade.c
@@ -0,0 +1,85 @@
+/*
+     This file is part of GNUnet.
+     (C) 2010 Christian Grothoff (and other contributing authors)
+
+     GNUnet is free software; you can redistribute it and/or modify
+     it under the terms of the GNU General Public License as published
+     by the Free Software Foundation; either version 2, or (at your
+     option) any later version.
+
+     GNUnet is distributed in the hope that it will be useful, but
+     WITHOUT ANY WARRANTY; without even the implied warranty of
+     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+     General Public License for more details.
+
+     You should have received a copy of the GNU General Public License
+     along with GNUnet; see the file COPYING.  If not, write to the
+     Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+     Boston, MA 02111-1307, USA.
+*/
+
+/**
+ * @file src/lib/glade.c
+ * @brief code for integration with glade
+ * @author Christian Grothoff
+ */
+#include "gnunet_gtk_config.h"
+#include "gnunet_gtk.h"
+
+
+/**
+ * Get the name of the directory where all of our package
+ * data is stored ($PREFIX/share/)
+ * 
+ * @return name of the data directory
+ */
+const char *
+GNUNET_GTK_get_data_dir ()
+{
+  static char *dd;
+
+  if (dd == NULL)
+    dd = GNUNET_GTK_installation_get_path (GNUNET_OS_IPK_DATADIR);
+  return dd;
+}
+
+
+/**
+ * Create an initialize a new builder based on the
+ * GNUnet-GTK glade file.
+ *
+ * @param filename name of the resource file to load
+ * @return NULL on error
+ */
+GtkBuilder *
+GNUNET_GTK_get_new_builder (const char *filename)
+{
+  char *glade_path;
+  GtkBuilder *ret;
+  GError *error;
+
+  ret = gtk_builder_new ();
+  gtk_builder_set_translation_domain (ret, "gnunet-gtk");
+  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;
+    }
+  gtk_builder_connect_signals (ret, NULL);
+  GNUNET_free (glade_path);
+  return ret;
+}
+
+
+
+/* end of glade.c */
diff --git a/src/lib/nls.c b/src/lib/nls.c
new file mode 100644
index 00000000..96e44a99
--- /dev/null
+++ b/src/lib/nls.c
@@ -0,0 +1,58 @@
+/*
+     This file is part of GNUnet.
+     (C) 2010, 2011 Christian Grothoff (and other contributing authors)
+
+     GNUnet is free software; you can redistribute it and/or modify
+     it under the terms of the GNU General Public License as published
+     by the Free Software Foundation; either version 2, or (at your
+     option) any later version.
+
+     GNUnet is distributed in the hope that it will be useful, but
+     WITHOUT ANY WARRANTY; without even the implied warranty of
+     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+     General Public License for more details.
+
+     You should have received a copy of the GNU General Public License
+     along with GNUnet; see the file COPYING.  If not, write to the
+     Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+     Boston, MA 02111-1307, USA.
+*/
+
+/**
+ * @file src/lib/nls.c
+ * @brief natural language support
+ * @author Christian Grothoff
+ */
+#include "gnunet_gtk.h"
+
+#if ENABLE_NLS
+#include <locale.h>
+#endif
+
+
+/**
+ * Initialize GNU gettext for message translation.
+ */
+void
+GNUNET_GTK_setup_nls ()
+{
+#if ENABLE_NLS
+  char *path;
+
+  setlocale (LC_ALL, "");
+  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");
+  bind_textdomain_codeset ("gnunet-gtk", "UTF-8");
+  GNUNET_free (path);
+#else
+  fprintf (stderr,
+           "WARNING: gnunet-gtk was compiled without i18n support (did CFLAGS contain -Werror?).\n");
+#endif
+}
+
+/* end of nls.c */
diff --git a/src/lib/os_installation.c b/src/lib/os_installation.c
new file mode 100644
index 00000000..9a884f27
--- /dev/null
+++ b/src/lib/os_installation.c
@@ -0,0 +1,435 @@
+/*
+     This file is part of GNUnet.
+     (C) 2006, 2010, 2011 Christian Grothoff (and other contributing authors)
+
+     GNUnet is free software; you can redistribute it and/or modify
+     it under the terms of the GNU General Public License as published
+     by the Free Software Foundation; either version 2, or (at your
+     option) any later version.
+
+     GNUnet is distributed in the hope that it will be useful, but
+     WITHOUT ANY WARRANTY; without even the implied warranty of
+     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+     General Public License for more details.
+
+     You should have received a copy of the GNU General Public License
+     along with GNUnet; see the file COPYING.  If not, write to the
+     Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+     Boston, MA 02111-1307, USA.
+*/
+
+/**
+ * @file src/lib/os_installation.c
+ * @brief get paths used by the program; this code is almost the
+ *        same as src/util/os_installation.c in libgnunetutil; however,
+ *        it contains sublte changes to detect the installation path
+ *        of gnunet-gtk (which may be different from the path for
+ *        GNUnet itself) and also needs to be replicated anyway since
+ *        some of the methods try to find the location of the binary
+ *        of the test-code itself, which would never yield the
+ *        correct result for gnunet-gtk if the code lives in libgnunetutil.
+ * @author Milan
+ * @author Christian Grothoff
+ */
+#include "gnunet_gtk.h"
+#if DARWIN
+#include <mach-o/ldsyms.h>
+#include <mach-o/dyld.h>
+#endif
+
+#if LINUX
+/**
+ * Try to determine path by reading /proc/PID/exe
+ */
+static char *
+get_path_from_proc_maps ()
+{
+  char fn[64];
+  char line[1024];
+  char dir[1024];
+  FILE *f;
+  char *lgu;
+
+  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))
+    {
+      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);
+        }
+    }
+  fclose (f);
+  return NULL;
+}
+
+/**
+ * Try to determine path by reading /proc/PID/exe
+ */
+static char *
+get_path_from_proc_exe ()
+{
+  char fn[64];
+  char lnk[1024];
+  ssize_t size;
+
+  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_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;
+    }
+  lnk[size] = '\0';
+  return GNUNET_strdup (lnk);
+}
+#endif
+
+#if WINDOWS
+/**
+ * Try to determine path with win32-specific function
+ */
+static char *
+get_path_from_module_filename ()
+{
+  char path[4097];
+  char *idx;
+
+  GetModuleFileName (NULL, path, sizeof(path)-1);
+  idx = path + strlen (path);
+  while ((idx > path) && (*idx != '\\') && (*idx != '/'))
+    idx--;
+  *idx = '\0';
+  return GNUNET_strdup (path);
+}
+#endif
+
+#if DARWIN
+typedef int (*MyNSGetExecutablePathProto) (char *buf, size_t * bufsize);
+
+static char *
+get_path_from_NSGetExecutablePath ()
+{
+  static char zero = '\0';
+  char *path;
+  size_t len;
+  MyNSGetExecutablePathProto func;
+  int ret;
+
+  path = NULL;
+  func =
+    (MyNSGetExecutablePathProto) dlsym (RTLD_DEFAULT, "_NSGetExecutablePath");
+  if (!func)
+    return NULL;
+  path = &zero;
+  len = 0;
+  /* get the path len, including the trailing \0 */
+  func (path, &len);
+  if (len == 0)
+    return NULL;
+  path = GNUNET_malloc (len);
+  ret = func (path, &len);
+  if (ret != 0)
+    {
+      GNUNET_free (path);
+      return NULL;
+    }
+  len = strlen (path);
+  while ((path[len] != '/') && (len > 0))
+    len--;
+  path[len] = '\0';
+  return path;
+}
+
+static char *
+get_path_from_dyld_image ()
+{
+  const char *path;
+  char *p, *s;
+  int i;
+  int c;
+
+  p = NULL;
+  c = _dyld_image_count ();
+  for (i = 0; i < c; i++)
+    {
+      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;
+        }
+    }
+  return p;
+}
+#endif
+
+static char *
+get_path_from_PATH ()
+{
+  char *path;
+  char *pos;
+  char *end;
+  char *buf;
+  const char *p;
+
+  p = getenv ("PATH");
+  if (p == NULL)
+    return NULL;
+  path = GNUNET_strdup (p);     /* because we write on it */
+  buf = GNUNET_malloc (strlen (path) + 20);
+  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)
+    {
+      pos = GNUNET_strdup (pos);
+      GNUNET_free (buf);
+      GNUNET_free (path);
+      return pos;
+    }
+  GNUNET_free (buf);
+  GNUNET_free (path);
+  return NULL;
+}
+
+static char *
+get_path_from_GNUNET_PREFIX ()
+{
+  const char *p;
+
+  p = getenv ("GNUNET_GTK_PREFIX");
+  if (p != NULL)
+    return GNUNET_strdup (p);
+  p = getenv ("GNUNET_PREFIX");
+  if (p != NULL)
+    return GNUNET_strdup (p);
+  return NULL;
+}
+
+/*
+ * @brief get the path to GNUnet bin/ or lib/, prefering the lib/ path
+ * @author Milan
+ *
+ * @return a pointer to the executable path, or NULL on error
+ */
+static char *
+os_get_gnunet_path ()
+{
+  char *ret;
+
+  ret = get_path_from_GNUNET_PREFIX ();
+  if (ret != NULL)
+    return ret;
+#if LINUX
+  ret = get_path_from_proc_maps ();
+  if (ret != NULL)
+    return ret;
+  ret = get_path_from_proc_exe ();
+  if (ret != NULL)
+    return ret;
+#endif
+#if WINDOWS
+  ret = get_path_from_module_filename ();
+  if (ret != NULL)
+    return ret;
+#endif
+#if DARWIN
+  ret = get_path_from_dyld_image ();
+  if (ret != NULL)
+    return ret;
+  ret = get_path_from_NSGetExecutablePath ();
+  if (ret != NULL)
+    return ret;
+#endif
+  ret = get_path_from_PATH ();
+  if (ret != NULL)
+    return ret;
+  /* other attempts here */
+  GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+              _
+              ("Could not determine installation path for %s.  Set `%s' environment variable.\n"),
+              "gnunet-gtk",
+              "GNUNET_GTK_PREFIX");
+  return NULL;
+}
+
+/*
+ * @brief get the path to current app's bin/
+ * @author Milan
+ *
+ * @return a pointer to the executable path, or NULL on error
+ */
+static char *
+os_get_exec_path ()
+{
+  char *ret;
+
+  ret = NULL;
+#if LINUX
+  ret = get_path_from_proc_exe ();
+  if (ret != NULL)
+    return ret;
+#endif
+#if WINDOWS
+  ret = get_path_from_module_filename ();
+  if (ret != NULL)
+    return ret;
+#endif
+#if DARWIN
+  ret = get_path_from_NSGetExecutablePath ();
+  if (ret != NULL)
+    return ret;
+#endif
+  /* other attempts here */
+  return ret;
+}
+
+
+
+/**
+ * @brief get the path to a specific GNUnet installation directory or,
+ * with GNUNET_IPK_SELF_PREFIX, the current running apps installation directory
+ * @author Milan
+ * @return a pointer to the dir path (to be freed by the caller)
+ */
+char *
+GNUNET_GTK_installation_get_path (enum GNUNET_OS_InstallationPathKind dirkind)
+{
+  size_t n;
+  const char *dirname;
+  char *execpath = NULL;
+  char *tmp;
+  int isbasedir;
+
+  /* if wanted, try to get the current app's bin/ */
+  if (dirkind == GNUNET_OS_IPK_SELF_PREFIX)
+    execpath = os_get_exec_path ();
+
+  /* try to get GNUnet's bin/ or lib/, or if previous was unsuccessful some
+   * guess for the current app */
+  if (execpath == NULL)
+    execpath = os_get_gnunet_path ();
+
+  if (execpath == NULL)
+    return NULL;
+
+  n = strlen (execpath);
+  if (n == 0)
+    {
+      /* 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';
+
+  isbasedir = 1;
+  if ((n > 5) &&
+      ((0 == strcasecmp (&execpath[n - 5], "lib32")) ||
+       (0 == strcasecmp (&execpath[n - 5], "lib64"))))
+    {
+      if (dirkind != GNUNET_OS_IPK_LIBDIR)
+        {
+          /* 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;
+    }
+  /* 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 =
+          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 =
+        DIR_SEPARATOR_STR "share" DIR_SEPARATOR_STR "gnunet-gtk"
+        DIR_SEPARATOR_STR;
+      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;
+    }
+  tmp = GNUNET_malloc (strlen (execpath) + strlen (dirname) + 1);
+  sprintf (tmp, "%s%s", execpath, dirname);
+  GNUNET_free (execpath);
+  return tmp;
+}
+
+/* end of os_installation.c */