80 files changed, 24666 insertions, 0 deletions

diff --git a/src/util/Makefile.am b/src/util/Makefile.am
new file mode 100644
index 000000000..a90b2b793
--- /dev/null
+++ b/src/util/Makefile.am
@@ -0,0 +1,308 @@
+INCLUDES = -I$(top_srcdir)/src/include
+
+plugindir = $(libdir)/gnunet
+
+if MINGW
+ WINFLAGS = -Wl,--no-undefined -Wl,--export-all-symbols -lole32 -lshell32 -luuid -liconv -lstdc++ -lcomdlg32 -lgdi32
+endif
+
+if USE_COVERAGE
+  AM_CFLAGS = --coverage
+endif
+
+lib_LTLIBRARIES = libgnunetutil.la
+
+libgnunetutil_la_SOURCES = \
+  client.c \
+  common_allocation.c \
+  common_endian.c \
+  common_gettext.c \
+  common_logging.c \
+  configuration.c \
+  container_bloomfilter.c \
+  container_meta_data.c \
+  container_multihashmap.c \
+  crypto_aes.c \
+  crypto_crc.c \
+  crypto_hash.c \
+  crypto_ksk.c \
+  crypto_random.c \
+  crypto_rsa.c \
+  disk.c \
+  getopt.c \
+  getopt_helpers.c \
+  network.c \
+  os_installation.c \
+  os_load.c \
+  os_network.c \
+  os_priority.c \
+  plugin.c \
+  program.c \
+  pseudonym.c \
+  scheduler.c \
+  server.c \
+  server_tc.c \
+  service.c \
+  signal.c \
+  strings.c \
+  time.c
+
+
+libgnunetutil_la_LIBADD = \
+  $(GCLIBADD) \
+  $(LIBGCRYPT_LIBS) \
+  -lgmp -lltdl -lz -lextractor
+
+libgnunetutil_la_LDFLAGS = \
+  $(GN_LIB_LDFLAGS) $(WINFLAGS) \
+  -version-info 4:0:0
+
+
+plugin_LTLIBRARIES = \
+  libgnunet_plugin_test.la
+
+libgnunet_plugin_test_la_SOURCES = \
+  test_plugin_plug.c
+libgnunet_plugin_test_la_LDFLAGS = \
+ $(GN_PLUGIN_LDFLAGS)
+
+
+check_PROGRAMS = \
+ test_client \
+ test_common_allocation \
+ test_common_endian \
+ test_common_logging \
+ test_configuration \
+ test_container_bloomfilter \
+ test_container_meta_data \
+ test_container_multihashmap \
+ test_crypto_aes \
+ test_crypto_aes_weak \
+ test_crypto_crc \
+ test_crypto_hash \
+ test_crypto_ksk \
+ test_crypto_random \
+ test_crypto_rsa \
+ test_disk \
+ test_getopt \
+ test_network \
+ test_network_addressing \
+ test_network_receive_cancel \
+ test_network_timeout \
+ test_network_timeout_no_connect \
+ test_network_transmit_cancel \
+ test_os_load \
+ test_os_network \
+ test_os_priority \
+ test_plugin \
+ test_program \
+ test_pseudonym \
+ test_scheduler \
+ test_scheduler_delay \
+ test_server \
+ test_server_disconnect \
+ test_server_with_client \
+ test_service \
+ test_strings \
+ test_time \
+ perf_crypto_hash
+
+TESTS = $(check_PROGRAMS)
+
+test_client_SOURCES = \
+ test_client.c
+test_client_LDADD = \
+ $(top_builddir)/src/util/libgnunetutil.la  
+
+test_common_allocation_SOURCES = \
+ test_common_allocation.c
+test_common_allocation_LDADD = \
+ $(top_builddir)/src/util/libgnunetutil.la  
+
+test_common_endian_SOURCES = \
+ test_common_endian.c
+test_common_endian_LDADD = \
+ $(top_builddir)/src/util/libgnunetutil.la  
+
+test_common_logging_SOURCES = \
+ test_common_logging.c
+test_common_logging_LDADD = \
+ $(top_builddir)/src/util/libgnunetutil.la  
+
+test_configuration_SOURCES = \
+ test_configuration.c
+test_configuration_LDADD = \
+ $(top_builddir)/src/util/libgnunetutil.la  
+
+test_container_bloomfilter_SOURCES = \
+ test_container_bloomfilter.c
+test_container_bloomfilter_LDADD = \
+ $(top_builddir)/src/util/libgnunetutil.la  
+
+test_container_meta_data_SOURCES = \
+ test_container_meta_data.c
+test_container_meta_data_LDADD = \
+ $(top_builddir)/src/util/libgnunetutil.la  
+
+test_container_multihashmap_SOURCES = \
+ test_container_multihashmap.c
+test_container_multihashmap_LDADD = \
+ $(top_builddir)/src/util/libgnunetutil.la  
+
+test_crypto_aes_SOURCES = \
+ test_crypto_aes.c
+test_crypto_aes_LDADD = \
+ $(top_builddir)/src/util/libgnunetutil.la  
+
+test_crypto_aes_weak_SOURCES = \
+ test_crypto_aes_weak.c
+test_crypto_aes_weak_LDADD = \
+ $(top_builddir)/src/util/libgnunetutil.la  
+
+test_crypto_crc_SOURCES = \
+ test_crypto_crc.c
+test_crypto_crc_LDADD = \
+ $(top_builddir)/src/util/libgnunetutil.la  
+
+test_crypto_hash_SOURCES = \
+ test_crypto_hash.c
+test_crypto_hash_LDADD = \
+ $(top_builddir)/src/util/libgnunetutil.la  
+
+test_crypto_ksk_SOURCES = \
+ test_crypto_ksk.c
+test_crypto_ksk_LDADD = \
+ $(top_builddir)/src/util/libgnunetutil.la  
+
+test_crypto_random_SOURCES = \
+ test_crypto_random.c
+test_crypto_random_LDADD = \
+ $(top_builddir)/src/util/libgnunetutil.la  
+
+test_crypto_rsa_SOURCES = \
+ test_crypto_rsa.c
+test_crypto_rsa_LDADD = \
+ $(top_builddir)/src/util/libgnunetutil.la  
+
+test_disk_SOURCES = \
+ test_disk.c
+test_disk_LDADD = \
+ $(top_builddir)/src/util/libgnunetutil.la  
+
+test_getopt_SOURCES = \
+ test_getopt.c
+test_getopt_LDADD = \
+ $(top_builddir)/src/util/libgnunetutil.la  
+
+test_network_SOURCES = \
+ test_network.c
+test_network_LDADD = \
+ $(top_builddir)/src/util/libgnunetutil.la  
+
+test_network_addressing_SOURCES = \
+ test_network_addressing.c
+test_network_addressing_LDADD = \
+ $(top_builddir)/src/util/libgnunetutil.la  
+
+test_network_receive_cancel_SOURCES = \
+ test_network_receive_cancel.c
+test_network_receive_cancel_LDADD = \
+ $(top_builddir)/src/util/libgnunetutil.la  
+
+test_network_timeout_SOURCES = \
+ test_network_timeout.c
+test_network_timeout_LDADD = \
+ $(top_builddir)/src/util/libgnunetutil.la  
+
+test_network_timeout_no_connect_SOURCES = \
+ test_network_timeout_no_connect.c
+test_network_timeout_no_connect_LDADD = \
+ $(top_builddir)/src/util/libgnunetutil.la  
+
+test_network_transmit_cancel_SOURCES = \
+ test_network_transmit_cancel.c
+test_network_transmit_cancel_LDADD = \
+ $(top_builddir)/src/util/libgnunetutil.la  
+
+test_os_load_SOURCES = \
+ test_os_load.c
+test_os_load_LDADD = \
+ $(top_builddir)/src/util/libgnunetutil.la  
+
+test_os_network_SOURCES = \
+ test_os_network.c
+test_os_network_LDADD = \
+ $(top_builddir)/src/util/libgnunetutil.la  
+
+test_os_priority_SOURCES = \
+ test_os_priority.c
+test_os_priority_LDADD = \
+ $(top_builddir)/src/util/libgnunetutil.la  
+
+test_plugin_SOURCES = \
+ test_plugin.c
+test_plugin_LDADD = \
+ $(top_builddir)/src/util/libgnunetutil.la  
+
+test_program_SOURCES = \
+ test_program.c
+test_program_LDADD = \
+ $(top_builddir)/src/util/libgnunetutil.la  
+
+test_pseudonym_SOURCES = \
+ test_pseudonym.c
+test_pseudonym_LDADD = \
+ $(top_builddir)/src/util/libgnunetutil.la  
+
+test_scheduler_SOURCES = \
+ test_scheduler.c
+test_scheduler_LDADD = \
+ $(top_builddir)/src/util/libgnunetutil.la  
+
+test_scheduler_delay_SOURCES = \
+ test_scheduler_delay.c
+test_scheduler_delay_LDADD = \
+ $(top_builddir)/src/util/libgnunetutil.la  
+
+test_server_SOURCES = \
+ test_server.c
+test_server_LDADD = \
+ $(top_builddir)/src/util/libgnunetutil.la  
+
+test_server_disconnect_SOURCES = \
+ test_server_disconnect.c
+test_server_disconnect_LDADD = \
+ $(top_builddir)/src/util/libgnunetutil.la  
+
+test_server_with_client_SOURCES = \
+ test_server_with_client.c
+test_server_with_client_LDADD = \
+ $(top_builddir)/src/util/libgnunetutil.la  
+
+test_service_SOURCES = \
+ test_service.c
+test_service_LDADD = \
+ $(top_builddir)/src/util/libgnunetutil.la  
+
+test_strings_SOURCES = \
+ test_strings.c
+test_strings_LDADD = \
+ $(top_builddir)/src/util/libgnunetutil.la  
+
+test_time_SOURCES = \
+ test_time.c
+test_time_LDADD = \
+ $(top_builddir)/src/util/libgnunetutil.la  
+
+perf_crypto_hash_SOURCES = \
+ perf_crypto_hash.c
+perf_crypto_hash_LDADD = \
+ $(top_builddir)/src/util/libgnunetutil.la  
+
+
+EXTRA_DIST = \
+  test_configuration_data.conf \
+  test_container_meta_data_image.jpg \
+  test_program_data.conf \
+  test_pseudonym_data.conf \
+  test_service_data.conf
diff --git a/src/util/client.c b/src/util/client.c
new file mode 100644
index 000000000..9dd70f266
--- /dev/null
+++ b/src/util/client.c
@@ -0,0 +1,526 @@
+/*
+     This file is part of GNUnet.
+     (C) 2001, 2002, 2006, 2008, 2009 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 util/client.c
+ * @brief code for access to services
+ * @author Christian Grothoff
+ *
+ * Generic TCP code for reliable, record-oriented TCP
+ * connections between clients and service providers.
+ */
+
+#include "platform.h"
+#include "gnunet_common.h"
+#include "gnunet_client_lib.h"
+#include "gnunet_protocols.h"
+#include "gnunet_server_lib.h"
+#include "gnunet_scheduler_lib.h"
+
+#define DEBUG_CLIENT GNUNET_NO
+
+/**
+ * Struct to refer to a GNUnet TCP connection.
+ * This is more than just a socket because if the server
+ * drops the connection, the client automatically tries
+ * to reconnect (and for that needs connection information).
+ */
+struct GNUNET_CLIENT_Connection
+{
+
+  /**
+   * the socket handle, NULL if not live
+   */
+  struct GNUNET_NETWORK_SocketHandle *sock;
+
+  /**
+   * Our scheduler.
+   */
+  struct GNUNET_SCHEDULER_Handle *sched;
+
+  /**
+   * Name of the service we interact with.
+   */
+  char *service_name;
+
+  /**
+   * ID of task used for receiving.
+   */
+  GNUNET_SCHEDULER_TaskIdentifier receiver_task;
+
+  /**
+   * Handler for current receiver task.
+   */
+  GNUNET_CLIENT_MessageHandler receiver_handler;
+
+  /**
+   * Closure for receiver_handler.
+   */
+  void *receiver_handler_cls;
+
+  /**
+   * Handler for service test completion (NULL unless in service_test)
+   */
+  GNUNET_SCHEDULER_Task test_cb;
+
+  /**
+   * Closure for test_cb (NULL unless in service_test)
+   */
+  void *test_cb_cls;
+
+  /**
+   * Buffer for received message.
+   */
+  char *received_buf;
+
+  /**
+   * Timeout for receiving a response (absolute time).
+   */
+  struct GNUNET_TIME_Absolute receive_timeout;
+
+  /**
+   * Number of bytes in received_buf that are valid.
+   */
+  size_t received_pos;
+
+  /**
+   * Size of received_buf.
+   */
+  size_t received_size;
+
+  /**
+   * Do we have a complete response in received_buf?
+   */
+  int msg_complete;
+
+};
+
+
+/**
+ * Get a connection with a service.
+ *
+ * @param sched scheduler to use
+ * @param service_name name of the service
+ * @param cfg configuration to use
+ * @return NULL on error (service unknown to configuration)
+ */
+struct GNUNET_CLIENT_Connection *
+GNUNET_CLIENT_connect (struct GNUNET_SCHEDULER_Handle *sched,
+                       const char *service_name,
+                       struct GNUNET_CONFIGURATION_Handle *cfg)
+{
+  struct GNUNET_CLIENT_Connection *ret;
+  struct GNUNET_NETWORK_SocketHandle *sock;
+  char *hostname;
+  unsigned long long port;
+
+  if ((GNUNET_OK !=
+       GNUNET_CONFIGURATION_get_value_number (cfg,
+                                              service_name,
+                                              "PORT",
+                                              &port)) ||
+      (port > 65535) ||
+      (GNUNET_OK !=
+       GNUNET_CONFIGURATION_get_value_string (cfg,
+                                              service_name,
+                                              "HOSTNAME", &hostname)))
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                  "Could not determine valid hostname and port for service `%s' from configuration.\n",
+                  service_name);
+      return NULL;
+    }
+  sock = GNUNET_NETWORK_socket_create_from_connect (sched,
+                                                    hostname,
+                                                    port,
+                                                    GNUNET_SERVER_MAX_MESSAGE_SIZE);
+  GNUNET_free (hostname);
+  if (sock == NULL)
+    return NULL;
+  ret = GNUNET_malloc (sizeof (struct GNUNET_CLIENT_Connection));
+  ret->sock = sock;
+  ret->sched = sched;
+  ret->service_name = GNUNET_strdup (service_name);
+  return ret;
+}
+
+
+/**
+ * Receiver task has completed, free rest of client
+ * data structures.
+ */
+static void
+finish_cleanup (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+{
+  struct GNUNET_CLIENT_Connection *sock = cls;
+
+  GNUNET_array_grow (sock->received_buf, sock->received_size, 0);
+  GNUNET_free (sock->service_name);
+  GNUNET_free (sock);
+}
+
+
+/**
+ * Destroy connection with the service.
+ */
+void
+GNUNET_CLIENT_disconnect (struct GNUNET_CLIENT_Connection *sock)
+{
+  GNUNET_assert (sock->sock != NULL);
+  GNUNET_NETWORK_socket_destroy (sock->sock);
+  sock->sock = NULL;
+  sock->receiver_handler = NULL;
+  GNUNET_SCHEDULER_add_after (sock->sched,
+                              GNUNET_YES,
+                              GNUNET_SCHEDULER_PRIORITY_KEEP,
+                              sock->receiver_task, &finish_cleanup, sock);
+}
+
+
+/**
+ * check if message is complete
+ */
+static void
+check_complete (struct GNUNET_CLIENT_Connection *conn)
+{
+  if ((conn->received_pos >= sizeof (struct GNUNET_MessageHeader)) &&
+      (conn->received_pos >=
+       ntohs (((const struct GNUNET_MessageHeader *) conn->received_buf)->
+              size)))
+    conn->msg_complete = GNUNET_YES;
+}
+
+
+/**
+ * Callback function for data received from the network.  Note that
+ * both "available" and "err" would be 0 if the read simply timed out.
+ *
+ * @param cls closure
+ * @param buf pointer to received data
+ * @param available number of bytes availabe in "buf",
+ *        possibly 0 (on errors)
+ * @param addr address of the sender
+ * @param addrlen size of addr
+ * @param errCode value of errno (on errors receiving)
+ */
+static void
+receive_helper (void *cls,
+                const void *buf,
+                size_t available,
+                const struct sockaddr *addr, socklen_t addrlen, int errCode)
+{
+  struct GNUNET_CLIENT_Connection *conn = cls;
+  struct GNUNET_TIME_Relative remaining;
+
+  GNUNET_assert (conn->msg_complete == GNUNET_NO);
+  conn->receiver_task = GNUNET_SCHEDULER_NO_PREREQUISITE_TASK;
+
+  if ((available == 0) || (conn->sock == NULL) || (errCode != 0))
+    {
+      /* signal timeout! */
+      if (conn->receiver_handler != NULL)
+        {
+          conn->receiver_handler (conn->receiver_handler_cls, NULL);
+          conn->receiver_handler = NULL;
+        }
+      return;
+    }
+
+  /* FIXME: optimize for common fast case where buf contains the
+     entire message and we need no copying... */
+
+
+  /* slow path: append to array */
+  if (conn->received_size < conn->received_pos + available)
+    GNUNET_array_grow (conn->received_buf,
+                       conn->received_size, conn->received_pos + available);
+  memcpy (&conn->received_buf[conn->received_pos], buf, available);
+  conn->received_pos += available;
+  check_complete (conn);
+  /* check for timeout */
+  remaining = GNUNET_TIME_absolute_get_remaining (conn->receive_timeout);
+  if (remaining.value == 0)
+    {
+      /* signal timeout! */
+      conn->receiver_handler (conn->receiver_handler_cls, NULL);
+      return;
+    }
+  /* back to receive -- either for more data or to call callback! */
+  GNUNET_CLIENT_receive (conn,
+                         conn->receiver_handler,
+                         conn->receiver_handler_cls, remaining);
+}
+
+
+/**
+ * Continuation to call the receive callback.
+ */
+static void
+receive_task (void *scls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+{
+  struct GNUNET_CLIENT_Connection *sock = scls;
+  const struct GNUNET_MessageHeader *cmsg;
+  struct GNUNET_MessageHeader *msg;
+  GNUNET_CLIENT_MessageHandler handler = sock->receiver_handler;
+  void *cls = sock->receiver_handler_cls;
+  uint16_t msize;
+
+  GNUNET_assert (GNUNET_YES == sock->msg_complete);
+  sock->receiver_task = GNUNET_SCHEDULER_NO_PREREQUISITE_TASK;
+  cmsg = (const struct GNUNET_MessageHeader *) sock->received_buf;
+  msize = ntohs (cmsg->size);
+  GNUNET_assert (sock->received_pos >= msize);
+  msg = GNUNET_malloc (msize);
+  memcpy (msg, cmsg, msize);
+  memmove (sock->received_buf,
+           &sock->received_buf[msize], sock->received_pos - msize);
+  sock->received_pos -= msize;
+  sock->msg_complete = GNUNET_NO;
+  sock->receiver_handler = NULL;
+  check_complete (sock);
+  handler (cls, msg);
+  GNUNET_free (msg);
+}
+
+
+/**
+ * Read from the service.
+ *
+ * @param sched scheduler to use
+ * @param sock the service
+ * @param handler function to call with the message
+ * @param cls closure for handler
+ * @param timeout how long to wait until timing out
+ */
+void
+GNUNET_CLIENT_receive (struct GNUNET_CLIENT_Connection *sock,
+                       GNUNET_CLIENT_MessageHandler handler,
+                       void *cls, struct GNUNET_TIME_Relative timeout)
+{
+  if (sock->sock == NULL)
+    {
+      /* already disconnected, fail instantly! */
+      GNUNET_break (0);         /* this should not happen in well-written code! */
+      handler (cls, NULL);
+      return;
+    }
+  GNUNET_assert (sock->receiver_task ==
+                 GNUNET_SCHEDULER_NO_PREREQUISITE_TASK);
+  sock->receiver_handler = handler;
+  sock->receiver_handler_cls = cls;
+  sock->receive_timeout = GNUNET_TIME_relative_to_absolute (timeout);
+  if (GNUNET_YES == sock->msg_complete)
+    sock->receiver_task = GNUNET_SCHEDULER_add_after (sock->sched,
+                                                      GNUNET_YES,
+                                                      GNUNET_SCHEDULER_PRIORITY_KEEP,
+                                                      GNUNET_SCHEDULER_NO_PREREQUISITE_TASK,
+                                                      &receive_task, sock);
+  else
+    sock->receiver_task = GNUNET_NETWORK_receive (sock->sock,
+                                                  GNUNET_SERVER_MAX_MESSAGE_SIZE,
+                                                  timeout,
+                                                  &receive_helper, sock);
+}
+
+
+static size_t
+write_shutdown (void *cls, size_t size, void *buf)
+{
+  struct GNUNET_MessageHeader *msg;
+
+  if (size < sizeof (struct GNUNET_MessageHeader))
+    return 0;                   /* client disconnected */
+  msg = (struct GNUNET_MessageHeader *) buf;
+  msg->type = htons (GNUNET_MESSAGE_TYPE_SHUTDOWN);
+  msg->size = htons (sizeof (struct GNUNET_MessageHeader));
+  return sizeof (struct GNUNET_MessageHeader);
+}
+
+
+/**
+ * Request that the service should shutdown.
+ * Afterwards, the connection should be disconnected.
+ *
+ * @param sched scheduler to use
+ * @param sock the socket connected to the service
+ */
+void
+GNUNET_CLIENT_service_shutdown (struct GNUNET_CLIENT_Connection *sock)
+{
+  GNUNET_NETWORK_notify_transmit_ready (sock->sock,
+                                        sizeof (struct GNUNET_MessageHeader),
+                                        GNUNET_TIME_UNIT_FOREVER_REL,
+                                        &write_shutdown, NULL);
+}
+
+
+/**
+ * Report service unavailable.
+ */
+static void
+service_test_error (struct GNUNET_SCHEDULER_Handle *s,
+                    GNUNET_SCHEDULER_Task task, void *task_cls)
+{
+  GNUNET_SCHEDULER_add_continuation (s,
+                                     GNUNET_YES,
+                                     task,
+                                     task_cls,
+                                     GNUNET_SCHEDULER_REASON_TIMEOUT);
+}
+
+
+/**
+ * Receive confirmation from test, service is up.
+ *
+ * @param cls closure
+ * @param msg message received, NULL on timeout or fatal error
+ */
+static void
+confirm_handler (void *cls, const struct GNUNET_MessageHeader *msg)
+{
+  struct GNUNET_CLIENT_Connection *conn = cls;
+  /* We may want to consider looking at the reply in more
+     detail in the future, for example, is this the
+     correct service? FIXME! */
+  if (msg != NULL)
+    {
+#if DEBUG_CLIENT
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "Received confirmation that service is running.\n");
+#endif
+      GNUNET_SCHEDULER_add_continuation (conn->sched,
+                                         GNUNET_YES,
+                                         conn->test_cb,
+                                         conn->test_cb_cls,
+                                         GNUNET_SCHEDULER_REASON_PREREQ_DONE);
+    }
+  else
+    {
+      service_test_error (conn->sched, conn->test_cb, conn->test_cb_cls);
+    }
+  GNUNET_CLIENT_disconnect (conn);
+}
+
+
+static size_t
+write_test (void *cls, size_t size, void *buf)
+{
+  struct GNUNET_MessageHeader *msg;
+
+  if (size < sizeof (struct GNUNET_MessageHeader))
+    {
+#if DEBUG_CLIENT
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  _("Failure to transmit TEST request.\n"));
+#endif
+      return 0;                 /* client disconnected */
+    }
+#if DEBUG_CLIENT
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, _("Transmitting TEST request.\n"));
+#endif
+  msg = (struct GNUNET_MessageHeader *) buf;
+  msg->type = htons (GNUNET_MESSAGE_TYPE_TEST);
+  msg->size = htons (sizeof (struct GNUNET_MessageHeader));
+  return sizeof (struct GNUNET_MessageHeader);
+}
+
+
+/**
+ * Wait until the service is running.
+ *
+ * @param sched scheduler to use
+ * @param service name of the service to wait for
+ * @param cfg configuration to use
+ * @param timeout how long to wait at most in ms
+ * @param task task to run if service is running
+ *        (reason will be "PREREQ_DONE" (service running)
+ *         or "TIMEOUT" (service not known to be running))
+ * @param task_cls closure for task
+ */
+void
+GNUNET_CLIENT_service_test (struct GNUNET_SCHEDULER_Handle *sched,
+                            const char *service,
+                            struct GNUNET_CONFIGURATION_Handle *cfg,
+                            struct GNUNET_TIME_Relative timeout,
+                            GNUNET_SCHEDULER_Task task, void *task_cls)
+{
+  struct GNUNET_CLIENT_Connection *conn;
+
+#if DEBUG_CLIENT
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Testing if service `%s' is running.\n", service);
+#endif
+  conn = GNUNET_CLIENT_connect (sched, service, cfg);
+  if (conn == NULL)
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                  _
+                  ("Could not connect to service `%s', must not be running.\n"),
+                  service);
+      service_test_error (sched, task, task_cls);
+      return;
+    }
+  conn->test_cb = task;
+  conn->test_cb_cls = task_cls;
+  if (NULL ==
+      GNUNET_NETWORK_notify_transmit_ready (conn->sock,
+                                            sizeof (struct
+                                                    GNUNET_MessageHeader),
+                                            timeout, &write_test, NULL))
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                  _("Failure to transmit request to service `%s'\n"),
+                  service);
+      service_test_error (sched, task, task_cls);
+      GNUNET_CLIENT_disconnect (conn);
+      return;
+    }
+  GNUNET_CLIENT_receive (conn, &confirm_handler, conn, timeout);
+}
+
+
+/**
+ * Ask the client to call us once the specified number of bytes
+ * are free in the transmission buffer.  May call the notify
+ * method immediately if enough space is available.
+ *
+ * @param client connection to the service
+ * @param size number of bytes to send
+ * @param timeout after how long should we give up (and call
+ *        notify with buf NULL and size 0)?
+ * @param notify function to call
+ * @param notify_cls closure for notify
+ * @return NULL if our buffer will never hold size bytes,
+ *         a handle if the notify callback was queued (can be used to cancel)
+ */
+struct GNUNET_NETWORK_TransmitHandle *
+GNUNET_CLIENT_notify_transmit_ready (struct GNUNET_CLIENT_Connection *sock,
+                                     size_t size,
+                                     struct GNUNET_TIME_Relative timeout,
+                                     GNUNET_NETWORK_TransmitReadyNotify
+                                     notify, void *notify_cls)
+{
+  return GNUNET_NETWORK_notify_transmit_ready (sock->sock,
+                                               size,
+                                               timeout, notify, notify_cls);
+}
+
+
+/*  end of client.c */
diff --git a/src/util/common_allocation.c b/src/util/common_allocation.c
new file mode 100644
index 000000000..9fabb3a32
--- /dev/null
+++ b/src/util/common_allocation.c
@@ -0,0 +1,206 @@
+/*
+     This file is part of GNUnet.
+     (C) 2001, 2002, 2003, 2005, 2006 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 util/memory/common_allocation.c
+ * @brief wrapper around malloc/free
+ * @author Christian Grothoff
+ */
+
+#include "platform.h"
+#include "gnunet_common.h"
+
+#ifndef INT_MAX
+#define INT_MAX 0x7FFFFFFF
+#endif
+
+/**
+ * Allocate memory. Checks the return value, aborts if no more
+ * memory is available.
+ *
+ * @param size how many bytes of memory to allocate, do NOT use
+ *  this function (or GNUNET_malloc) to allocate more than several MB
+ *  of memory, if you are possibly needing a very large chunk use
+ *  GNUNET_xmalloc_unchecked_ instead.
+ * @param filename where in the code was the call to GNUNET_array_grow
+ * @param linenumber where in the code was the call to GNUNET_array_grow
+ * @return pointer to size bytes of memory
+ */
+void *
+GNUNET_xmalloc_ (size_t size, const char *filename, int linenumber)
+{
+  /* As a security precaution, we generally do not allow very large
+     allocations using the default 'GNUNET_malloc' macro */
+  GNUNET_assert_at (size <= GNUNET_MAX_GNUNET_MALLOC_CHECKED, filename,
+                    linenumber);
+  return GNUNET_xmalloc_unchecked_ (size, filename, linenumber);
+}
+
+void *
+GNUNET_xmalloc_unchecked_ (size_t size, const char *filename, int linenumber)
+{
+  void *result;
+
+  GNUNET_assert_at (size < INT_MAX, filename, linenumber);
+  result = malloc (size);
+  if (result == NULL)
+    {
+      GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "malloc");
+      abort ();
+    }
+  memset (result, 0, size);
+  return result;
+}
+
+/**
+ * Reallocate memory. Checks the return value, aborts if no more
+ * memory is available.
+ *
+ * @ptr the pointer to reallocate
+ * @param size how many bytes of memory to allocate, do NOT use
+ *  this function (or GNUNET_malloc) to allocate more than several MB
+ *  of memory
+ * @param filename where in the code was the call to GNUNET_realloc
+ * @param linenumber where in the code was the call to GNUNET_realloc
+ * @return pointer to size bytes of memory
+ */
+void *
+GNUNET_xrealloc_ (void *ptr,
+                  const size_t n, const char *filename, int linenumber)
+{
+  ptr = realloc (ptr, n);
+  if (!ptr)
+    {
+      GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "realloc");
+      abort ();
+    }
+  return ptr;
+}
+
+/**
+ * Free memory. Merely a wrapper for the case that we
+ * want to keep track of allocations.
+ *
+ * @param ptr the pointer to free
+ * @param filename where in the code was the call to GNUNET_array_grow
+ * @param linenumber where in the code was the call to GNUNET_array_grow
+ */
+void
+GNUNET_xfree_ (void *ptr, const char *filename, int linenumber)
+{
+  GNUNET_assert_at (ptr != NULL, filename, linenumber);
+  free (ptr);
+}
+
+/**
+ * Dup a string (same semantics as strdup).
+ *
+ * @param str the string to dup
+ * @param filename where in the code was the call to GNUNET_array_grow
+ * @param linenumber where in the code was the call to GNUNET_array_grow
+ * @return strdup(str)
+ */
+char *
+GNUNET_xstrdup_ (const char *str, const char *filename, int linenumber)
+{
+  char *res;
+
+  GNUNET_assert_at (str != NULL, filename, linenumber);
+  res = GNUNET_xmalloc_ (strlen (str) + 1, filename, linenumber);
+  memcpy (res, str, strlen (str) + 1);
+  return res;
+}
+
+/**
+ * Grow an array.  Grows old by (*oldCount-newCount)*elementSize bytes
+ * and sets *oldCount to newCount.
+ *
+ * @param old address of the pointer to the array
+ *        *old may be NULL
+ * @param elementSize the size of the elements of the array
+ * @param oldCount address of the number of elements in the *old array
+ * @param newCount number of elements in the new array, may be 0
+ * @param filename where in the code was the call to GNUNET_array_grow
+ * @param linenumber where in the code was the call to GNUNET_array_grow
+ */
+void
+GNUNET_xgrow_ (void **old,
+               size_t elementSize,
+               unsigned int *oldCount,
+               unsigned int newCount, const char *filename, int linenumber)
+{
+  void *tmp;
+  size_t size;
+
+  GNUNET_assert_at (INT_MAX / elementSize > newCount, filename, linenumber);
+  size = newCount * elementSize;
+  if (size == 0)
+    {
+      tmp = NULL;
+    }
+  else
+    {
+      tmp = GNUNET_xmalloc_ (size, filename, linenumber);
+      memset (tmp, 0, size);    /* client code should not rely on this, though... */
+      if (*oldCount > newCount)
+        *oldCount = newCount;   /* shrink is also allowed! */
+      memcpy (tmp, *old, elementSize * (*oldCount));
+    }
+
+  if (*old != NULL)
+    {
+      GNUNET_xfree_ (*old, filename, linenumber);
+    }
+  *old = tmp;
+  *oldCount = newCount;
+}
+
+
+int
+GNUNET_asprintf (char **buf, const char *format, ...)
+{
+  int ret;
+  va_list args;
+
+  va_start (args, format);
+  ret = VSNPRINTF (NULL, 0, format, args);
+  va_end (args);
+  *buf = GNUNET_malloc (ret + 1);
+  va_start (args, format);
+  ret = VSPRINTF (*buf, format, args);
+  va_end (args);
+  return ret;
+}
+
+int
+GNUNET_snprintf (char *buf, size_t size, const char *format, ...)
+{
+  int ret;
+  va_list args;
+
+  va_start (args, format);
+  ret = VSNPRINTF (buf, size, format, args);
+  va_end (args);
+  GNUNET_assert (ret <= size);
+  return ret;
+}
+
+
+/* end of common_allocation.c */
diff --git a/src/util/common_endian.c b/src/util/common_endian.c
new file mode 100644
index 000000000..223144c40
--- /dev/null
+++ b/src/util/common_endian.c
@@ -0,0 +1,52 @@
+/*
+     This file is part of GNUnet.
+     (C) 2001, 2002, 2003, 2004, 2006 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 util/common_endian.c
+ * @brief endian conversion helpers
+ * @author Christian Grothoff
+ */
+
+#include "platform.h"
+#include "gnunet_common.h"
+
+unsigned long long
+GNUNET_ntohll (unsigned long long n)
+{
+#if __BYTE_ORDER == __BIG_ENDIAN
+  return n;
+#else
+  return (((unsigned long long) ntohl (n)) << 32) + ntohl (n >> 32);
+#endif
+}
+
+unsigned long long
+GNUNET_htonll (unsigned long long n)
+{
+#if __BYTE_ORDER == __BIG_ENDIAN
+  return n;
+#else
+  return (((unsigned long long) htonl (n)) << 32) + htonl (n >> 32);
+#endif
+}
+
+
+
+/* end of common_endian.c */
diff --git a/src/util/common_gettext.c b/src/util/common_gettext.c
new file mode 100644
index 000000000..ad347e160
--- /dev/null
+++ b/src/util/common_gettext.c
@@ -0,0 +1,42 @@
+/*
+     This file is part of GNUnet.
+     (C) 2008 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 util/common_gettext.c
+ * @brief gettext init routine
+ * @author Heikki Lindholm
+ */
+#include "platform.h"
+#include "gnunet_common.h"
+#include "gnunet_os_lib.h"
+
+void __attribute__ ((constructor)) GNUNET_util_generic_ltdl_init ()
+{
+#if ENABLE_NLS
+  char *path;
+
+  path = GNUNET_OS_installation_get_path (GNUNET_OS_IPK_LOCALEDIR);
+  if (path != NULL)
+    {
+      BINDTEXTDOMAIN ("GNUnet", path);
+      GNUNET_free (path);
+    }
+#endif
+}
diff --git a/src/util/common_logging.c b/src/util/common_logging.c
new file mode 100644
index 000000000..4068ed94b
--- /dev/null
+++ b/src/util/common_logging.c
@@ -0,0 +1,401 @@
+/*
+     This file is part of GNUnet.
+     (C) 2006, 2008, 2009 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 util/common_logging.c
+ * @brief error handling API
+ *
+ * @author Christian Grothoff
+ */
+#include "platform.h"
+#include "gnunet_common.h"
+#include "gnunet_crypto_lib.h"
+#include "gnunet_strings_lib.h"
+#include "gnunet_time_lib.h"
+
+/**
+ * After how many seconds do we always print
+ * that "message X was repeated N times"?  Use 12h.
+ */
+#define BULK_DELAY_THRESHOLD (12 * 60 * 60 * 1000)
+
+/**
+ * After how many repetitions do we always print
+ * that "message X was repeated N times"? (even if
+ * we have not yet reached the delay threshold)
+ */
+#define BULK_REPEAT_THRESHOLD 1000
+
+/**
+ * How many characters do we use for matching of
+ * bulk messages?
+ */
+#define BULK_TRACK_SIZE 256
+
+/**
+ * How many characters can a date/time string
+ * be at most?
+ */
+#define DATE_STR_SIZE 64
+
+/**
+ * Linked list of active loggers.
+ */
+struct CustomLogger
+{
+  /**
+   * This is a linked list.
+   */
+  struct CustomLogger *next;
+
+  /**
+   * Log function.
+   */
+  GNUNET_Logger logger;
+
+  /**
+   * Closure for logger.
+   */
+  void *logger_cls;
+};
+
+/**
+ * The last "bulk" error message that we have been logging.
+ * Note that this message maybe truncated to the first BULK_TRACK_SIZE
+ * characters, in which case it is NOT 0-terminated!
+ */
+static char last_bulk[BULK_TRACK_SIZE];
+
+/**
+ * Type of the last bulk message.
+ */
+static enum GNUNET_ErrorType last_bulk_kind;
+
+/**
+ * Time of the last bulk error message (0 for none)
+ */
+static struct GNUNET_TIME_Absolute last_bulk_time;
+
+/**
+ * Number of times that bulk message has been repeated since.
+ */
+static unsigned int last_bulk_repeat;
+
+/**
+ * Component when the last bulk was logged.
+ */
+static const char *last_bulk_comp;
+
+/**
+ * Running component.
+ */
+static const char *component;
+
+/**
+ * Minimum log level.
+ */
+static enum GNUNET_ErrorType min_level;
+
+/**
+ * Linked list of our custom loggres.
+ */
+static struct CustomLogger *loggers;
+
+/**
+ * Number of log calls to ignore.
+ */
+static unsigned int skip_log;
+
+/**
+ * Convert a textual description of a loglevel
+ * to the respective GNUNET_GE_KIND.
+ * @returns GNUNET_GE_INVALID if log does not parse
+ */
+static enum GNUNET_ErrorType
+get_type (const char *log)
+{
+  if (0 == strcasecmp (log, _("DEBUG")))
+    return GNUNET_ERROR_TYPE_DEBUG;
+  if (0 == strcasecmp (log, _("INFO")))
+    return GNUNET_ERROR_TYPE_INFO;
+  if (0 == strcasecmp (log, _("WARNING")))
+    return GNUNET_ERROR_TYPE_WARNING;
+  if (0 == strcasecmp (log, _("ERROR")))
+    return GNUNET_ERROR_TYPE_ERROR;
+  return GNUNET_ERROR_TYPE_INVALID;
+}
+
+/**
+ * Setup logging.
+ *
+ * @param comp default component to use
+ * @param loglevel what types of messages should be logged
+ */
+int
+GNUNET_log_setup (const char *comp, const char *loglevel, const char *logfile)
+{
+  FILE *altlog;
+
+  component = comp;
+  min_level = get_type (loglevel);
+  if (logfile == NULL)
+    return GNUNET_OK;
+  altlog = fopen (logfile, "a");
+  if (altlog == NULL)
+    {
+      GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_ERROR, "fopen", logfile);
+      return GNUNET_SYSERR;
+    }
+  if (stderr != NULL)
+    fclose (stderr);
+  stderr = altlog;
+  return GNUNET_OK;
+}
+
+/**
+ * Add a custom logger.
+ *
+ * @param logger log function
+ * @param logger_cls closure for logger
+ */
+void
+GNUNET_logger_add (GNUNET_Logger logger, void *logger_cls)
+{
+  struct CustomLogger *entry;
+
+  entry = GNUNET_malloc (sizeof (struct CustomLogger));
+  entry->logger = logger;
+  entry->logger_cls = logger_cls;
+  entry->next = loggers;
+  loggers = entry;
+}
+
+/**
+ * Remove a custom logger.
+ *
+ * @param logger log function
+ * @param logger_cls closure for logger
+ */
+void
+GNUNET_logger_remove (GNUNET_Logger logger, void *logger_cls)
+{
+  struct CustomLogger *pos;
+  struct CustomLogger *prev;
+
+  prev = NULL;
+  pos = loggers;
+  while ((pos != NULL) &&
+         ((pos->logger != logger) || (pos->logger_cls != logger_cls)))
+    {
+      prev = pos;
+      pos = pos->next;
+    }
+  GNUNET_assert (pos != NULL);
+  if (prev == NULL)
+    loggers = pos->next;
+  else
+    prev->next = pos->next;
+  GNUNET_free (pos);
+}
+
+static void
+output_message (enum GNUNET_ErrorType kind,
+                const char *comp, const char *datestr, const char *msg)
+{
+  struct CustomLogger *pos;
+  if (stderr != NULL)
+    fprintf (stderr, "%s %s %s %s", datestr, comp,
+             GNUNET_error_type_to_string (kind), msg);
+  pos = loggers;
+  while (pos != NULL)
+    {
+      pos->logger (pos->logger_cls, kind, comp, datestr, msg);
+      pos = pos->next;
+    }
+}
+
+static void
+flush_bulk (const char *datestr)
+{
+  char msg[DATE_STR_SIZE + BULK_TRACK_SIZE + 256];
+  int rev;
+  char *last;
+  char *ft;
+
+  if ((last_bulk_time.value == 0) || (last_bulk_repeat == 0))
+    return;
+  rev = 0;
+  last = memchr (last_bulk, '\0', BULK_TRACK_SIZE);
+  if (last == NULL)
+    last = &last_bulk[BULK_TRACK_SIZE - 1];
+  else if (last != last_bulk)
+    last--;
+  if (last[0] == '\n')
+    {
+      rev = 1;
+      last[0] = '\0';
+    }
+  ft =
+    GNUNET_STRINGS_relative_time_to_string (GNUNET_TIME_absolute_get_duration
+                                            (last_bulk_time));
+  snprintf (msg, sizeof (msg),
+            _("Message `%.*s' repeated %u times in the last %s\n"),
+            BULK_TRACK_SIZE, last_bulk, last_bulk_repeat, ft);
+  GNUNET_free (ft);
+  if (rev == 1)
+    last[0] = '\n';
+  output_message (last_bulk_kind, last_bulk_comp, datestr, msg);
+  last_bulk_time = GNUNET_TIME_absolute_get ();
+  last_bulk_repeat = 0;
+}
+
+
+/**
+ * Ignore the next n calls to the log function.
+ *
+ * @param n number of log calls to ignore
+ */
+void
+GNUNET_log_skip (unsigned int n)
+{
+  int ok;
+
+  if (n == 0)
+    {
+      ok = (0 == skip_log);
+      skip_log = 0;
+      GNUNET_assert (ok);
+    }
+  skip_log += n;
+}
+
+
+static void
+mylog (enum GNUNET_ErrorType kind,
+       const char *comp, const char *message, va_list va)
+{
+  char date[DATE_STR_SIZE];
+  time_t timetmp;
+  struct tm *tmptr;
+  size_t size;
+  char *buf;
+  va_list vacp;
+
+  if (skip_log > 0)
+    {
+      skip_log--;
+      return;
+    }
+  if ((kind & (~GNUNET_ERROR_TYPE_BULK)) > min_level)
+    return;
+  va_copy (vacp, va);
+  size = VSNPRINTF (NULL, 0, message, vacp) + 1;
+  va_end (vacp);
+  buf = malloc (size);
+  if (buf == NULL)
+    return;                     /* oops */
+  VSNPRINTF (buf, size, message, va);
+  time (&timetmp);
+  memset (date, 0, DATE_STR_SIZE);
+  tmptr = localtime (&timetmp);
+  strftime (date, DATE_STR_SIZE, "%b %d %H:%M:%S", tmptr);
+  if ((0 != (kind & GNUNET_ERROR_TYPE_BULK)) &&
+      (last_bulk_time.value != 0) &&
+      (0 == strncmp (buf, last_bulk, sizeof (last_bulk))))
+    {
+      last_bulk_repeat++;
+      if ((GNUNET_TIME_absolute_get_duration (last_bulk_time).value >
+           BULK_DELAY_THRESHOLD)
+          || (last_bulk_repeat > BULK_REPEAT_THRESHOLD))
+        flush_bulk (date);
+      free (buf);
+      return;
+    }
+  flush_bulk (date);
+  strncpy (last_bulk, buf, sizeof (last_bulk));
+  last_bulk_repeat = 0;
+  last_bulk_kind = kind;
+  last_bulk_time = GNUNET_TIME_absolute_get ();
+  last_bulk_comp = comp;
+  output_message (kind, comp, date, buf);
+  free (buf);
+}
+
+
+void
+GNUNET_log (enum GNUNET_ErrorType kind, const char *message, ...)
+{
+  va_list va;
+  va_start (va, message);
+  mylog (kind, component, message, va);
+  va_end (va);
+}
+
+
+void
+GNUNET_log_from (enum GNUNET_ErrorType kind,
+                 const char *comp, const char *message, ...)
+{
+  va_list va;
+  va_start (va, message);
+  mylog (kind, comp, message, va);
+  va_end (va);
+}
+
+
+/**
+ * Convert KIND to String
+ */
+const char *
+GNUNET_error_type_to_string (enum GNUNET_ErrorType kind)
+{
+  if ((kind & GNUNET_ERROR_TYPE_ERROR) > 0)
+    return _("ERROR");
+  if ((kind & GNUNET_ERROR_TYPE_WARNING) > 0)
+    return _("WARNING");
+  if ((kind & GNUNET_ERROR_TYPE_INFO) > 0)
+    return _("INFO");
+  if ((kind & GNUNET_ERROR_TYPE_DEBUG) > 0)
+    return _("DEBUG");
+  return _("INVALID");
+}
+
+
+/**
+ * Convert a peer identity to a string (for printing debug messages).
+ * This is one of the very few calls in the entire API that is
+ * NOT reentrant!
+ *
+ * @param pid the peer identity
+ * @return string form of the pid; will be overwritten by next
+ *         call to GNUNET_i2s.
+ */
+const char *
+GNUNET_i2s (const struct GNUNET_PeerIdentity *pid)
+{
+  static struct GNUNET_CRYPTO_HashAsciiEncoded ret;
+  GNUNET_CRYPTO_hash_to_enc (&pid->hashPubKey, &ret);
+  ret.encoding[4] = '\0';
+  return (const char *) ret.encoding;
+}
+
+
+
+/* end of common_logging.c */
diff --git a/src/util/configuration.c b/src/util/configuration.c
new file mode 100644
index 000000000..4413b0377
--- /dev/null
+++ b/src/util/configuration.c
@@ -0,0 +1,848 @@
+/*
+     This file is part of GNUnet.
+     (C) 2006, 2007, 2008, 2009 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/util/configuration.c
+ * @brief configuration management
+ *
+ * @author Christian Grothoff
+ */
+
+#include "platform.h"
+#include "gnunet_common.h"
+#include "gnunet_configuration_lib.h"
+#include "gnunet_crypto_lib.h"
+#include "gnunet_disk_lib.h"
+#include "gnunet_os_lib.h"
+#include "gnunet_strings_lib.h"
+
+/**
+ * @brief configuration entry
+ */
+struct ConfigEntry
+{
+
+  /**
+   * This is a linked list.
+   */
+  struct ConfigEntry *next;
+
+  /**
+   * key for this entry
+   */
+  char *key;
+
+  /**
+   * current, commited value
+   */
+  char *val;
+};
+
+/**
+ * @brief configuration section
+ */
+struct ConfigSection
+{
+  /**
+   * This is a linked list.
+   */
+  struct ConfigSection *next;
+
+  /**
+   * entries in the section
+   */
+  struct ConfigEntry *entries;
+
+  /**
+   * name of the section
+   */
+  char *name;
+};
+
+/**
+ * @brief configuration data
+ */
+struct GNUNET_CONFIGURATION_Handle
+{
+  /**
+   * Configuration sections.
+   */
+  struct ConfigSection *sections;
+
+  /**
+   * Modification indication since last save
+   * GNUNET_NO if clean, GNUNET_YES if dirty,
+   * GNUNET_SYSERR on error (i.e. last save failed)
+   */
+  int dirty;
+
+};
+
+/**
+ * Create a GNUNET_CONFIGURATION_Configuration.
+ */
+struct GNUNET_CONFIGURATION_Handle *
+GNUNET_CONFIGURATION_create ()
+{
+  return GNUNET_malloc (sizeof (struct GNUNET_CONFIGURATION_Handle));
+}
+
+void
+GNUNET_CONFIGURATION_destroy (struct GNUNET_CONFIGURATION_Handle *cfg)
+{
+  struct ConfigSection *sec;
+  struct ConfigEntry *ent;
+
+  while (NULL != (sec = cfg->sections))
+    {
+      cfg->sections = sec->next;
+      while (NULL != (ent = sec->entries))
+        {
+          sec->entries = ent->next;
+          GNUNET_free (ent->key);
+          GNUNET_free_non_null (ent->val);
+          GNUNET_free (ent);
+        }
+      GNUNET_free (sec->name);
+      GNUNET_free (sec);
+    }
+  GNUNET_free (cfg);
+}
+
+int
+GNUNET_CONFIGURATION_parse (struct GNUNET_CONFIGURATION_Handle *cfg,
+                            const char *filename)
+{
+  int dirty;
+  char line[256];
+  char tag[64];
+  char value[192];
+  FILE *fp;
+  unsigned int nr;
+  int i;
+  int emptyline;
+  int ret;
+  char *section;
+  char *fn;
+
+  fn = GNUNET_STRINGS_filename_expand (filename);
+  dirty = cfg->dirty;           /* back up value! */
+  if (NULL == (fp = FOPEN (fn, "r")))
+    {
+      GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING, "fopen", fn);
+      GNUNET_free (fn);
+      return GNUNET_SYSERR;
+    }
+  GNUNET_free (fn);
+  ret = GNUNET_OK;
+  section = GNUNET_strdup ("");
+  memset (line, 0, 256);
+  nr = 0;
+  while (NULL != fgets (line, 255, fp))
+    {
+      nr++;
+      for (i = 0; i < 255; i++)
+        if (line[i] == '\t')
+          line[i] = ' ';
+      if (line[0] == '\n' || line[0] == '#' || line[0] == '%' ||
+          line[0] == '\r')
+        continue;
+      emptyline = 1;
+      for (i = 0; (i < 255 && line[i] != 0); i++)
+        if (line[i] != ' ' && line[i] != '\n' && line[i] != '\r')
+          emptyline = 0;
+      if (emptyline == 1)
+        continue;
+      /* remove tailing whitespace */
+      for (i = strlen (line) - 1; (i >= 0) && (isspace (line[i])); i--)
+        line[i] = '\0';
+      if (1 == sscanf (line, "@INLINE@ %191[^\n]", value))
+        {
+          /* @INLINE@ value */
+          if (0 != GNUNET_CONFIGURATION_parse (cfg, value))
+            ret = GNUNET_SYSERR;        /* failed to parse included config */
+        }
+      else if (1 == sscanf (line, "[%99[^]]]", value))
+        {
+          /* [value] */
+          GNUNET_free (section);
+          section = GNUNET_strdup (value);
+        }
+      else if (2 == sscanf (line, " %63[^= ] = %191[^\n]", tag, value))
+        {
+          /* tag = value */
+          /* Strip LF */
+          i = strlen (value) - 1;
+          while ((i >= 0) && (isspace (value[i])))
+            value[i--] = '\0';
+          /* remove quotes */
+          i = 0;
+          if (value[0] == '"')
+            {
+              i = 1;
+              while ((value[i] != '\0') && (value[i] != '"'))
+                i++;
+              if (value[i] == '"')
+                {
+                  value[i] = '\0';
+                  i = 1;
+                }
+              else
+                i = 0;
+            }
+          GNUNET_CONFIGURATION_set_value_string (cfg,
+                                                 section, tag, &value[i]);
+        }
+      else if (1 == sscanf (line, " %63[^= ] =[^\n]", tag))
+        {
+          /* tag = */
+          GNUNET_CONFIGURATION_set_value_string (cfg, section, tag, "");
+        }
+      else
+        {
+          /* parse error */
+          GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                      _
+                      ("Syntax error in configuration file `%s' at line %u.\n"),
+                      filename, nr);
+          ret = GNUNET_SYSERR;
+          break;
+        }
+    }
+  GNUNET_assert (0 == fclose (fp));
+  /* restore dirty flag - anything we set in the meantime
+     came from disk */
+  cfg->dirty = dirty;
+  GNUNET_free (section);
+  return ret;
+}
+
+int
+GNUNET_CONFIGURATION_test_dirty (struct GNUNET_CONFIGURATION_Handle *cfg)
+{
+  return cfg->dirty;
+}
+
+int
+GNUNET_CONFIGURATION_write (struct GNUNET_CONFIGURATION_Handle *data,
+                            const char *filename)
+{
+  struct ConfigSection *sec;
+  struct ConfigEntry *ent;
+  FILE *fp;
+  int error;
+  char *fn;
+  char *val;
+  char *pos;
+
+  fn = GNUNET_STRINGS_filename_expand (filename);
+  GNUNET_DISK_directory_create_for_file (fn);
+  if (NULL == (fp = FOPEN (fn, "w")))
+    {
+      GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING, "fopen", fn);
+      GNUNET_free (fn);
+      return GNUNET_SYSERR;
+    }
+  GNUNET_free (fn);
+  error = 0;
+  sec = data->sections;
+  while (sec != NULL)
+    {
+      if (0 > fprintf (fp, "[%s]\n", sec->name))
+        {
+          error = 1;
+          break;
+        }
+      ent = sec->entries;
+      while (ent != NULL)
+        {
+          if (ent->val != NULL)
+            {
+              val = GNUNET_malloc (strlen (ent->val) * 2 + 1);
+              strcpy (val, ent->val);
+              while (NULL != (pos = strstr (val, "\n")))
+                {
+                  memmove (&pos[2], &pos[1], strlen (&pos[1]));
+                  pos[0] = '\\';
+                  pos[1] = 'n';
+                }
+              if (0 > fprintf (fp, "%s = %s\n", ent->key, val))
+                {
+                  error = 1;
+                  GNUNET_free (val);
+                  break;
+                }
+              GNUNET_free (val);
+            }
+          ent = ent->next;
+        }
+      if (error != 0)
+        break;
+      if (0 > fprintf (fp, "\n"))
+        {
+          error = 1;
+          break;
+        }
+      sec = sec->next;
+    }
+  if (error != 0)
+    GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING, "fprintf", filename);
+  GNUNET_assert (0 == fclose (fp));
+  if (error != 0)
+    {
+      data->dirty = GNUNET_SYSERR;      /* last write failed */
+      return GNUNET_SYSERR;
+    }
+  data->dirty = GNUNET_NO;      /* last write succeeded */
+  return GNUNET_OK;
+}
+
+
+static struct ConfigSection *
+findSection (struct GNUNET_CONFIGURATION_Handle *data, const char *section)
+{
+  struct ConfigSection *pos;
+
+  pos = data->sections;
+  while ((pos != NULL) && (0 != strcasecmp (section, pos->name)))
+    pos = pos->next;
+  return pos;
+}
+
+
+static struct ConfigEntry *
+findEntry (struct GNUNET_CONFIGURATION_Handle *data,
+           const char *section, const char *key)
+{
+  struct ConfigSection *sec;
+  struct ConfigEntry *pos;
+
+  sec = findSection (data, section);
+  if (sec == NULL)
+    return NULL;
+  pos = sec->entries;
+  while ((pos != NULL) && (0 != strcasecmp (key, pos->key)))
+    pos = pos->next;
+  return pos;
+}
+
+void
+GNUNET_CONFIGURATION_set_value_string (struct GNUNET_CONFIGURATION_Handle
+                                       *data,
+                                       const char *section,
+                                       const char *option, const char *value)
+{
+  struct ConfigSection *sec;
+  struct ConfigEntry *e;
+
+  e = findEntry (data, section, option);
+  if (e != NULL)
+    {
+      GNUNET_free_non_null (e->val);
+      e->val = GNUNET_strdup (value);
+      return;
+    }
+  sec = findSection (data, section);
+  if (sec == NULL)
+    {
+      sec = GNUNET_malloc (sizeof (struct ConfigSection));
+      sec->name = GNUNET_strdup (section);
+      sec->next = data->sections;
+      data->sections = sec;
+    }
+  e = GNUNET_malloc (sizeof (struct ConfigEntry));
+  e->key = GNUNET_strdup (option);
+  e->val = GNUNET_strdup (value);
+  e->next = sec->entries;
+  sec->entries = e;
+}
+
+void
+GNUNET_CONFIGURATION_set_value_number (struct GNUNET_CONFIGURATION_Handle
+                                       *cfg, const char *section,
+                                       const char *option,
+                                       unsigned long long number)
+{
+  char s[64];
+  GNUNET_snprintf (s, 64, "%llu", number);
+  GNUNET_CONFIGURATION_set_value_string (cfg, section, option, s);
+}
+
+int
+GNUNET_CONFIGURATION_get_value_number (struct GNUNET_CONFIGURATION_Handle
+                                       *cfg, const char *section,
+                                       const char *option,
+                                       unsigned long long *number)
+{
+  struct ConfigEntry *e;
+
+  e = findEntry (cfg, section, option);
+  if (e == NULL)
+    return GNUNET_SYSERR;
+  if (1 != SSCANF (e->val, "%llu", number))
+    return GNUNET_SYSERR;
+  return GNUNET_OK;
+}
+
+int
+GNUNET_CONFIGURATION_get_value_string (struct GNUNET_CONFIGURATION_Handle
+                                       *cfg, const char *section,
+                                       const char *option, char **value)
+{
+  struct ConfigEntry *e;
+
+  e = findEntry (cfg, section, option);
+  if ((e == NULL) || (e->val == NULL))
+    {
+      *value = NULL;
+      return GNUNET_SYSERR;
+    }
+  *value = GNUNET_strdup (e->val);
+  return GNUNET_OK;
+}
+
+int
+GNUNET_CONFIGURATION_get_value_choice (struct GNUNET_CONFIGURATION_Handle
+                                       *cfg, const char *section,
+                                       const char *option,
+                                       const char **choices,
+                                       const char **value)
+{
+  struct ConfigEntry *e;
+  int i;
+
+  e = findEntry (cfg, section, option);
+  if (e == NULL)
+    return GNUNET_SYSERR;
+  i = 0;
+  while (choices[i] != NULL)
+    {
+      if (0 == strcasecmp (choices[i], e->val))
+        break;
+      i++;
+    }
+  if (choices[i] == NULL)
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                  _("Configuration value '%s' for '%s'"
+                    " in section '%s' is not in set of legal choices\n"),
+                  e->val, option, section);
+      return GNUNET_SYSERR;
+    }
+  *value = choices[i];
+  return GNUNET_OK;
+}
+
+/**
+ * Test if we have a value for a particular option
+ * @return GNUNET_YES if so, GNUNET_NO if not.
+ */
+int
+GNUNET_CONFIGURATION_have_value (struct GNUNET_CONFIGURATION_Handle *cfg,
+                                 const char *section, const char *option)
+{
+  struct ConfigEntry *e;
+  if ((NULL == (e = findEntry (cfg, section, option))) || (e->val == NULL))
+    return GNUNET_NO;
+  return GNUNET_YES;
+}
+
+/**
+ * Expand an expression of the form "$FOO/BAR" to "DIRECTORY/BAR"
+ * where either in the "PATHS" section or the environtment
+ * "FOO" is set to "DIRECTORY".
+ *
+ * @param old string to $-expand (will be freed!)
+ * @return $-expanded string
+ */
+char *
+GNUNET_CONFIGURATION_expand_dollar (struct GNUNET_CONFIGURATION_Handle *cfg,
+                                    char *orig)
+{
+  int i;
+  char *prefix;
+  char *result;
+  const char *post;
+  const char *env;
+
+  if (orig[0] != '$')
+    return orig;
+  i = 0;
+  while ((orig[i] != '/') && (orig[i] != '\\') && (orig[i] != '\0'))
+    i++;
+  if (orig[i] == '\0')
+    {
+      post = "";
+    }
+  else
+    {
+      orig[i] = '\0';
+      post = &orig[i + 1];
+    }
+  if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_string (cfg,
+                                                          "PATHS",
+                                                          &orig[1], &prefix))
+    {
+      if (NULL == (env = getenv (&orig[1])))
+        {
+          orig[i] = DIR_SEPARATOR;
+          return orig;
+        }
+      prefix = GNUNET_strdup (env);
+    }
+  result = GNUNET_malloc (strlen (prefix) + strlen (post) + 2);
+  strcpy (result, prefix);
+  if ((strlen (prefix) == 0) ||
+      ((prefix[strlen (prefix) - 1] != DIR_SEPARATOR) && (strlen (post) > 0)))
+    strcat (result, DIR_SEPARATOR_STR);
+  strcat (result, post);
+  GNUNET_free (prefix);
+  GNUNET_free (orig);
+  return result;
+}
+
+/**
+ * Get a configuration value that should be a string.
+ * @param value will be set to a freshly allocated configuration
+ *        value, or NULL if option is not specified
+ * @return GNUNET_OK on success, GNUNET_SYSERR on error
+ */
+int
+GNUNET_CONFIGURATION_get_value_filename (struct GNUNET_CONFIGURATION_Handle
+                                         *data, const char *section,
+                                         const char *option, char **value)
+{
+  int ret;
+  char *tmp;
+
+  tmp = NULL;
+  ret = GNUNET_CONFIGURATION_get_value_string (data, section, option, &tmp);
+  if (ret == GNUNET_SYSERR)
+    return ret;
+  if (tmp != NULL)
+    {
+      tmp = GNUNET_CONFIGURATION_expand_dollar (data, tmp);
+      *value = GNUNET_STRINGS_filename_expand (tmp);
+      GNUNET_free (tmp);
+    }
+  else
+    {
+      *value = NULL;
+    }
+  return ret;
+}
+
+/**
+ * Get a configuration value that should be in a set of
+ * "GNUNET_YES" or "GNUNET_NO".
+ *
+ * @return GNUNET_YES, GNUNET_NO or GNUNET_SYSERR
+ */
+int
+GNUNET_CONFIGURATION_get_value_yesno (struct GNUNET_CONFIGURATION_Handle *cfg,
+                                      const char *section, const char *option)
+{
+  static const char *yesno[] = { "YES", "NO", NULL };
+  const char *val;
+  int ret;
+
+  ret = GNUNET_CONFIGURATION_get_value_choice (cfg,
+                                               section, option, yesno, &val);
+  if (ret == GNUNET_SYSERR)
+    return ret;
+  if (val == yesno[0])
+    return GNUNET_YES;
+  return GNUNET_NO;
+}
+
+
+/**
+ * Iterate over the set of filenames stored in a configuration value.
+ *
+ * @return number of filenames iterated over, -1 on error
+ */
+int
+GNUNET_CONFIGURATION_iterate_value_filenames (struct
+                                              GNUNET_CONFIGURATION_Handle
+                                              *cfg, const char *section,
+                                              const char *option,
+                                              GNUNET_FileNameCallback cb,
+                                              void *cls)
+{
+  char *list;
+  char *pos;
+  char *end;
+  char old;
+  int ret;
+
+  if (GNUNET_OK !=
+      GNUNET_CONFIGURATION_get_value_string (cfg, section, option, &list))
+    return 0;
+  GNUNET_assert (list != NULL);
+  ret = 0;
+  pos = list;
+  while (1)
+    {
+      while (pos[0] == ' ')
+        pos++;
+      if (strlen (pos) == 0)
+        break;
+      end = pos + 1;
+      while ((end[0] != ' ') && (end[0] != '\0'))
+        {
+          if (end[0] == '\\')
+            {
+              switch (end[1])
+                {
+                case '\\':
+                case ' ':
+                  memmove (end, &end[1], strlen (&end[1]) + 1);
+                case '\0':
+                  /* illegal, but just keep it */
+                  break;
+                default:
+                  /* illegal, but just ignore that there was a '/' */
+                  break;
+                }
+            }
+          end++;
+        }
+      old = end[0];
+      end[0] = '\0';
+      if (strlen (pos) > 0)
+        {
+          ret++;
+          if ((cb != NULL) && (GNUNET_OK != cb (cls, pos)))
+            {
+              ret = GNUNET_SYSERR;
+              break;
+            }
+        }
+      if (old == '\0')
+        break;
+      pos = end + 1;
+    }
+  GNUNET_free (list);
+  return ret;
+}
+
+static char *
+escape_name (const char *value)
+{
+  char *escaped;
+  const char *rpos;
+  char *wpos;
+
+  escaped = GNUNET_malloc (strlen (value) * 2 + 1);
+  memset (escaped, 0, strlen (value) * 2 + 1);
+  rpos = value;
+  wpos = escaped;
+  while (rpos[0] != '\0')
+    {
+      switch (rpos[0])
+        {
+        case '\\':
+        case ' ':
+          wpos[0] = '\\';
+          wpos[1] = rpos[0];
+          wpos += 2;
+          break;
+        default:
+          wpos[0] = rpos[0];
+          wpos++;
+        }
+      rpos++;
+    }
+  return escaped;
+}
+
+static int
+test_match (void *cls, const char *fn)
+{
+  const char *of = cls;
+  return (0 == strcmp (of, fn)) ? GNUNET_SYSERR : GNUNET_OK;
+}
+
+/**
+ * Append a filename to a configuration value that
+ * represents a list of filenames
+ *
+ * @param value filename to append
+ * @return GNUNET_OK on success,
+ *         GNUNET_NO if the filename already in the list
+ *         GNUNET_SYSERR on error
+ */
+int
+GNUNET_CONFIGURATION_append_value_filename (struct GNUNET_CONFIGURATION_Handle
+                                            *cfg,
+                                            const char *section,
+                                            const char *option,
+                                            const char *value)
+{
+  char *escaped;
+  char *old;
+  char *nw;
+
+  if (GNUNET_SYSERR
+      == GNUNET_CONFIGURATION_iterate_value_filenames (cfg,
+                                                       section,
+                                                       option,
+                                                       &test_match,
+                                                       (void *) value))
+    return GNUNET_NO;           /* already exists */
+  if (GNUNET_OK !=
+      GNUNET_CONFIGURATION_get_value_string (cfg, section, option, &old))
+    old = GNUNET_strdup ("");
+  escaped = escape_name (value);
+  nw = GNUNET_malloc (strlen (old) + strlen (escaped) + 2);
+  strcpy (nw, old);
+  strcat (nw, " ");
+  strcat (nw, escaped);
+  GNUNET_CONFIGURATION_set_value_string (cfg, section, option, nw);
+  GNUNET_free (old);
+  GNUNET_free (nw);
+  GNUNET_free (escaped);
+  return GNUNET_OK;
+}
+
+
+/**
+ * Remove a filename from a configuration value that
+ * represents a list of filenames
+ *
+ * @param value filename to remove
+ * @return GNUNET_OK on success,
+ *         GNUNET_NO if the filename is not in the list,
+ *         GNUNET_SYSERR on error
+ */
+int
+GNUNET_CONFIGURATION_remove_value_filename (struct GNUNET_CONFIGURATION_Handle
+                                            *cfg,
+                                            const char *section,
+                                            const char *option,
+                                            const char *value)
+{
+  char *list;
+  char *pos;
+  char *end;
+  char *match;
+  char old;
+  int ret;
+
+  if (GNUNET_OK !=
+      GNUNET_CONFIGURATION_get_value_string (cfg, section, option, &list))
+    return GNUNET_NO;
+  match = escape_name (value);
+  ret = 0;
+  pos = list;
+  while (1)
+    {
+      while (pos[0] == ' ')
+        pos++;
+      if (strlen (pos) == 0)
+        break;
+      end = pos + 1;
+      while ((end[0] != ' ') && (end[0] != '\0'))
+        {
+          if (end[0] == '\\')
+            {
+              switch (end[1])
+                {
+                case '\\':
+                case ' ':
+                  end++;
+                  break;
+                case '\0':
+                  /* illegal, but just keep it */
+                  break;
+                default:
+                  /* illegal, but just ignore that there was a '/' */
+                  break;
+                }
+            }
+          end++;
+        }
+      old = end[0];
+      end[0] = '\0';
+      if (strlen (pos) > 0)
+        {
+          if (0 == strcmp (pos, match))
+            {
+              memmove (pos, &end[1], strlen (&end[1]) + 1);
+
+              if (pos != list)
+                pos[-1] = ' ';  /* previously changed to "\0" */
+              GNUNET_CONFIGURATION_set_value_string (cfg,
+                                                     section, option, list);
+              GNUNET_free (list);
+              GNUNET_free (match);
+              return GNUNET_OK;
+            }
+        }
+      if (old == '\0')
+        break;
+      pos = end + 1;
+    }
+  GNUNET_free (list);
+  GNUNET_free (match);
+  return GNUNET_NO;
+}
+
+
+/**
+ * Load configuration (starts with defaults, then loads
+ * system-specific configuration).
+ */
+int
+GNUNET_CONFIGURATION_load (struct GNUNET_CONFIGURATION_Handle *cfg,
+                           const char *cfgfn)
+{
+  char *baseconfig;
+  char *ipath;
+
+  ipath = GNUNET_OS_installation_get_path (GNUNET_OS_IPK_DATADIR);
+  if (ipath == NULL)
+    return GNUNET_SYSERR;
+  baseconfig = NULL;
+  GNUNET_asprintf (&baseconfig,
+                   "%s%s%s", ipath, DIR_SEPARATOR_STR, "defaults.conf");
+  GNUNET_free (ipath);
+  if ((GNUNET_OK !=
+       GNUNET_CONFIGURATION_parse (cfg, baseconfig)) ||
+      (!((cfgfn == NULL) ||
+         (GNUNET_OK == GNUNET_CONFIGURATION_parse (cfg, cfgfn)))))
+    {
+      GNUNET_free (baseconfig);
+      return GNUNET_SYSERR;
+    }
+  GNUNET_free (baseconfig);
+  if ((GNUNET_YES == GNUNET_CONFIGURATION_have_value (cfg,
+                                                      "TESTING",
+                                                      "WEAKRANDOM")) &&
+      (GNUNET_YES == GNUNET_CONFIGURATION_get_value_yesno (cfg,
+                                                           "TESTING",
+                                                           "WEAKRANDOM")))
+    GNUNET_CRYPTO_random_disable_entropy_gathering ();
+  return GNUNET_OK;
+}
+
+
+
+/* end of configuration.c */
diff --git a/src/util/container_bloomfilter.c b/src/util/container_bloomfilter.c
new file mode 100644
index 000000000..8b76ef8dc
--- /dev/null
+++ b/src/util/container_bloomfilter.c
@@ -0,0 +1,677 @@
+/*
+     This file is part of GNUnet.
+     (C) 2001, 2002, 2003, 2004, 2006, 2008 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 util/container_bloomfilter.c
+ * @brief data structure used to reduce disk accesses.
+ *
+ * The idea basically: Create a signature for each element in the
+ * database. Add those signatures to a bit array. When doing a lookup,
+ * check if the bit array matches the signature of the requested
+ * element. If yes, address the disk, otherwise return 'not found'.
+ *
+ * A property of the bloom filter is that sometimes we will have
+ * a match even if the element is not on the disk (then we do
+ * an unnecessary disk access), but what's most important is that
+ * we never get a single "false negative".
+ *
+ * To be able to delete entries from the bloom filter, we maintain
+ * a 4 bit counter in the file on the drive (we still use only one
+ * bit in memory).
+ *
+ * @author Igor Wronsky
+ * @author Christian Grothoff
+ */
+
+#include "platform.h"
+#include "gnunet_common.h"
+#include "gnunet_container_lib.h"
+#include "gnunet_disk_lib.h"
+
+struct GNUNET_CONTAINER_BloomFilter
+{
+
+  /**
+   * The actual bloomfilter bit array
+   */
+  char *bitArray;
+
+  /**
+   * Filename of the filter
+   */
+  char *filename;
+
+  /**
+   * The bit counter file on disk
+   */
+  int fd;
+
+  /**
+   * How many bits we set for each stored element
+   */
+  unsigned int addressesPerElement;
+
+  /**
+   * Size of bitArray in bytes
+   */
+  unsigned int bitArraySize;
+
+};
+
+
+/**
+ * Sets a bit active in the bitArray. Increment bit-specific
+ * usage counter on disk only if below 4bit max (==15).
+ *
+ * @param bitArray memory area to set the bit in
+ * @param bitIdx which bit to set
+ */
+static void
+setBit (char *bitArray, unsigned int bitIdx)
+{
+  unsigned int arraySlot;
+  unsigned int targetBit;
+
+  arraySlot = bitIdx / 8;
+  targetBit = (1L << (bitIdx % 8));
+  bitArray[arraySlot] |= targetBit;
+}
+
+/**
+ * Clears a bit from bitArray. Bit is cleared from the array
+ * only if the respective usage counter on the disk hits/is zero.
+ *
+ * @param bitArray memory area to set the bit in
+ * @param bitIdx which bit to unset
+ */
+static void
+clearBit (char *bitArray, unsigned int bitIdx)
+{
+  unsigned int slot;
+  unsigned int targetBit;
+
+  slot = bitIdx / 8;
+  targetBit = (1L << (bitIdx % 8));
+  bitArray[slot] = bitArray[slot] & (~targetBit);
+}
+
+/**
+ * Checks if a bit is active in the bitArray
+ *
+ * @param bitArray memory area to set the bit in
+ * @param bitIdx which bit to test
+ * @return GNUNET_YES if the bit is set, GNUNET_NO if not.
+ */
+static int
+testBit (char *bitArray, unsigned int bitIdx)
+{
+  unsigned int slot;
+  unsigned int targetBit;
+
+  slot = bitIdx / 8;
+  targetBit = (1L << (bitIdx % 8));
+  if (bitArray[slot] & targetBit)
+    return GNUNET_YES;
+  else
+    return GNUNET_NO;
+}
+
+/**
+ * Sets a bit active in the bitArray and increments
+ * bit-specific usage counter on disk (but only if
+ * the counter was below 4 bit max (==15)).
+ *
+ * @param bitArray memory area to set the bit in
+ * @param bitIdx which bit to test
+ * @param fd A file to keep the 4 bit address usage counters in
+ */
+static void
+incrementBit (char *bitArray, unsigned int bitIdx, int fd)
+{
+  unsigned int fileSlot;
+  unsigned char value;
+  unsigned int high;
+  unsigned int low;
+  unsigned int targetLoc;
+
+  setBit (bitArray, bitIdx);
+  if (fd == -1)
+    return;
+  /* Update the counter file on disk */
+  fileSlot = bitIdx / 2;
+  targetLoc = bitIdx % 2;
+
+  GNUNET_assert (fileSlot == (unsigned int) LSEEK (fd, fileSlot, SEEK_SET));
+  if (1 != READ (fd, &value, 1))
+    value = 0;
+  low = value & 0xF;
+  high = (value & (~0xF)) >> 4;
+
+  if (targetLoc == 0)
+    {
+      if (low < 0xF)
+        low++;
+    }
+  else
+    {
+      if (high < 0xF)
+        high++;
+    }
+  value = ((high << 4) | low);
+  GNUNET_assert (fileSlot == (unsigned int) LSEEK (fd, fileSlot, SEEK_SET));
+  GNUNET_assert (1 == WRITE (fd, &value, 1));
+}
+
+/**
+ * Clears a bit from bitArray if the respective usage
+ * counter on the disk hits/is zero.
+ *
+ * @param bitArray memory area to set the bit in
+ * @param bitIdx which bit to test
+ * @param fd A file to keep the 4bit address usage counters in
+ */
+static void
+decrementBit (char *bitArray, unsigned int bitIdx, int fd)
+{
+  unsigned int fileSlot;
+  unsigned char value;
+  unsigned int high;
+  unsigned int low;
+  unsigned int targetLoc;
+
+  if (fd == -1)
+    return;                     /* cannot decrement! */
+  /* Each char slot in the counter file holds two 4 bit counters */
+  fileSlot = bitIdx / 2;
+  targetLoc = bitIdx % 2;
+  LSEEK (fd, fileSlot, SEEK_SET);
+  if (1 != READ (fd, &value, 1))
+    value = 0;
+  low = value & 0xF;
+  high = (value & 0xF0) >> 4;
+
+  /* decrement, but once we have reached the max, never go back! */
+  if (targetLoc == 0)
+    {
+      if ((low > 0) && (low < 0xF))
+        low--;
+      if (low == 0)
+        {
+          clearBit (bitArray, bitIdx);
+        }
+    }
+  else
+    {
+      if ((high > 0) && (high < 0xF))
+        high--;
+      if (high == 0)
+        {
+          clearBit (bitArray, bitIdx);
+        }
+    }
+  value = ((high << 4) | low);
+  LSEEK (fd, fileSlot, SEEK_SET);
+  GNUNET_assert (1 == WRITE (fd, &value, 1));
+}
+
+#define BUFFSIZE 65536
+
+/**
+ * Creates a file filled with zeroes
+ *
+ * @param fd the file handle
+ * @param size the size of the file
+ * @return GNUNET_OK if created ok, GNUNET_SYSERR otherwise
+ */
+static int
+makeEmptyFile (int fd, unsigned int size)
+{
+  char *buffer;
+  unsigned int bytesleft = size;
+  int res = 0;
+
+  if (fd == -1)
+    return GNUNET_SYSERR;
+  buffer = GNUNET_malloc (BUFFSIZE);
+  memset (buffer, 0, BUFFSIZE);
+  LSEEK (fd, 0, SEEK_SET);
+
+  while (bytesleft > 0)
+    {
+      if (bytesleft > BUFFSIZE)
+        {
+          res = WRITE (fd, buffer, BUFFSIZE);
+          bytesleft -= BUFFSIZE;
+        }
+      else
+        {
+          res = WRITE (fd, buffer, bytesleft);
+          bytesleft = 0;
+        }
+      GNUNET_assert (res != -1);
+    }
+  GNUNET_free (buffer);
+  return GNUNET_OK;
+}
+
+/* ************** GNUNET_CONTAINER_BloomFilter GNUNET_CRYPTO_hash iterator ********* */
+
+/**
+ * Iterator (callback) method to be called by the
+ * bloomfilter iterator on each bit that is to be
+ * set or tested for the key.
+ *
+ * @param bf the filter to manipulate
+ * @param bit the current bit
+ * @param additional context specific argument
+ */
+typedef void (*BitIterator) (struct GNUNET_CONTAINER_BloomFilter * bf,
+                             unsigned int bit, void *arg);
+
+/**
+ * Call an iterator for each bit that the bloomfilter
+ * must test or set for this element.
+ *
+ * @param bf the filter
+ * @param callback the method to call
+ * @param arg extra argument to callback
+ * @param key the key for which we iterate over the BF bits
+ */
+static void
+iterateBits (struct GNUNET_CONTAINER_BloomFilter *bf,
+             BitIterator callback, void *arg, const GNUNET_HashCode * key)
+{
+  GNUNET_HashCode tmp[2];
+  int bitCount;
+  int round;
+  unsigned int slot = 0;
+
+  bitCount = bf->addressesPerElement;
+  memcpy (&tmp[0], key, sizeof (GNUNET_HashCode));
+  round = 0;
+  while (bitCount > 0)
+    {
+      while (slot < (sizeof (GNUNET_HashCode) / sizeof (unsigned int)))
+        {
+          callback (bf,
+                    (((unsigned int *) &tmp[round & 1])[slot]) &
+                    ((bf->bitArraySize * 8) - 1), arg);
+          slot++;
+          bitCount--;
+          if (bitCount == 0)
+            break;
+        }
+      if (bitCount > 0)
+        {
+          GNUNET_CRYPTO_hash (&tmp[round & 1], sizeof (GNUNET_HashCode),
+                              &tmp[(round + 1) & 1]);
+          round++;
+          slot = 0;
+        }
+    }
+}
+
+/**
+ * Callback: increment bit
+ *
+ * @param bf the filter to manipulate
+ * @param bit the bit to increment
+ * @param arg not used
+ */
+static void
+incrementBitCallback (struct GNUNET_CONTAINER_BloomFilter *bf,
+                      unsigned int bit, void *arg)
+{
+  incrementBit (bf->bitArray, bit, bf->fd);
+}
+
+/**
+ * Callback: decrement bit
+ *
+ * @param bf the filter to manipulate
+ * @param bit the bit to decrement
+ * @param arg not used
+ */
+static void
+decrementBitCallback (struct GNUNET_CONTAINER_BloomFilter *bf,
+                      unsigned int bit, void *arg)
+{
+  decrementBit (bf->bitArray, bit, bf->fd);
+}
+
+/**
+ * Callback: test if all bits are set
+ *
+ * @param bf the filter
+ * @param bit the bit to test
+ * @param arg pointer set to GNUNET_NO if bit is not set
+ */
+static void
+testBitCallback (struct GNUNET_CONTAINER_BloomFilter *bf, unsigned int bit,
+                 void *cls)
+{
+  int *arg = cls;
+  if (GNUNET_NO == testBit (bf->bitArray, bit))
+    *arg = GNUNET_NO;
+}
+
+/* *********************** INTERFACE **************** */
+
+/**
+ * Load a bloom-filter from a file.
+ *
+ * @param filename the name of the file (or the prefix)
+ * @param size the size of the bloom-filter (number of
+ *        bytes of storage space to use)
+ * @param k the number of GNUNET_CRYPTO_hash-functions to apply per
+ *        element (number of bits set per element in the set)
+ * @return the bloomfilter
+ */
+struct GNUNET_CONTAINER_BloomFilter *
+GNUNET_CONTAINER_bloomfilter_load (const char *filename, unsigned int size,
+                                   unsigned int k)
+{
+  struct GNUNET_CONTAINER_BloomFilter *bf;
+  char *rbuff;
+  unsigned int pos;
+  int i;
+  unsigned int ui;
+
+  if ((k == 0) || (size == 0))
+    return NULL;
+  if (size < BUFFSIZE)
+    size = BUFFSIZE;
+  ui = 1;
+  while (ui < size)
+    ui *= 2;
+  size = ui;                    /* make sure it's a power of 2 */
+
+  bf = GNUNET_malloc (sizeof (struct GNUNET_CONTAINER_BloomFilter));
+  /* Try to open a bloomfilter file */
+  if (filename != NULL)
+    {
+#ifndef _MSC_VER
+      bf->fd = GNUNET_DISK_file_open (filename, O_RDWR | O_CREAT,
+                                      S_IRUSR | S_IWUSR);
+#else
+      bf->fd = GNUNET_DISK_file_open (filename,
+                                      O_WRONLY | O_CREAT, S_IREAD | S_IWRITE);
+#endif
+      if (-1 == bf->fd)
+        {
+          GNUNET_free (bf);
+          return NULL;
+        }
+      bf->filename = GNUNET_strdup (filename);
+    }
+  else
+    {
+      bf->fd = -1;
+      bf->filename = NULL;
+    }
+  /* Alloc block */
+  bf->bitArray = GNUNET_malloc_large (size);
+  bf->bitArraySize = size;
+  bf->addressesPerElement = k;
+  memset (bf->bitArray, 0, bf->bitArraySize);
+
+  if (bf->fd != -1)
+    {
+      /* Read from the file what bits we can */
+      rbuff = GNUNET_malloc (BUFFSIZE);
+      pos = 0;
+      while (pos < size * 8)
+        {
+          int res;
+
+          res = READ (bf->fd, rbuff, BUFFSIZE);
+          if (res == 0)
+            break;              /* is ok! we just did not use that many bits yet */
+          for (i = 0; i < res; i++)
+            {
+              if ((rbuff[i] & 0x0F) != 0)
+                setBit (bf->bitArray, pos + i * 2);
+              if ((rbuff[i] & 0xF0) != 0)
+                setBit (bf->bitArray, pos + i * 2 + 1);
+            }
+          if (res < BUFFSIZE)
+            break;
+          pos += BUFFSIZE * 2;  /* 2 bits per byte in the buffer */
+        }
+      GNUNET_free (rbuff);
+    }
+  return bf;
+}
+
+
+/**
+ * Create a bloom filter from raw bits.
+ *
+ * @param data the raw bits in memory (maybe NULL,
+ *        in which case all bits should be considered
+ *        to be zero).
+ * @param size the size of the bloom-filter (number of
+ *        bytes of storage space to use); also size of data
+ *        -- unless data is NULL
+ * @param k the number of GNUNET_CRYPTO_hash-functions to apply per
+ *        element (number of bits set per element in the set)
+ * @return the bloomfilter
+ */
+struct GNUNET_CONTAINER_BloomFilter *
+GNUNET_CONTAINER_bloomfilter_init (const char *data, unsigned int size,
+                                   unsigned int k)
+{
+  struct GNUNET_CONTAINER_BloomFilter *bf;
+  unsigned int ui;
+
+  if ((k == 0) || (size == 0))
+    return NULL;
+  ui = 1;
+  while (ui < size)
+    ui *= 2;
+  if (size != ui)
+    {
+      GNUNET_break (0);
+      return NULL;
+    }
+  bf = GNUNET_malloc (sizeof (struct GNUNET_CONTAINER_BloomFilter));
+  bf->fd = -1;
+  bf->filename = NULL;
+  bf->bitArray = GNUNET_malloc_large (size);
+  bf->bitArraySize = size;
+  bf->addressesPerElement = k;
+  if (data != NULL)
+    memcpy (bf->bitArray, data, size);
+  else
+    memset (bf->bitArray, 0, bf->bitArraySize);
+  return bf;
+}
+
+
+/**
+ * Copy the raw data of this bloomfilter into
+ * the given data array.
+ *
+ * @param data where to write the data
+ * @param size the size of the given data array
+ * @return GNUNET_SYSERR if the data array is not big enough
+ */
+int
+GNUNET_CONTAINER_bloomfilter_get_raw_data (struct GNUNET_CONTAINER_BloomFilter
+                                           *bf, char *data, unsigned int size)
+{
+  if (NULL == bf)
+    return GNUNET_SYSERR;
+
+  if (bf->bitArraySize != size)
+    return GNUNET_SYSERR;
+  memcpy (data, bf->bitArray, size);
+  return GNUNET_OK;
+}
+
+/**
+ * Free the space associated with a filter
+ * in memory, flush to drive if needed (do not
+ * free the space on the drive)
+ *
+ * @param bf the filter
+ */
+void
+GNUNET_CONTAINER_bloomfilter_free (struct GNUNET_CONTAINER_BloomFilter *bf)
+{
+  if (NULL == bf)
+    return;
+  if (bf->fd != -1)
+    GNUNET_DISK_file_close (bf->filename, bf->fd);
+  GNUNET_free_non_null (bf->filename);
+  GNUNET_free (bf->bitArray);
+  GNUNET_free (bf);
+}
+
+/**
+ * Reset a bloom filter to empty. Clears the file on disk.
+ *
+ * @param bf the filter
+ */
+void
+GNUNET_CONTAINER_bloomfilter_clear (struct GNUNET_CONTAINER_BloomFilter *bf)
+{
+  if (NULL == bf)
+    return;
+
+  memset (bf->bitArray, 0, bf->bitArraySize);
+  if (bf->fd != -1)
+    makeEmptyFile (bf->fd, bf->bitArraySize * 4);
+}
+
+
+/**
+ * Test if an element is in the filter.
+ *
+ * @param e the element
+ * @param bf the filter
+ * @return GNUNET_YES if the element is in the filter, GNUNET_NO if not
+ */
+int
+GNUNET_CONTAINER_bloomfilter_test (struct GNUNET_CONTAINER_BloomFilter *bf,
+                                   const GNUNET_HashCode * e)
+{
+  int res;
+
+  if (NULL == bf)
+    return GNUNET_YES;
+  res = GNUNET_YES;
+  iterateBits (bf, &testBitCallback, &res, e);
+  return res;
+}
+
+/**
+ * Add an element to the filter
+ *
+ * @param bf the filter
+ * @param e the element
+ */
+void
+GNUNET_CONTAINER_bloomfilter_add (struct GNUNET_CONTAINER_BloomFilter *bf,
+                                  const GNUNET_HashCode * e)
+{
+
+  if (NULL == bf)
+    return;
+  iterateBits (bf, &incrementBitCallback, NULL, e);
+}
+
+
+/**
+ * Or the entries of the given raw data array with the
+ * data of the given bloom filter.  Assumes that
+ * the size of the data array and the current filter
+ * match.
+ * @param bf the filter
+ */
+int
+GNUNET_CONTAINER_bloomfilter_or (struct GNUNET_CONTAINER_BloomFilter *bf,
+                                 const char *data, unsigned int size)
+{
+  unsigned int i;
+
+  if (NULL == bf)
+    return GNUNET_YES;
+  if (bf->bitArraySize != size)
+    return GNUNET_SYSERR;
+  /* FIXME: we could do this 4-8x faster by
+     going over int/long arrays */
+  for (i = 0; i < size; i++)
+    bf->bitArray[i] |= data[i];
+  return GNUNET_OK;
+}
+
+/**
+ * Remove an element from the filter.
+ *
+ * @param bf the filter
+ * @param e the element to remove
+ */
+void
+GNUNET_CONTAINER_bloomfilter_remove (struct GNUNET_CONTAINER_BloomFilter *bf,
+                                     const GNUNET_HashCode * e)
+{
+  if (NULL == bf)
+    return;
+  if (bf->fd == -1)
+    return;
+  iterateBits (bf, &decrementBitCallback, NULL, e);
+}
+
+/**
+ * Resize a bloom filter.  Note that this operation
+ * is pretty costly.  Essentially, the bloom filter
+ * needs to be completely re-build.
+ *
+ * @param bf the filter
+ * @param iterator an iterator over all elements stored in the BF
+ * @param iterator_arg argument to the iterator function
+ * @param size the new size for the filter
+ * @param k the new number of GNUNET_CRYPTO_hash-function to apply per element
+ */
+void
+GNUNET_CONTAINER_bloomfilter_resize (struct GNUNET_CONTAINER_BloomFilter *bf,
+                                     GNUNET_HashCodeIterator iterator,
+                                     void *iterator_arg, unsigned int size,
+                                     unsigned int k)
+{
+  GNUNET_HashCode hc;
+  unsigned int i;
+
+  GNUNET_free (bf->bitArray);
+  i = 1;
+  while (i < size)
+    i *= 2;
+  size = i;                     /* make sure it's a power of 2 */
+
+  bf->bitArraySize = size;
+  bf->bitArray = GNUNET_malloc (size);
+  memset (bf->bitArray, 0, bf->bitArraySize);
+  if (bf->fd != -1)
+    makeEmptyFile (bf->fd, bf->bitArraySize * 4);
+  while (GNUNET_YES == iterator (&hc, iterator_arg))
+    GNUNET_CONTAINER_bloomfilter_add (bf, &hc);
+}
+
+/* end of container_bloomfilter.c */
diff --git a/src/util/container_heap.c b/src/util/container_heap.c
new file mode 100644
index 000000000..1e7077c80
--- /dev/null
+++ b/src/util/container_heap.c
@@ -0,0 +1,533 @@
+/*
+ This file is part of GNUnet.
+ (C) 2008 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.
+ */
+
+/**
+ * @author Nathan Evans
+ * @file util/container_heap.c
+ * @brief Implementation of heap operations
+ */
+
+#include "platform.h"
+#include "gnunet_protocols.h"
+#include "gnunet_util.h"
+#include "gnunet_util_containers.h"
+
+/*
+ * Struct that is stored in hashmap, pointers to
+ * locations in min_heap and max_heap.
+ */
+struct GNUNET_CONTAINER_heap_info
+{
+  struct GNUNET_CONTAINER_heap_node *min_loc;
+
+  struct GNUNET_CONTAINER_heap_node *max_loc;
+
+};
+
+/*
+ * Generic heap node structure, contains pointer to parent
+ * left child, right child, and actual neighbor.
+ */
+struct GNUNET_CONTAINER_heap_node
+{
+  struct GNUNET_CONTAINER_heap_node *parent;
+
+  struct GNUNET_CONTAINER_heap_node *left_child;
+
+  struct GNUNET_CONTAINER_heap_node *right_child;
+
+  GNUNET_CONTAINER_HeapCost cost;
+
+  void *element;
+
+};
+
+struct GNUNET_CONTAINER_Heap
+{
+  unsigned int size;
+
+  unsigned int max_size;
+
+  enum type;
+
+  struct GNUNET_CONTAINER_heap_node *root;
+
+  struct GNUNET_CONTAINER_heap_node *traversal_pos;
+
+};
+
+void
+internal_print (struct GNUNET_CONTAINER_heap_node *root)
+{
+  fprintf (stdout, "%d\n", root->cost);
+  if (root->left_child != NULL)
+    {
+      fprintf (stdout, "LEFT of %d\n", root->cost);
+      internal_print (root->left_child);
+    }
+  if (root->right_child != NULL)
+    {
+      fprintf (stdout, "RIGHT of %d\n", root->cost);
+      internal_print (root->right_child);
+    }
+}
+
+void
+printTree (struct GNUNET_CONTAINER_Heap *root)
+{
+  internal_print (root->root);
+}
+
+struct GNUNET_CONTAINER_Heap *
+GNUNET_CONTAINER_heap_create (enum type)
+{
+  struct GNUNET_CONTAINER_Heap *heap;
+  heap = malloc (sizeof (struct GNUNET_CONTAINER_Heap));
+  heap->max_size = -1;
+  heap->type = type;
+  heap->root = NULL;
+  heap->traversal_pos = NULL;
+  heap->size = 0;
+
+  return heap;
+}
+
+void
+GNUNET_CONTAINER_heap_destroy (struct GNUNET_CONTAINER_Heap *heap)
+{
+  void *unused;
+  while (heap->size > 0)
+    {
+      unused = GNUNET_CONTAINER_heap_remove_root (heap);
+    }
+
+  GNUNET_free (heap);
+  return;
+}
+
+struct GNUNET_CONTAINER_heap_node *
+find_element (struct GNUNET_CONTAINER_heap_node *node, void *element)
+{
+  struct GNUNET_CONTAINER_heap_node *ret;
+  ret = NULL;
+  if ((node != NULL) && (node->element == element))
+    {
+      ret = node;
+    }
+
+  if ((ret == NULL) && (node->left_child != NULL))
+    {
+      ret = find_element (node->left_child, element);
+    }
+
+  if ((ret == NULL) && (node->right_child != NULL))
+    {
+      ret = find_element (node->right_child, element);
+    }
+
+  return ret;
+}
+
+static struct GNUNET_CONTAINER_heap_node *
+getNextPos (struct GNUNET_CONTAINER_Heap *root)
+{
+  struct GNUNET_CONTAINER_heap_node *ret;
+  struct GNUNET_CONTAINER_heap_node *parent;
+  int pos;
+  int depth;
+  int i;
+
+  ret = GNUNET_malloc (sizeof (struct GNUNET_CONTAINER_heap_node));
+  pos = root->size + 1;
+  depth = (int) log2 (pos);
+  ret->left_child = NULL;
+  ret->right_child = NULL;
+
+  if (depth == 0)
+    {
+      ret->parent = NULL;
+      root->root = ret;
+    }
+  else
+    {
+      parent = root->root;
+      for (i = depth; i > 1; i--)
+        {
+          if (((pos / (1 << (i - 1))) % 2) == 0)
+            parent = parent->left_child;
+          else
+            parent = parent->right_child;
+        }
+
+      ret->parent = parent;
+      if ((pos % 2) == 0)
+        parent->left_child = ret;
+      else
+        parent->right_child = ret;
+
+    }
+
+  return ret;
+
+}
+
+static struct GNUNET_CONTAINER_heap_node *
+getPos (struct GNUNET_CONTAINER_Heap *root, unsigned int pos)
+{
+  struct GNUNET_CONTAINER_heap_node *ret;
+
+  int depth;
+  int i;
+
+  depth = (int) log2 (pos);
+  ret = NULL;
+  if (pos > root->size)
+    {
+      return ret;
+    }
+  else
+    {
+      ret = root->root;
+      for (i = depth; i > 0; i--)
+        {
+          if (((pos / (1 << (i - 1))) % 2) == 0)
+            ret = ret->left_child;
+          else
+            ret = ret->right_child;
+        }
+    }
+
+  return ret;
+
+}
+
+void
+swapNodes (struct GNUNET_CONTAINER_heap_node *first,
+           struct GNUNET_CONTAINER_heap_node *second,
+           struct GNUNET_CONTAINER_Heap *root)
+{
+  void *temp_element;
+  GNUNET_CONTAINER_HeapCost temp_cost;
+
+  temp_element = first->element;
+  temp_cost = first->cost;
+  first->element = second->element;
+  first->cost = second->cost;
+  second->element = temp_element;
+  second->cost = temp_cost;
+
+/*
+ * I still worry that there is some good reason for
+ * elements being location aware... but it eludes me
+ * for the moment...
+  if ((root->type == GNUNET_DV_MAX_HEAP))
+    {
+      first->neighbor->max_loc = first;
+      second->neighbor->max_loc = second;
+    }
+  else if ((root->type == GNUNET_DV_MIN_HEAP))
+    {
+      first->neighbor->min_loc = first;
+      second->neighbor->min_loc = second;
+    }
+*/
+  return;
+}
+
+void
+percolateHeap (struct GNUNET_CONTAINER_heap_node *pos,
+               struct GNUNET_CONTAINER_Heap *root)
+{
+
+  while ((pos->parent != NULL) &&
+         (((root->type == GNUNET_CONTAINER_HEAP_ORDER_MAX)
+           && (pos->parent->cost < pos->cost))
+          || ((root->type == GNUNET_CONTAINER_HEAP_ORDER_MIN)
+              && (pos->parent->cost > pos->cost))))
+    {
+      swapNodes (pos, pos->parent, root);
+      pos = pos->parent;
+    }
+
+  return;
+}
+
+
+
+void
+percolateDownHeap (struct GNUNET_CONTAINER_heap_node *pos,
+                   struct GNUNET_CONTAINER_Heap *root)
+{
+  struct GNUNET_CONTAINER_heap_node *switchNeighbor;
+
+  switchNeighbor = pos;
+
+  if ((root->type == GNUNET_CONTAINER_HEAP_ORDER_MAX))
+    {
+      if ((pos->left_child != NULL)
+          && (pos->left_child->cost > switchNeighbor->cost))
+        {
+          switchNeighbor = pos->left_child;
+        }
+
+      if ((pos->right_child != NULL)
+          && (pos->right_child->cost > switchNeighbor->cost))
+        {
+          switchNeighbor = pos->right_child;
+        }
+    }
+  else if ((root->type == GNUNET_CONTAINER_HEAP_ORDER_MIN))
+    {
+      if ((pos->left_child != NULL)
+          && (pos->left_child->cost < switchNeighbor->cost))
+        {
+          switchNeighbor = pos->left_child;
+        }
+
+      if ((pos->right_child != NULL)
+          && (pos->right_child->cost < switchNeighbor->cost))
+        {
+          switchNeighbor = pos->right_child;
+        }
+    }
+
+  if (switchNeighbor != pos)
+    {
+      swapNodes (switchNeighbor, pos, root);
+      percolateDownHeap (switchNeighbor, root);
+    }
+
+  return;
+}
+
+void *
+GNUNET_CONTAINER_heap_remove_node (struct GNUNET_CONTAINER_Heap *root,
+                                   void *element)
+{
+  void *ret;
+  struct GNUNET_CONTAINER_heap_node *del_node;
+  struct GNUNET_CONTAINER_heap_node *last;
+  GNUNET_CONTAINER_HeapCost old_cost;
+
+  del_node = NULL;
+  del_node = find_element (root->root, element);
+
+  if (del_node == NULL)
+    return NULL;
+
+  ret = del_node->element;
+  last = getPos (root, root->size);
+
+  old_cost = del_node->cost;
+  del_node->element = last->element;
+  del_node->cost = last->cost;
+
+  if (last->parent->left_child == last)
+    last->parent->left_child = NULL;
+  if (last->parent->right_child == last)
+    last->parent->right_child = NULL;
+
+  if (root->traversal_pos == last)
+    {
+      root->traversal_pos = root->root;
+    }
+  GNUNET_free (last);
+  root->size--;
+
+  if (del_node->cost > old_cost)
+    {
+      if (root->type == GNUNET_CONTAINER_HEAP_ORDER_MAX)
+        percolateHeap (del_node, root);
+      else if (root->type == GNUNET_CONTAINER_HEAP_ORDER_MIN)
+        percolateDownHeap (del_node, root);
+    }
+  else if (del_node->cost < old_cost)
+    {
+      if (root->type == GNUNET_CONTAINER_HEAP_ORDER_MAX)
+        percolateDownHeap (del_node, root);
+      else if (root->type == GNUNET_CONTAINER_HEAP_ORDER_MIN)
+        percolateHeap (del_node, root);
+    }
+
+  return ret;
+}
+
+int
+GNUNET_CONTAINER_heap_insert (struct GNUNET_CONTAINER_Heap *root,
+                              void *element, GNUNET_CONTAINER_HeapCost cost)
+{
+  struct GNUNET_CONTAINER_heap_node *new_pos;
+  int ret;
+  ret = GNUNET_YES;
+
+  if (root->max_size > root->size)
+    {
+      new_pos = getNextPos (root);
+      new_pos->element = element;
+      new_pos->cost = cost;
+      root->size++;
+      /*We no longer can tolerate pointers between heaps :( */
+      /*if (root->type == GNUNET_DV_MIN_HEAP)
+         new_pos->neighbor->min_loc = new_pos;
+         else if (root->type == GNUNET_DV_MAX_HEAP)
+         new_pos->neighbor->max_loc = new_pos; */
+
+      percolateHeap (new_pos, root);
+    }
+  else
+    {
+      ret = GNUNET_NO;
+    }
+
+  return ret;
+}
+
+void *
+GNUNET_CONTAINER_heap_remove_root (struct GNUNET_CONTAINER_Heap *root)
+{
+  void *ret;
+  struct GNUNET_CONTAINER_heap_node *root_node;
+  struct GNUNET_CONTAINER_heap_node *last;
+
+  root_node = root->root;
+  ret = root_node->element;
+  last = getPos (root, root->size);
+
+  if (last->parent->left_child == last)
+    last->parent->left_child = NULL;
+  else if (last->parent->right_child == last)
+    last->parent->right_child = NULL;
+
+  root_node->element = last->element;
+  root_node->cost = last->cost;
+
+  if (root->traversal_pos == last)
+    {
+      root->traversal_pos = root->root;
+    }
+
+  GNUNET_free (last);
+  root->size--;
+  percolateDownHeap (root->root, root);
+  return ret;
+}
+
+static int
+updatedCost (struct GNUNET_CONTAINER_Heap *root,
+             struct GNUNET_CONTAINER_heap_node *node)
+{
+  struct GNUNET_CONTAINER_heap_node *parent;
+
+  if (node == NULL)
+    return GNUNET_SYSERR;
+
+  parent = node->parent;
+
+  if ((root->type == GNUNET_CONTAINER_HEAP_ORDER_MAX) && (parent != NULL)
+      && (node->cost > parent->cost))
+    percolateHeap (node, root);
+  else if ((root->type == GNUNET_CONTAINER_HEAP_ORDER_MIN) && (parent != NULL)
+           && (node->cost < parent->cost))
+    percolateHeap (node, root);
+  else if (root->type == GNUNET_CONTAINER_HEAP_ORDER_MAX)
+    percolateDownHeap (node, root);
+  else if (root->type == GNUNET_CONTAINER_HEAP_ORDER_MIN)
+    percolateDownHeap (node, root);
+
+  return GNUNET_YES;
+}
+
+
+int
+GNUNET_CONTAINER_heap_update_cost (struct GNUNET_CONTAINER_Heap *root,
+                                   void *element,
+                                   GNUNET_CONTAINER_HeapCost new_cost)
+{
+  struct GNUNET_CONTAINER_heap_node *node;
+  int ret = GNUNET_YES;
+  node = find_element (root->root, element);
+  if (node == NULL)
+    return GNUNET_NO;
+
+  node->cost = new_cost;
+  ret = updatedCost (root, node);
+  return ret;
+}
+
+void
+internal_iterator (struct GNUNET_CONTAINER_Heap *root,
+                   struct GNUNET_CONTAINER_heap_node *node,
+                   GNUNET_CONTAINER_HeapIterator iterator, void *cls)
+{
+  if (node == NULL)
+    return;
+  internal_iterator (root, node->left_child, iterator, cls);
+  internal_iterator (root, node->right_child, iterator, cls);
+  iterator (node->element, node->cost, root, cls);
+}
+
+int
+GNUNET_CONTAINER_heap_iterate (struct GNUNET_CONTAINER_Heap *heap,
+                               GNUNET_CONTAINER_HeapIterator iterator,
+                               void *cls)
+{
+  internal_iterator (heap, heap->root, iterator, cls);
+  return GNUNET_OK;
+}
+
+void *
+GNUNET_CONTAINER_heap_walk_get_next (struct GNUNET_CONTAINER_Heap *root)
+{
+  unsigned int choice;
+  void *element;
+
+  if ((root->traversal_pos == NULL) && (root->root != NULL))
+    {
+      root->traversal_pos = root->root;
+    }
+
+  if (root->traversal_pos == NULL)
+    return NULL;
+
+  element = root->traversal_pos->element;
+
+  choice = GNUNET_random_u32 (GNUNET_RANDOM_QUALITY_WEAK, 2);
+
+  switch (choice)
+    {
+    case 1:
+      root->traversal_pos = root->traversal_pos->right_child;
+      break;
+    case 0:
+      root->traversal_pos = root->traversal_pos->left_child;
+      break;
+    }
+
+  return element;
+
+}
+
+unsigned int
+GNUNET_CONTAINER_heap_get_size (struct GNUNET_CONTAINER_Heap *heap)
+{
+  return heap->size;
+}
+
+/* end of heap.c */
diff --git a/src/util/container_meta_data.c b/src/util/container_meta_data.c
new file mode 100644
index 000000000..b79de57d2
--- /dev/null
+++ b/src/util/container_meta_data.c
@@ -0,0 +1,721 @@
+/*
+     This file is part of GNUnet.
+     (C) 2003, 2004, 2005, 2006, 2008, 2009 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 util/container_meta_data.c
+ * @brief Storing of meta data
+ * @author Christian Grothoff
+ */
+
+#include "platform.h"
+#include "gnunet_common.h"
+#include "gnunet_container_lib.h"
+#include "gnunet_strings_lib.h"
+#include "gnunet_time_lib.h"
+#include <extractor.h>
+#include <zlib.h>
+
+#define EXTRA_CHECKS ALLOW_EXTRA_CHECKS
+
+struct Item
+{
+  EXTRACTOR_KeywordType type;
+  char *data;
+};
+
+/**
+ * Meta data to associate with a file, directory or namespace.
+ */
+struct GNUNET_CONTAINER_MetaData
+{
+  uint32_t itemCount;
+  struct Item *items;
+};
+
+/**
+ * Create a fresh struct CONTAINER_MetaData token.
+ */
+struct GNUNET_CONTAINER_MetaData *
+GNUNET_CONTAINER_meta_data_create ()
+{
+  struct GNUNET_CONTAINER_MetaData *ret;
+  ret = GNUNET_malloc (sizeof (struct GNUNET_CONTAINER_MetaData));
+  ret->items = NULL;
+  ret->itemCount = 0;
+  return ret;
+}
+
+/**
+ * Free meta data.
+ */
+void
+GNUNET_CONTAINER_meta_data_destroy (struct GNUNET_CONTAINER_MetaData *md)
+{
+  int i;
+
+  if (md == NULL)
+    return;
+  for (i = 0; i < md->itemCount; i++)
+    GNUNET_free (md->items[i].data);
+  GNUNET_array_grow (md->items, md->itemCount, 0);
+  GNUNET_free (md);
+}
+
+/**
+ * Add the current time as the publication date
+ * to the meta-data.
+ */
+void
+GNUNET_CONTAINER_meta_data_add_publication_date (struct
+                                                 GNUNET_CONTAINER_MetaData
+                                                 *md)
+{
+  char *dat;
+  struct GNUNET_TIME_Absolute t;
+
+  t = GNUNET_TIME_absolute_get ();
+  GNUNET_CONTAINER_meta_data_delete (md, EXTRACTOR_PUBLICATION_DATE, NULL);
+  dat = GNUNET_STRINGS_absolute_time_to_string (t);
+  GNUNET_CONTAINER_meta_data_insert (md, EXTRACTOR_PUBLICATION_DATE, dat);
+  GNUNET_free (dat);
+}
+
+/**
+ * Extend metadata.
+ * @return GNUNET_OK on success, GNUNET_SYSERR if this entry already exists
+ */
+int
+GNUNET_CONTAINER_meta_data_insert (struct GNUNET_CONTAINER_MetaData *md,
+                                   EXTRACTOR_KeywordType type,
+                                   const char *data)
+{
+  uint32_t idx;
+  char *p;
+
+  GNUNET_assert (data != NULL);
+  for (idx = 0; idx < md->itemCount; idx++)
+    {
+      if ((md->items[idx].type == type) &&
+          (0 == strcmp (md->items[idx].data, data)))
+        return GNUNET_SYSERR;
+    }
+  idx = md->itemCount;
+  GNUNET_array_grow (md->items, md->itemCount, md->itemCount + 1);
+  md->items[idx].type = type;
+  md->items[idx].data = p = GNUNET_strdup (data);
+
+  /* change OS native dir separators to unix '/' and others to '_' */
+  if (type == EXTRACTOR_FILENAME)
+    {
+      while (*p != '\0')
+        {
+          if (*p == DIR_SEPARATOR)
+            *p = '/';
+          else if (*p == '\\')
+            *p = '_';
+          p++;
+        }
+    }
+
+  return GNUNET_OK;
+}
+
+/**
+ * Remove an item.
+ * @return GNUNET_OK on success, GNUNET_SYSERR if the item does not exist in md
+ */
+int
+GNUNET_CONTAINER_meta_data_delete (struct GNUNET_CONTAINER_MetaData *md,
+                                   EXTRACTOR_KeywordType type,
+                                   const char *data)
+{
+  uint32_t idx;
+  int ret = GNUNET_SYSERR;
+  for (idx = 0; idx < md->itemCount; idx++)
+    {
+      if ((md->items[idx].type == type) &&
+          ((data == NULL) || (0 == strcmp (md->items[idx].data, data))))
+        {
+          GNUNET_free (md->items[idx].data);
+          md->items[idx] = md->items[md->itemCount - 1];
+          GNUNET_array_grow (md->items, md->itemCount, md->itemCount - 1);
+          if (data == NULL)
+            {
+              ret = GNUNET_OK;
+              continue;
+            }
+          return GNUNET_OK;
+        }
+    }
+  return ret;
+}
+
+/**
+ * Iterate over MD entries, excluding thumbnails.
+ *
+ * @return number of entries
+ */
+int
+GNUNET_CONTAINER_meta_data_get_contents (const struct
+                                         GNUNET_CONTAINER_MetaData *md,
+                                         GNUNET_CONTAINER_MetaDataProcessor
+                                         iterator, void *closure)
+{
+  uint32_t i;
+  uint32_t sub;
+
+  sub = 0;
+  for (i = 0; i < md->itemCount; i++)
+    {
+      if (!EXTRACTOR_isBinaryType (md->items[i].type))
+        {
+          if ((iterator != NULL) &&
+              (GNUNET_OK != iterator (md->items[i].type,
+                                      md->items[i].data, closure)))
+            return GNUNET_SYSERR;
+        }
+      else
+        sub++;
+    }
+  return (int) (md->itemCount - sub);
+}
+
+/**
+ * Iterate over MD entries
+ *
+ * @return number of entries
+ */
+char *
+GNUNET_CONTAINER_meta_data_get_by_type (const struct GNUNET_CONTAINER_MetaData
+                                        *md, EXTRACTOR_KeywordType type)
+{
+  uint32_t i;
+
+  for (i = 0; i < md->itemCount; i++)
+    if (type == md->items[i].type)
+      return GNUNET_strdup (md->items[i].data);
+  return NULL;
+}
+
+/**
+ * Iterate over MD entries
+ *
+ * @return number of entries
+ */
+char *
+GNUNET_CONTAINER_meta_data_get_first_by_types (const struct
+                                               GNUNET_CONTAINER_MetaData *md,
+                                               ...)
+{
+  char *ret;
+  va_list args;
+  EXTRACTOR_KeywordType type;
+
+  ret = NULL;
+  va_start (args, md);
+  while (1)
+    {
+      type = va_arg (args, EXTRACTOR_KeywordType);
+      if (type == -1)
+        break;
+      ret = GNUNET_CONTAINER_meta_data_get_by_type (md, type);
+      if (ret != NULL)
+        break;
+    }
+  va_end (args);
+  return ret;
+}
+
+/**
+ * Get a thumbnail from the meta-data (if present).
+ *
+ * @param thumb will be set to the thumbnail data.  Must be
+ *        freed by the caller!
+ * @return number of bytes in thumbnail, 0 if not available
+ */
+size_t
+GNUNET_CONTAINER_meta_data_get_thumbnail (const struct
+                                          GNUNET_CONTAINER_MetaData * md,
+                                          unsigned char **thumb)
+{
+  char *encoded;
+  int ret;
+  size_t size;
+
+  encoded =
+    GNUNET_CONTAINER_meta_data_get_by_type (md, EXTRACTOR_THUMBNAIL_DATA);
+  if (encoded == NULL)
+    return 0;
+  if (strlen (encoded) == 0)
+    {
+      GNUNET_free (encoded);
+      return 0;                 /* invalid */
+    }
+  *thumb = NULL;
+  ret = EXTRACTOR_binaryDecode (encoded, thumb, &size);
+  GNUNET_free (encoded);
+  if (ret != 0)
+    return 0;
+  return size;
+}
+
+/**
+ * Duplicate struct GNUNET_CONTAINER_MetaData.
+ */
+struct GNUNET_CONTAINER_MetaData *
+GNUNET_CONTAINER_meta_data_duplicate (const struct GNUNET_CONTAINER_MetaData
+                                      *md)
+{
+  uint32_t i;
+  struct GNUNET_CONTAINER_MetaData *ret;
+
+  if (md == NULL)
+    return NULL;
+  ret = GNUNET_CONTAINER_meta_data_create ();
+  for (i = 0; i < md->itemCount; i++)
+    GNUNET_CONTAINER_meta_data_insert (ret, md->items[i].type,
+                                       md->items[i].data);
+  return ret;
+}
+
+/**
+ * Extract meta-data from a file.
+ *
+ * @return GNUNET_SYSERR on error, otherwise the number
+ *   of meta-data items obtained
+ */
+int
+GNUNET_CONTAINER_meta_data_extract_from_file (struct GNUNET_CONTAINER_MetaData
+                                              *md, const char *filename,
+                                              EXTRACTOR_ExtractorList *
+                                              extractors)
+{
+  EXTRACTOR_KeywordList *head;
+  EXTRACTOR_KeywordList *pos;
+  int ret;
+
+  if (filename == NULL)
+    return GNUNET_SYSERR;
+  if (extractors == NULL)
+    return 0;
+  head = EXTRACTOR_getKeywords (extractors, filename);
+  head = EXTRACTOR_removeDuplicateKeywords (head,
+                                            EXTRACTOR_DUPLICATES_REMOVE_UNKNOWN);
+  pos = head;
+  ret = 0;
+  while (pos != NULL)
+    {
+      if (GNUNET_OK ==
+          GNUNET_CONTAINER_meta_data_insert (md, pos->keywordType,
+                                             pos->keyword))
+        ret++;
+      pos = pos->next;
+    }
+  EXTRACTOR_freeKeywords (head);
+  return ret;
+}
+
+static unsigned int
+tryCompression (char *data, unsigned int oldSize)
+{
+  char *tmp;
+  uLongf dlen;
+
+#ifdef compressBound
+  dlen = compressBound (oldSize);
+#else
+  dlen = oldSize + (oldSize / 100) + 20;
+  /* documentation says 100.1% oldSize + 12 bytes, but we
+     should be able to overshoot by more to be safe */
+#endif
+  tmp = GNUNET_malloc (dlen);
+  if (Z_OK == compress2 ((Bytef *) tmp,
+                         &dlen, (const Bytef *) data, oldSize, 9))
+    {
+      if (dlen < oldSize)
+        {
+          memcpy (data, tmp, dlen);
+          GNUNET_free (tmp);
+          return dlen;
+        }
+    }
+  GNUNET_free (tmp);
+  return oldSize;
+}
+
+/**
+ * Decompress input, return the decompressed data
+ * as output, set outputSize to the number of bytes
+ * that were found.
+ *
+ * @return NULL on error
+ */
+static char *
+decompress (const char *input,
+            unsigned int inputSize, unsigned int outputSize)
+{
+  char *output;
+  uLongf olen;
+
+  olen = outputSize;
+  output = GNUNET_malloc (olen);
+  if (Z_OK == uncompress ((Bytef *) output,
+                          &olen, (const Bytef *) input, inputSize))
+    {
+      return output;
+    }
+  else
+    {
+      GNUNET_free (output);
+      return NULL;
+    }
+}
+
+/**
+ * Flag in 'version' that indicates compressed meta-data.
+ */
+#define HEADER_COMPRESSED 0x80000000
+
+/**
+ * Bits in 'version' that give the version number.
+ */
+#define HEADER_VERSION_MASK 0x7FFFFFFF
+
+struct MetaDataHeader
+{
+  /**
+   * The version of the MD serialization.
+   * The highest bit is used to indicate
+   * compression.
+   *
+   * Version 0 is the current version;
+   * Version is 1 for a NULL pointer.
+   * Other version numbers are not yet defined.
+   */
+  uint32_t version;
+
+  /**
+   * How many MD entries are there?
+   */
+  uint32_t entries;
+
+  /**
+   * Size of the MD (decompressed)
+   */
+  uint32_t size;
+
+  /**
+   * This is followed by 'entries' values of type 'unsigned int' that
+   * correspond to EXTRACTOR_KeywordTypes.  After that, the meta-data
+   * keywords follow (0-terminated).  The MD block always ends with
+   * 0-termination, padding with 0 until a multiple of 8 bytes.
+   */
+
+};
+
+/**
+ * Serialize meta-data to target.
+ *
+ * @param size maximum number of bytes available
+ * @param part is it ok to just write SOME of the
+ *        meta-data to match the size constraint,
+ *        possibly discarding some data?
+ * @return number of bytes written on success,
+ *         GNUNET_SYSERR on error (typically: not enough
+ *         space)
+ */
+int
+GNUNET_CONTAINER_meta_data_serialize (const struct GNUNET_CONTAINER_MetaData
+                                      *md, char *target, unsigned int max,
+                                      enum
+                                      GNUNET_CONTAINER_MetaDataSerializationOptions
+                                      part)
+{
+  struct MetaDataHeader *hdr;
+  size_t size;
+  size_t pos;
+  uint32_t i;
+  size_t len;
+  uint32_t ic;
+
+  if (max < sizeof (struct MetaDataHeader))
+    return GNUNET_SYSERR;       /* far too small */
+  ic = md ? md->itemCount : 0;
+  hdr = NULL;
+  while (1)
+    {
+      size = sizeof (struct MetaDataHeader);
+      size += sizeof (unsigned int) * ic;
+      for (i = 0; i < ic; i++)
+        size += 1 + strlen (md->items[i].data);
+      while (size % 8 != 0)
+        size++;
+      hdr = GNUNET_malloc (size);
+      hdr->version = htonl (md == NULL ? 1 : 0);
+      hdr->entries = htonl (ic);
+      for (i = 0; i < ic; i++)
+        ((unsigned int *) &hdr[1])[i] =
+          htonl ((unsigned int) md->items[i].type);
+      pos = sizeof (struct MetaDataHeader);
+      pos += sizeof (unsigned int) * ic;
+      for (i = 0; i < ic; i++)
+        {
+          len = strlen (md->items[i].data) + 1;
+          memcpy (&((char *) hdr)[pos], md->items[i].data, len);
+          pos += len;
+        }
+
+      hdr->size = htonl (size);
+      if ((part & GNUNET_CONTAINER_META_DATA_SERIALIZE_NO_COMPRESS) == 0)
+        {
+          pos = tryCompression ((char *) &hdr[1],
+                                size - sizeof (struct MetaDataHeader));
+        }
+      else
+        {
+          pos = size - sizeof (struct MetaDataHeader);
+        }
+      if (pos < size - sizeof (struct MetaDataHeader))
+        {
+          hdr->version = htonl (HEADER_COMPRESSED);
+          size = pos + sizeof (struct MetaDataHeader);
+        }
+      if (size <= max)
+        break;
+      GNUNET_free (hdr);
+      hdr = NULL;
+
+      if ((part & GNUNET_CONTAINER_META_DATA_SERIALIZE_PART) == 0)
+        {
+          return GNUNET_SYSERR; /* does not fit! */
+        }
+      /* partial serialization ok, try again with less meta-data */
+      if (size > 2 * max)
+        ic = ic * 2 / 3;        /* still far too big, make big reductions */
+      else
+        ic--;                   /* small steps, we're close */
+    }
+  GNUNET_assert (size <= max);
+  memcpy (target, hdr, size);
+  GNUNET_free (hdr);
+  /* extra check: deserialize! */
+#if EXTRA_CHECKS
+  {
+    struct GNUNET_CONTAINER_MetaData *mdx;
+    mdx = GNUNET_CONTAINER_meta_data_deserialize (target, size);
+    GNUNET_assert (NULL != mdx);
+    GNUNET_CONTAINER_meta_data_destroy (mdx);
+  }
+#endif
+  return size;
+}
+
+/**
+ * Estimate (!) the size of the meta-data in
+ * serialized form.  The estimate MAY be higher
+ * than what is strictly needed.
+ */
+unsigned int
+GNUNET_CONTAINER_meta_data_get_serialized_size (const struct
+                                                GNUNET_CONTAINER_MetaData *md,
+                                                enum
+                                                GNUNET_CONTAINER_MetaDataSerializationOptions
+                                                part)
+{
+  struct MetaDataHeader *hdr;
+  size_t size;
+  size_t pos;
+  uint32_t i;
+  size_t len;
+  uint32_t ic;
+
+  ic = md ? md->itemCount : 0;
+  size = sizeof (struct MetaDataHeader);
+  size += sizeof (unsigned int) * ic;
+  for (i = 0; i < ic; i++)
+    size += 1 + strlen (md->items[i].data);
+  while (size % 8 != 0)
+    size++;
+  hdr = GNUNET_malloc (size);
+  hdr->version = htonl (md == NULL ? 1 : 0);
+  hdr->entries = htonl (ic);
+  for (i = 0; i < ic; i++)
+    ((unsigned int *) &hdr[1])[i] = htonl ((unsigned int) md->items[i].type);
+  pos = sizeof (struct MetaDataHeader);
+  pos += sizeof (unsigned int) * ic;
+  for (i = 0; i < ic; i++)
+    {
+      len = strlen (md->items[i].data) + 1;
+      memcpy (&((char *) hdr)[pos], md->items[i].data, len);
+      pos += len;
+    }
+  if ((part & GNUNET_CONTAINER_META_DATA_SERIALIZE_NO_COMPRESS) == 0)
+    {
+      pos =
+        tryCompression ((char *) &hdr[1],
+                        size - sizeof (struct MetaDataHeader));
+    }
+  else
+    {
+      pos = size - sizeof (struct MetaDataHeader);
+    }
+  if (pos < size - sizeof (struct MetaDataHeader))
+    size = pos + sizeof (struct MetaDataHeader);
+  GNUNET_free (hdr);
+  return size;
+}
+
+/**
+ * Deserialize meta-data.  Initializes md.
+ * @param size number of bytes available
+ * @return MD on success, NULL on error (i.e.
+ *         bad format)
+ */
+struct GNUNET_CONTAINER_MetaData *
+GNUNET_CONTAINER_meta_data_deserialize (const char *input, unsigned int size)
+{
+  struct GNUNET_CONTAINER_MetaData *md;
+  const struct MetaDataHeader *hdr;
+  uint32_t ic;
+  char *data;
+  const char *cdata;
+  uint32_t dataSize;
+  int compressed;
+  int i;
+  unsigned int pos;
+  int len;
+  uint32_t version;
+
+  if (size < sizeof (struct MetaDataHeader))
+    return NULL;
+  hdr = (const struct MetaDataHeader *) input;
+  version = ntohl (MAKE_UNALIGNED (hdr->version)) & HEADER_VERSION_MASK;
+  if (version == 1)
+    return NULL;                /* null pointer */
+  if (version != 0)
+    {
+      GNUNET_break_op (0);      /* unsupported version */
+      return NULL;
+    }
+  ic = ntohl (MAKE_UNALIGNED (hdr->entries));
+  compressed =
+    (ntohl (MAKE_UNALIGNED (hdr->version)) & HEADER_COMPRESSED) != 0;
+  if (compressed)
+    {
+      dataSize =
+        ntohl (MAKE_UNALIGNED (hdr->size)) - sizeof (struct MetaDataHeader);
+      if (dataSize > 2 * 1042 * 1024)
+        {
+          GNUNET_break (0);
+          return NULL;          /* only 2 MB allowed [to make sure we don't blow
+                                   our memory limit because of a mal-formed
+                                   message... ] */
+        }
+      data =
+        decompress ((const char *) &input[sizeof (struct MetaDataHeader)],
+                    size - sizeof (struct MetaDataHeader), dataSize);
+      if (data == NULL)
+        {
+          GNUNET_break_op (0);
+          return NULL;
+        }
+      cdata = data;
+    }
+  else
+    {
+      data = NULL;
+      cdata = (const char *) &hdr[1];
+      dataSize = size - sizeof (struct MetaDataHeader);
+      if (size != ntohl (MAKE_UNALIGNED (hdr->size)))
+        {
+          GNUNET_break (0);
+          return NULL;
+        }
+    }
+
+  if ((sizeof (unsigned int) * ic + ic) > dataSize)
+    {
+      GNUNET_break (0);
+      goto FAILURE;
+    }
+  if ((ic > 0) && (cdata[dataSize - 1] != '\0'))
+    {
+      GNUNET_break (0);
+      goto FAILURE;
+    }
+
+  md = GNUNET_CONTAINER_meta_data_create ();
+  GNUNET_array_grow (md->items, md->itemCount, ic);
+  i = 0;
+  pos = sizeof (unsigned int) * ic;
+  while ((pos < dataSize) && (i < ic))
+    {
+      len = strlen (&cdata[pos]) + 1;
+      md->items[i].type = (EXTRACTOR_KeywordType)
+        ntohl (MAKE_UNALIGNED (((const unsigned int *) cdata)[i]));
+      md->items[i].data = GNUNET_strdup (&cdata[pos]);
+      pos += len;
+      i++;
+    }
+  if (i < ic)
+    {                           /* oops */
+      GNUNET_CONTAINER_meta_data_destroy (md);
+      goto FAILURE;
+    }
+  GNUNET_free_non_null (data);
+  return md;
+FAILURE:
+  GNUNET_free_non_null (data);
+  return NULL;                  /* size too small */
+}
+
+/**
+ * Test if two MDs are equal.
+ */
+int
+GNUNET_CONTAINER_meta_data_test_equal (const struct GNUNET_CONTAINER_MetaData
+                                       *md1,
+                                       const struct GNUNET_CONTAINER_MetaData
+                                       *md2)
+{
+  uint32_t i;
+  uint32_t j;
+  int found;
+
+  if (md1->itemCount != md2->itemCount)
+    return GNUNET_NO;
+  for (i = 0; i < md1->itemCount; i++)
+    {
+      found = GNUNET_NO;
+      for (j = 0; j < md2->itemCount; j++)
+        if ((md1->items[i].type == md2->items[j].type) &&
+            (0 == strcmp (md1->items[i].data, md2->items[j].data)))
+          {
+            found = GNUNET_YES;
+            break;
+          }
+      if (found == GNUNET_NO)
+        return GNUNET_NO;
+    }
+  return GNUNET_YES;
+}
+
+
+/* end of container_meta_data.c */
diff --git a/src/util/container_multihashmap.c b/src/util/container_multihashmap.c
new file mode 100644
index 000000000..a84955eb3
--- /dev/null
+++ b/src/util/container_multihashmap.c
@@ -0,0 +1,334 @@
+/*
+     This file is part of GNUnet.
+     (C) 2008 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 util/container_multihashmap.c
+ * @brief hash map where the same key maybe present multiple times
+ * @author Christian Grothoff
+ */
+
+#include "platform.h"
+#include "gnunet_common.h"
+#include "gnunet_container_lib.h"
+#include "gnunet_crypto_lib.h"
+
+struct MapEntry
+{
+  GNUNET_HashCode key;
+  void *value;
+  struct MapEntry *next;
+};
+
+struct GNUNET_CONTAINER_MultiHashMap
+{
+
+  struct MapEntry **map;
+
+  unsigned int size;
+
+  unsigned int map_length;
+};
+
+struct GNUNET_CONTAINER_MultiHashMap *
+GNUNET_CONTAINER_multihashmap_create (unsigned int len)
+{
+  struct GNUNET_CONTAINER_MultiHashMap *ret;
+
+  ret = GNUNET_malloc (sizeof (struct GNUNET_CONTAINER_MultiHashMap));
+  ret->size = 0;
+  ret->map = GNUNET_malloc (len * sizeof (struct MapEntry *));
+  memset (ret->map, 0, len * sizeof (struct MapEntry *));
+  ret->map_length = len;
+  return ret;
+}
+
+void
+GNUNET_CONTAINER_multihashmap_destroy (struct GNUNET_CONTAINER_MultiHashMap
+                                       *map)
+{
+  unsigned int i;
+  struct MapEntry *e;
+
+  for (i = 0; i < map->map_length; i++)
+    {
+      while (NULL != (e = map->map[i]))
+        {
+          map->map[i] = e->next;
+          GNUNET_free (e);
+        }
+    }
+  GNUNET_free (map->map);
+  GNUNET_free (map);
+}
+
+static unsigned int
+idx_of (const struct GNUNET_CONTAINER_MultiHashMap *m,
+        const GNUNET_HashCode * key)
+{
+  return (*(unsigned int *) key) % m->map_length;
+}
+
+unsigned int
+GNUNET_CONTAINER_multihashmap_size (const struct GNUNET_CONTAINER_MultiHashMap
+                                    *map)
+{
+  return map->size;
+}
+
+void *
+GNUNET_CONTAINER_multihashmap_get (const struct GNUNET_CONTAINER_MultiHashMap
+                                   *map, const GNUNET_HashCode * key)
+{
+  struct MapEntry *e;
+
+  e = map->map[idx_of (map, key)];
+  while (e != NULL)
+    {
+      if (0 == memcmp (key, &e->key, sizeof (GNUNET_HashCode)))
+        return e->value;
+      e = e->next;
+    }
+  return NULL;
+}
+
+int
+GNUNET_CONTAINER_multihashmap_iterate (const struct
+                                       GNUNET_CONTAINER_MultiHashMap *map,
+                                       GNUNET_CONTAINER_HashMapIterator it,
+                                       void *cls)
+{
+  int count;
+  unsigned int i;
+  struct MapEntry *e;
+
+  count = 0;
+  for (i = 0; i < map->map_length; i++)
+    {
+      e = map->map[i];
+      while (e != NULL)
+        {
+          if ((NULL != it) && (GNUNET_OK != it (&e->key, e->value, cls)))
+            return GNUNET_SYSERR;
+          count++;
+          e = e->next;
+        }
+    }
+  return count;
+}
+
+int
+GNUNET_CONTAINER_multihashmap_remove (struct GNUNET_CONTAINER_MultiHashMap
+                                      *map, const GNUNET_HashCode * key,
+                                      void *value)
+{
+  struct MapEntry *e;
+  struct MapEntry *p;
+  unsigned int i;
+
+  i = idx_of (map, key);
+  p = NULL;
+  e = map->map[i];
+  while (e != NULL)
+    {
+      if ((0 == memcmp (key, &e->key, sizeof (GNUNET_HashCode))) &&
+          (value == e->value))
+        {
+          if (p == NULL)
+            map->map[i] = e->next;
+          else
+            p->next = e->next;
+          GNUNET_free (e);
+          map->size--;
+          return GNUNET_YES;
+        }
+      p = e;
+      e = e->next;
+    }
+  return GNUNET_NO;
+}
+
+int
+GNUNET_CONTAINER_multihashmap_remove_all (struct GNUNET_CONTAINER_MultiHashMap
+                                          *map, const GNUNET_HashCode * key)
+{
+  struct MapEntry *e;
+  struct MapEntry *p;
+  unsigned int i;
+  int ret;
+
+  ret = 0;
+  i = idx_of (map, key);
+  p = NULL;
+  e = map->map[i];
+  while (e != NULL)
+    {
+      if (0 == memcmp (key, &e->key, sizeof (GNUNET_HashCode)))
+        {
+          if (p == NULL)
+            map->map[i] = e->next;
+          else
+            p->next = e->next;
+          GNUNET_free (e);
+          map->size--;
+          if (p == NULL)
+            e = map->map[i];
+          else
+            e = p->next;
+          ret++;
+        }
+      else
+        {
+          p = e;
+          e = e->next;
+        }
+    }
+  return ret;
+}
+
+int
+GNUNET_CONTAINER_multihashmap_contains (const struct
+                                        GNUNET_CONTAINER_MultiHashMap *map,
+                                        const GNUNET_HashCode * key)
+{
+  struct MapEntry *e;
+  unsigned int i;
+
+  i = idx_of (map, key);
+  e = map->map[i];
+  while (e != NULL)
+    {
+      if (0 == memcmp (key, &e->key, sizeof (GNUNET_HashCode)))
+        return GNUNET_YES;
+      e = e->next;
+    }
+  return GNUNET_NO;
+}
+
+static void
+grow (struct GNUNET_CONTAINER_MultiHashMap *map)
+{
+  struct MapEntry **old;
+  struct MapEntry *e;
+  unsigned int i;
+  unsigned int l;
+
+  old = map->map;
+  l = map->map_length;
+  map->map_length *= 2;
+  map->map = GNUNET_malloc (sizeof (struct MapEntry *) * map->map_length);
+  memset (map->map, 0, sizeof (struct MapEntry *) * map->map_length);
+  for (i = 0; i < l; i++)
+    {
+      while (NULL != (e = old[i]))
+        {
+          old[i] = e->next;
+          e->next = map->map[idx_of (map, &e->key)];
+          map->map[idx_of (map, &e->key)] = e;
+        }
+    }
+  GNUNET_free (old);
+}
+
+int
+GNUNET_CONTAINER_multihashmap_put (struct GNUNET_CONTAINER_MultiHashMap *map,
+                                   const GNUNET_HashCode * key,
+                                   void *value,
+                                   enum GNUNET_CONTAINER_MultiHashMapOption
+                                   opt)
+{
+  struct MapEntry *e;
+  unsigned int i;
+
+  i = idx_of (map, key);
+  if ((opt != GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE) &&
+      (opt != GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST))
+    {
+      e = map->map[i];
+      while (e != NULL)
+        {
+          if ((0 == memcmp (key, &e->key, sizeof (GNUNET_HashCode))) &&
+              (value == e->value))
+            {
+              if (opt == GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY)
+                return GNUNET_SYSERR;
+              e->value = value;
+              return GNUNET_NO;
+            }
+          e = e->next;
+        }
+    }
+  if (map->size / 3 > map->map_length / 4)
+    grow (map);
+  e = GNUNET_malloc (sizeof (struct MapEntry));
+  e->key = *key;
+  e->value = value;
+  e->next = map->map[i];
+  map->map[i] = e;
+  map->size++;
+  return GNUNET_OK;
+}
+
+int
+GNUNET_CONTAINER_multihashmap_get_multiple (const struct
+                                            GNUNET_CONTAINER_MultiHashMap
+                                            *map, const GNUNET_HashCode * key,
+                                            GNUNET_CONTAINER_HashMapIterator
+                                            it, void *cls)
+{
+  int count;
+  struct MapEntry *e;
+
+  count = 0;
+  e = map->map[idx_of (map, key)];
+  while (e != NULL)
+    {
+      if (0 == memcmp (key, &e->key, sizeof (GNUNET_HashCode)))
+        {
+          if ((it != NULL) && (GNUNET_OK != it (&e->key, e->value, cls)))
+            return GNUNET_SYSERR;
+          count++;
+        }
+      e = e->next;
+    }
+  return count;
+}
+
+void *
+GNUNET_CONTAINER_multihashmap_get_random (const struct
+                                          GNUNET_CONTAINER_MultiHashMap *map)
+{
+  unsigned int rand;
+  struct MapEntry *e;
+  e = NULL;
+
+  if (map->size == 0)
+    return NULL;
+
+  while (e == NULL)
+    {
+      rand =
+        GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK,
+                                  map->map_length);
+      e = map->map[rand];
+    }
+
+  return e->value;
+}
+
+/* end of multihashmap.c */
diff --git a/src/util/crypto_aes.c b/src/util/crypto_aes.c
new file mode 100644
index 000000000..28a65dfca
--- /dev/null
+++ b/src/util/crypto_aes.c
@@ -0,0 +1,148 @@
+/*
+     This file is part of GNUnet.
+     (C) 2001, 2002, 2003, 2004, 2005, 2006 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 util/crypto_aes.c
+ * @brief Symmetric encryption services.
+ * @author Christian Grothoff
+ * @author Ioana Patrascu
+ */
+
+#include "platform.h"
+#include "gnunet_common.h"
+#include "gnunet_crypto_lib.h"
+#include <gcrypt.h>
+
+/**
+ * Create a new SessionKey (for AES-256).
+ */
+void
+GNUNET_CRYPTO_aes_create_session_key (struct GNUNET_CRYPTO_AesSessionKey *key)
+{
+  gcry_randomize (&key->key[0], GNUNET_CRYPTO_AES_KEY_LENGTH,
+                  GCRY_STRONG_RANDOM);
+  key->crc32 =
+    htonl (GNUNET_CRYPTO_crc32_n (key, GNUNET_CRYPTO_AES_KEY_LENGTH));
+}
+
+/**
+ * Check that a new session key is well-formed.
+ *
+ * @return GNUNET_OK if the key is valid
+ */
+int
+GNUNET_CRYPTO_aes_check_session_key (const struct GNUNET_CRYPTO_AesSessionKey
+                                     *key)
+{
+  uint32_t crc;
+
+  crc = GNUNET_CRYPTO_crc32_n (key, GNUNET_CRYPTO_AES_KEY_LENGTH);
+  if (ntohl (key->crc32) == crc)
+    return GNUNET_OK;
+  GNUNET_break (0);
+  return GNUNET_SYSERR;
+}
+
+
+/**
+ * Encrypt a block with the public key of another
+ * host that uses the same cyper.
+ * @param block the block to encrypt
+ * @param len the size of the block
+ * @param sessionkey the key used to encrypt
+ * @param iv the initialization vector to use, use INITVALUE
+ *        for streams.
+ * @param result the output parameter in which to store the encrypted result
+ * @returns the size of the encrypted block, -1 for errors
+ */
+int
+GNUNET_CRYPTO_aes_encrypt (const void *block,
+                           uint16_t len,
+                           const struct GNUNET_CRYPTO_AesSessionKey
+                           *sessionkey,
+                           const struct GNUNET_CRYPTO_AesInitializationVector
+                           *iv, void *result)
+{
+  gcry_cipher_hd_t handle;
+  int rc;
+
+  if (sessionkey->crc32 !=
+      htonl (GNUNET_CRYPTO_crc32_n
+             (sessionkey, GNUNET_CRYPTO_AES_KEY_LENGTH)))
+    {
+      GNUNET_break (0);
+      return GNUNET_SYSERR;
+    }
+  GNUNET_assert (0 == gcry_cipher_open (&handle,
+                                        GCRY_CIPHER_AES256,
+                                        GCRY_CIPHER_MODE_CFB, 0));
+  rc = gcry_cipher_setkey (handle, sessionkey, GNUNET_CRYPTO_AES_KEY_LENGTH);
+  GNUNET_assert ((0 == rc) || ((char) rc == GPG_ERR_WEAK_KEY));
+  rc =
+    gcry_cipher_setiv (handle, iv,
+                       sizeof (struct GNUNET_CRYPTO_AesInitializationVector));
+  GNUNET_assert ((0 == rc) || ((char) rc == GPG_ERR_WEAK_KEY));
+  GNUNET_assert (0 == gcry_cipher_encrypt (handle, result, len, block, len));
+  gcry_cipher_close (handle);
+  return len;
+}
+
+/**
+ * Decrypt a given block with the sessionkey.
+ * @param sessionkey the key used to decrypt
+ * @param block the data to decrypt, encoded as returned by encrypt
+ * @param size the size of the block to decrypt
+ * @param iv the initialization vector to use, use INITVALUE
+ *        for streams.
+ * @param result address to store the result at
+ * @return -1 on failure, size of decrypted block on success
+ */
+int
+GNUNET_CRYPTO_aes_decrypt (const struct GNUNET_CRYPTO_AesSessionKey
+                           *sessionkey, const void *block, uint16_t size,
+                           const struct GNUNET_CRYPTO_AesInitializationVector
+                           *iv, void *result)
+{
+  gcry_cipher_hd_t handle;
+  int rc;
+
+  if (sessionkey->crc32 !=
+      htonl (GNUNET_CRYPTO_crc32_n
+             (sessionkey, GNUNET_CRYPTO_AES_KEY_LENGTH)))
+    {
+      GNUNET_break (0);
+      return GNUNET_SYSERR;
+    }
+  GNUNET_assert (0 == gcry_cipher_open (&handle,
+                                        GCRY_CIPHER_AES256,
+                                        GCRY_CIPHER_MODE_CFB, 0));
+  rc = gcry_cipher_setkey (handle, sessionkey, GNUNET_CRYPTO_AES_KEY_LENGTH);
+  GNUNET_assert ((0 == rc) || ((char) rc == GPG_ERR_WEAK_KEY));
+  rc =
+    gcry_cipher_setiv (handle, iv,
+                       sizeof (struct GNUNET_CRYPTO_AesInitializationVector));
+  GNUNET_assert ((0 == rc) || ((char) rc == GPG_ERR_WEAK_KEY));
+  GNUNET_assert (0 ==
+                 gcry_cipher_decrypt (handle, result, size, block, size));
+  gcry_cipher_close (handle);
+  return size;
+}
+
+/* end of crypto_aes.c */
diff --git a/src/util/crypto_crc.c b/src/util/crypto_crc.c
new file mode 100644
index 000000000..35d1e2576
--- /dev/null
+++ b/src/util/crypto_crc.c
@@ -0,0 +1,106 @@
+/*
+     This file is part of GNUnet.
+     (C) 2001, 2002, 2003, 2004, 2006 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.
+
+     For the actual CRC code:
+     Copyright abandoned; this code is in the public domain.
+     Provided to GNUnet by peter@horizon.com
+*/
+
+/**
+ * @file util/crypto_crc.c
+ * @brief implementation of CRC32
+ * @author Christian Grothoff
+ */
+
+#include "platform.h"
+#include "gnunet_common.h"
+#include "gnunet_crypto_lib.h"
+
+/* Avoid wasting space on 8-byte longs. */
+#if UINT_MAX >= 0xffffffff
+typedef unsigned int uLong;
+#elif ULONG_MAX >= 0xffffffff
+typedef unsigned long uLong;
+#else
+#error This compiler is not ANSI-compliant!
+#endif
+
+#define Z_NULL  0
+
+
+#define POLYNOMIAL (uLong)0xedb88320
+static uLong crc_table[256];
+
+/*
+ * This routine writes each crc_table entry exactly once,
+ * with the ccorrect final value.  Thus, it is safe to call
+ * even on a table that someone else is using concurrently.
+ */
+void __attribute__ ((constructor)) GNUNET_CRYPTO_crc_init ()
+{
+  unsigned int i, j;
+  uLong h = 1;
+  crc_table[0] = 0;
+  for (i = 128; i; i >>= 1)
+    {
+      h = (h >> 1) ^ ((h & 1) ? POLYNOMIAL : 0);
+      /* h is now crc_table[i] */
+      for (j = 0; j < 256; j += 2 * i)
+        crc_table[i + j] = crc_table[j] ^ h;
+    }
+}
+
+/*
+ * This computes the standard preset and inverted CRC, as used
+ * by most networking standards.  Start by passing in an initial
+ * chaining value of 0, and then pass in the return value from the
+ * previous crc32() call.  The final return value is the CRC.
+ * Note that this is a little-endian CRC, which is best used with
+ * data transmitted lsbit-first, and it should, itself, be appended
+ * to data in little-endian byte and bit order to preserve the
+ * property of detecting all burst errors of length 32 bits or less.
+ */
+static uLong
+crc32 (uLong crc, const char *buf, size_t len)
+{
+  GNUNET_assert (crc_table[255] != 0);
+  crc ^= 0xffffffff;
+  while (len--)
+    crc = (crc >> 8) ^ crc_table[(crc ^ *buf++) & 0xff];
+  return crc ^ 0xffffffff;
+}
+
+
+/**
+ * Compute the CRC32 checksum for the first len bytes of the buffer.
+ *
+ * @param buf the data over which we're taking the CRC
+ * @param len the length of the buffer
+ * @return the resulting CRC32 checksum
+ */
+int
+GNUNET_CRYPTO_crc32_n (const void *buf, unsigned int len)
+{
+  uLong crc;
+  crc = crc32 (0L, Z_NULL, 0);
+  crc = crc32 (crc, (char *) buf, len);
+  return crc;
+}
+
+/* end of crc32.c */
diff --git a/src/util/crypto_hash.c b/src/util/crypto_hash.c
new file mode 100644
index 000000000..139496eac
--- /dev/null
+++ b/src/util/crypto_hash.c
@@ -0,0 +1,791 @@
+/*
+     This file is part of GNUnet.
+     (C) 2001, 2002, 2003, 2004, 2005, 2006, 2009 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.
+
+     SHA-512 code by Jean-Luc Cooke <jlcooke@certainkey.com>
+
+     Copyright (c) Jean-Luc Cooke <jlcooke@certainkey.com>
+     Copyright (c) Andrew McDonald <andrew@mcdonald.org.uk>
+     Copyright (c) 2003 Kyle McMartin <kyle@debian.org>
+*/
+
+/**
+ * @file util/crypto_hash.c
+ * @brief SHA-512 GNUNET_CRYPTO_hash related functions
+ * @author Christian Grothoff
+ */
+
+#include "platform.h"
+#include "gnunet_common.h"
+#include "gnunet_crypto_lib.h"
+#include "gnunet_disk_lib.h"
+
+#define SHA512_DIGEST_SIZE 64
+#define SHA512_HMAC_BLOCK_SIZE 128
+
+struct sha512_ctx
+{
+  unsigned long long state[8];
+  unsigned int count[4];
+  unsigned char buf[128];
+};
+
+static unsigned long long
+Ch (unsigned long long x, unsigned long long y, unsigned long long z)
+{
+  return z ^ (x & (y ^ z));
+}
+
+static unsigned long long
+Maj (unsigned long long x, unsigned long long y, unsigned long long z)
+{
+  return (x & y) | (z & (x | y));
+}
+
+static unsigned long long
+RORu64 (unsigned long long x, unsigned long long y)
+{
+  return (x >> y) | (x << (64 - y));
+}
+
+const unsigned long long sha512_K[80] = {
+  0x428a2f98d728ae22ULL, 0x7137449123ef65cdULL, 0xb5c0fbcfec4d3b2fULL,
+  0xe9b5dba58189dbbcULL, 0x3956c25bf348b538ULL, 0x59f111f1b605d019ULL,
+  0x923f82a4af194f9bULL, 0xab1c5ed5da6d8118ULL, 0xd807aa98a3030242ULL,
+  0x12835b0145706fbeULL, 0x243185be4ee4b28cULL, 0x550c7dc3d5ffb4e2ULL,
+  0x72be5d74f27b896fULL, 0x80deb1fe3b1696b1ULL, 0x9bdc06a725c71235ULL,
+  0xc19bf174cf692694ULL, 0xe49b69c19ef14ad2ULL, 0xefbe4786384f25e3ULL,
+  0x0fc19dc68b8cd5b5ULL, 0x240ca1cc77ac9c65ULL, 0x2de92c6f592b0275ULL,
+  0x4a7484aa6ea6e483ULL, 0x5cb0a9dcbd41fbd4ULL, 0x76f988da831153b5ULL,
+  0x983e5152ee66dfabULL, 0xa831c66d2db43210ULL, 0xb00327c898fb213fULL,
+  0xbf597fc7beef0ee4ULL, 0xc6e00bf33da88fc2ULL, 0xd5a79147930aa725ULL,
+  0x06ca6351e003826fULL, 0x142929670a0e6e70ULL, 0x27b70a8546d22ffcULL,
+  0x2e1b21385c26c926ULL, 0x4d2c6dfc5ac42aedULL, 0x53380d139d95b3dfULL,
+  0x650a73548baf63deULL, 0x766a0abb3c77b2a8ULL, 0x81c2c92e47edaee6ULL,
+  0x92722c851482353bULL, 0xa2bfe8a14cf10364ULL, 0xa81a664bbc423001ULL,
+  0xc24b8b70d0f89791ULL, 0xc76c51a30654be30ULL, 0xd192e819d6ef5218ULL,
+  0xd69906245565a910ULL, 0xf40e35855771202aULL, 0x106aa07032bbd1b8ULL,
+  0x19a4c116b8d2d0c8ULL, 0x1e376c085141ab53ULL, 0x2748774cdf8eeb99ULL,
+  0x34b0bcb5e19b48a8ULL, 0x391c0cb3c5c95a63ULL, 0x4ed8aa4ae3418acbULL,
+  0x5b9cca4f7763e373ULL, 0x682e6ff3d6b2b8a3ULL, 0x748f82ee5defb2fcULL,
+  0x78a5636f43172f60ULL, 0x84c87814a1f0ab72ULL, 0x8cc702081a6439ecULL,
+  0x90befffa23631e28ULL, 0xa4506cebde82bde9ULL, 0xbef9a3f7b2c67915ULL,
+  0xc67178f2e372532bULL, 0xca273eceea26619cULL, 0xd186b8c721c0c207ULL,
+  0xeada7dd6cde0eb1eULL, 0xf57d4f7fee6ed178ULL, 0x06f067aa72176fbaULL,
+  0x0a637dc5a2c898a6ULL, 0x113f9804bef90daeULL, 0x1b710b35131c471bULL,
+  0x28db77f523047d84ULL, 0x32caab7b40c72493ULL, 0x3c9ebe0a15c9bebcULL,
+  0x431d67c49c100d4cULL, 0x4cc5d4becb3e42b6ULL, 0x597f299cfc657e2aULL,
+  0x5fcb6fab3ad6faecULL, 0x6c44198c4a475817ULL,
+};
+
+#define e0(x)       (RORu64(x,28) ^ RORu64(x,34) ^ RORu64(x,39))
+#define e1(x)       (RORu64(x,14) ^ RORu64(x,18) ^ RORu64(x,41))
+#define s0(x)       (RORu64(x, 1) ^ RORu64(x, 8) ^ (x >> 7))
+#define s1(x)       (RORu64(x,19) ^ RORu64(x,61) ^ (x >> 6))
+
+/* H* initial state for SHA-512 */
+#define H0         0x6a09e667f3bcc908ULL
+#define H1         0xbb67ae8584caa73bULL
+#define H2         0x3c6ef372fe94f82bULL
+#define H3         0xa54ff53a5f1d36f1ULL
+#define H4         0x510e527fade682d1ULL
+#define H5         0x9b05688c2b3e6c1fULL
+#define H6         0x1f83d9abfb41bd6bULL
+#define H7         0x5be0cd19137e2179ULL
+
+/* H'* initial state for SHA-384 */
+#define HP0 0xcbbb9d5dc1059ed8ULL
+#define HP1 0x629a292a367cd507ULL
+#define HP2 0x9159015a3070dd17ULL
+#define HP3 0x152fecd8f70e5939ULL
+#define HP4 0x67332667ffc00b31ULL
+#define HP5 0x8eb44a8768581511ULL
+#define HP6 0xdb0c2e0d64f98fa7ULL
+#define HP7 0x47b5481dbefa4fa4ULL
+
+#define LOAD_OP(t1, I, W, input) \
+  t1  = input[(8*I)  ] & 0xff;\
+  t1 <<= 8;\
+  t1 |= input[(8*I)+1] & 0xff;\
+  t1 <<= 8;\
+  t1 |= input[(8*I)+2] & 0xff;\
+  t1 <<= 8;\
+  t1 |= input[(8*I)+3] & 0xff;\
+  t1 <<= 8;\
+  t1 |= input[(8*I)+4] & 0xff;\
+  t1 <<= 8;\
+  t1 |= input[(8*I)+5] & 0xff;\
+  t1 <<= 8;\
+  t1 |= input[(8*I)+6] & 0xff;\
+  t1 <<= 8;\
+  t1 |= input[(8*I)+7] & 0xff;\
+  W[I] = t1;
+
+
+#define BLEND_OP(I, W) \
+  W[I] = s1(W[I-2]) + W[I-7] + s0(W[I-15]) + W[I-16];
+
+static void
+sha512_transform (unsigned long long *state, const unsigned char *input)
+{
+  unsigned long long a, b, c, d, e, f, g, h, t1, t2;
+  unsigned long long W[80];
+  unsigned long long t0;
+  int i;
+
+  /* load the input */
+  for (i = 0; i < 16; i++)
+    {
+      LOAD_OP (t0, i, W, input);
+    }
+
+  for (i = 16; i < 80; i++)
+    {
+      BLEND_OP (i, W);
+    }
+
+  /* load the state into our registers */
+  a = state[0];
+  b = state[1];
+  c = state[2];
+  d = state[3];
+  e = state[4];
+  f = state[5];
+  g = state[6];
+  h = state[7];
+
+  /* now iterate */
+  for (i = 0; i < 80; i += 8)
+    {
+      t1 = h + e1 (e) + Ch (e, f, g) + sha512_K[i] + W[i];
+      t2 = e0 (a) + Maj (a, b, c);
+      d += t1;
+      h = t1 + t2;
+      t1 = g + e1 (d) + Ch (d, e, f) + sha512_K[i + 1] + W[i + 1];
+      t2 = e0 (h) + Maj (h, a, b);
+      c += t1;
+      g = t1 + t2;
+      t1 = f + e1 (c) + Ch (c, d, e) + sha512_K[i + 2] + W[i + 2];
+      t2 = e0 (g) + Maj (g, h, a);
+      b += t1;
+      f = t1 + t2;
+      t1 = e + e1 (b) + Ch (b, c, d) + sha512_K[i + 3] + W[i + 3];
+      t2 = e0 (f) + Maj (f, g, h);
+      a += t1;
+      e = t1 + t2;
+      t1 = d + e1 (a) + Ch (a, b, c) + sha512_K[i + 4] + W[i + 4];
+      t2 = e0 (e) + Maj (e, f, g);
+      h += t1;
+      d = t1 + t2;
+      t1 = c + e1 (h) + Ch (h, a, b) + sha512_K[i + 5] + W[i + 5];
+      t2 = e0 (d) + Maj (d, e, f);
+      g += t1;
+      c = t1 + t2;
+      t1 = b + e1 (g) + Ch (g, h, a) + sha512_K[i + 6] + W[i + 6];
+      t2 = e0 (c) + Maj (c, d, e);
+      f += t1;
+      b = t1 + t2;
+      t1 = a + e1 (f) + Ch (f, g, h) + sha512_K[i + 7] + W[i + 7];
+      t2 = e0 (b) + Maj (b, c, d);
+      e += t1;
+      a = t1 + t2;
+    }
+
+  state[0] += a;
+  state[1] += b;
+  state[2] += c;
+  state[3] += d;
+  state[4] += e;
+  state[5] += f;
+  state[6] += g;
+  state[7] += h;
+
+  /* erase our data */
+  a = b = c = d = e = f = g = h = t1 = t2 = 0;
+  memset (W, 0, 80 * sizeof (unsigned long long));
+}
+
+static void
+sha512_init (struct sha512_ctx *sctx)
+{
+  sctx->state[0] = H0;
+  sctx->state[1] = H1;
+  sctx->state[2] = H2;
+  sctx->state[3] = H3;
+  sctx->state[4] = H4;
+  sctx->state[5] = H5;
+  sctx->state[6] = H6;
+  sctx->state[7] = H7;
+  sctx->count[0] = sctx->count[1] = sctx->count[2] = sctx->count[3] = 0;
+  memset (sctx->buf, 0, sizeof (sctx->buf));
+}
+
+static void
+sha512_update (struct sha512_ctx *sctx,
+               const unsigned char *data, unsigned int len)
+{
+  unsigned int i, index, part_len;
+
+  /* Compute number of bytes mod 128 */
+  index = (unsigned int) ((sctx->count[0] >> 3) & 0x7F);
+
+  /* Update number of bits */
+  if ((sctx->count[0] += (len << 3)) < (len << 3))
+    {
+      if ((sctx->count[1] += 1) < 1)
+        if ((sctx->count[2] += 1) < 1)
+          sctx->count[3]++;
+      sctx->count[1] += (len >> 29);
+    }
+
+  part_len = 128 - index;
+
+  /* Transform as many times as possible. */
+  if (len >= part_len)
+    {
+      memcpy (&sctx->buf[index], data, part_len);
+      sha512_transform (sctx->state, sctx->buf);
+
+      for (i = part_len; i + 127 < len; i += 128)
+        sha512_transform (sctx->state, &data[i]);
+
+      index = 0;
+    }
+  else
+    {
+      i = 0;
+    }
+
+  /* Buffer remaining input */
+  memcpy (&sctx->buf[index], &data[i], len - i);
+}
+
+static void
+sha512_final (struct sha512_ctx *sctx, unsigned char *hash)
+{
+  static unsigned char padding[128] = { 0x80, };
+
+  unsigned int t;
+  unsigned long long t2;
+  unsigned char bits[128];
+  unsigned int index, pad_len;
+  int i, j;
+
+  index = pad_len = t = i = j = 0;
+  t2 = 0;
+
+  /* Save number of bits */
+  t = sctx->count[0];
+  bits[15] = t;
+  t >>= 8;
+  bits[14] = t;
+  t >>= 8;
+  bits[13] = t;
+  t >>= 8;
+  bits[12] = t;
+  t = sctx->count[1];
+  bits[11] = t;
+  t >>= 8;
+  bits[10] = t;
+  t >>= 8;
+  bits[9] = t;
+  t >>= 8;
+  bits[8] = t;
+  t = sctx->count[2];
+  bits[7] = t;
+  t >>= 8;
+  bits[6] = t;
+  t >>= 8;
+  bits[5] = t;
+  t >>= 8;
+  bits[4] = t;
+  t = sctx->count[3];
+  bits[3] = t;
+  t >>= 8;
+  bits[2] = t;
+  t >>= 8;
+  bits[1] = t;
+  t >>= 8;
+  bits[0] = t;
+
+  /* Pad out to 112 mod 128. */
+  index = (sctx->count[0] >> 3) & 0x7f;
+  pad_len = (index < 112) ? (112 - index) : ((128 + 112) - index);
+  sha512_update (sctx, padding, pad_len);
+
+  /* Append length (before padding) */
+  sha512_update (sctx, bits, 16);
+
+  /* Store state in digest */
+  for (i = j = 0; i < 8; i++, j += 8)
+    {
+      t2 = sctx->state[i];
+      hash[j + 7] = (char) t2 & 0xff;
+      t2 >>= 8;
+      hash[j + 6] = (char) t2 & 0xff;
+      t2 >>= 8;
+      hash[j + 5] = (char) t2 & 0xff;
+      t2 >>= 8;
+      hash[j + 4] = (char) t2 & 0xff;
+      t2 >>= 8;
+      hash[j + 3] = (char) t2 & 0xff;
+      t2 >>= 8;
+      hash[j + 2] = (char) t2 & 0xff;
+      t2 >>= 8;
+      hash[j + 1] = (char) t2 & 0xff;
+      t2 >>= 8;
+      hash[j] = (char) t2 & 0xff;
+    }
+
+  /* Zeroize sensitive information. */
+  memset (sctx, 0, sizeof (struct sha512_ctx));
+}
+
+/**
+ * Hash block of given size.
+ *
+ * @param block the data to GNUNET_CRYPTO_hash, length is given as a second argument
+ * @param size the length of the data to GNUNET_CRYPTO_hash
+ * @param ret pointer to where to write the hashcode
+ */
+void
+GNUNET_CRYPTO_hash (const void *block, unsigned int size,
+                    GNUNET_HashCode * ret)
+{
+  struct sha512_ctx ctx;
+
+  sha512_init (&ctx);
+  sha512_update (&ctx, block, size);
+  sha512_final (&ctx, (unsigned char *) ret);
+}
+
+
+/**
+ * Context used when hashing a file.
+ */
+struct FileHashContext
+{
+
+  /**
+   * Function to call upon completion.
+   */
+  GNUNET_CRYPTO_HashCompletedCallback callback;
+
+  /**
+   * Closure for callback.
+   */
+  void *callback_cls;
+
+  /**
+   * IO buffer.
+   */
+  unsigned char *buffer;
+
+  /**
+   * Name of the file we are hashing.
+   */
+  char *filename;
+
+  /**
+   * Cummulated hash.
+   */
+  struct sha512_ctx hctx;
+
+  /**
+   * Blocksize.
+   */
+  size_t bsize;
+
+  /**
+   * Size of the file.
+   */
+  unsigned long long fsize;
+
+  /**
+   * Current offset.
+   */
+  unsigned long long offset;
+
+  /**
+   * Run on shutdown?
+   */
+  int run_on_shutdown;
+
+  /**
+   * File descriptor.
+   */
+  int fd;
+
+};
+
+
+/**
+ * Report result of hash computation to callback
+ * and free associated resources.
+ */
+static void
+file_hash_finish (struct FileHashContext *fhc, const GNUNET_HashCode * res)
+{
+  fhc->callback (fhc->callback_cls, res);
+  GNUNET_free (fhc->filename);
+  if (fhc->fd != -1)
+    GNUNET_break (0 == CLOSE (fhc->fd));
+  GNUNET_free (fhc);            /* also frees fhc->buffer */
+}
+
+
+/**
+ * File hashing task.
+ *
+ * @param cls closure
+ * @param tc context
+ */
+static void
+file_hash_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+{
+  struct FileHashContext *fhc = cls;
+  GNUNET_HashCode res;
+  size_t delta;
+
+  GNUNET_assert (fhc->offset < fhc->fsize);
+  delta = fhc->bsize;
+  if (fhc->fsize - fhc->offset < delta)
+    delta = fhc->fsize - fhc->offset;
+  if (delta != READ (fhc->fd, fhc->buffer, delta))
+    {
+      GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING,
+                                "read", fhc->filename);
+      file_hash_finish (fhc, NULL);
+      return;
+    }
+  sha512_update (&fhc->hctx, fhc->buffer, delta);
+  fhc->offset += delta;
+  if (fhc->offset == fhc->fsize)
+    {
+      sha512_final (&fhc->hctx, (unsigned char *) &res);
+      file_hash_finish (fhc, &res);
+      return;
+    }
+  GNUNET_SCHEDULER_add_after (tc->sched,
+                              fhc->run_on_shutdown,
+                              GNUNET_SCHEDULER_PRIORITY_KEEP,
+                              GNUNET_SCHEDULER_NO_PREREQUISITE_TASK,
+                              &file_hash_task, fhc);
+}
+
+
+/**
+ * Compute the hash of an entire file.
+ *
+ * @param sched scheduler to use
+ * @param priority scheduling priority to use
+ * @param run_on_shutdown should we complete even on shutdown?
+ * @param filename name of file to hash
+ * @param blocksize number of bytes to process in one task
+ * @param callback function to call upon completion
+ * @param callback_cls closure for callback
+ */
+void
+GNUNET_CRYPTO_hash_file (struct GNUNET_SCHEDULER_Handle *sched,
+                         enum GNUNET_SCHEDULER_Priority priority,
+                         int run_on_shutdown,
+                         const char *filename,
+                         size_t blocksize,
+                         GNUNET_CRYPTO_HashCompletedCallback callback,
+                         void *callback_cls)
+{
+  struct FileHashContext *fhc;
+
+  GNUNET_assert (blocksize > 0);
+  fhc = GNUNET_malloc (sizeof (struct FileHashContext) + blocksize);
+  fhc->callback = callback;
+  fhc->callback_cls = callback_cls;
+  fhc->buffer = (unsigned char *) &fhc[1];
+  fhc->filename = GNUNET_strdup (filename);
+  fhc->fd = -1;
+  sha512_init (&fhc->hctx);
+  fhc->bsize = blocksize;
+  if (GNUNET_OK != GNUNET_DISK_file_size (filename, &fhc->fsize, GNUNET_NO))
+    {
+      file_hash_finish (fhc, NULL);
+      return;
+    }
+  fhc->run_on_shutdown = run_on_shutdown;
+  fhc->fd = GNUNET_DISK_file_open (filename, O_RDONLY | O_LARGEFILE);
+  if (fhc->fd == -1)
+    {
+      file_hash_finish (fhc, NULL);
+      return;
+    }
+  GNUNET_SCHEDULER_add_after (sched,
+                              run_on_shutdown,
+                              priority,
+                              GNUNET_SCHEDULER_NO_PREREQUISITE_TASK,
+                              &file_hash_task, fhc);
+}
+
+
+/* ***************** binary-ASCII encoding *************** */
+
+/**
+ * 32 characters for encoding (GNUNET_CRYPTO_hash => 32 characters)
+ */
+static char *encTable__ = "0123456789ABCDEFGHIJKLMNOPQRSTUV";
+
+static unsigned int
+getValue__ (unsigned char a)
+{
+  if ((a >= '0') && (a <= '9'))
+    return a - '0';
+  if ((a >= 'A') && (a <= 'V'))
+    return (a - 'A' + 10);
+  return -1;
+}
+
+/**
+ * Convert GNUNET_CRYPTO_hash to ASCII encoding.  The ASCII encoding is rather
+ * GNUnet specific.  It was chosen such that it only uses characters
+ * in [0-9A-V], can be produced without complex arithmetics and uses a
+ * small number of characters.  The GNUnet encoding uses 102
+ * characters plus a null terminator.
+ *
+ * @param block the GNUNET_CRYPTO_hash code
+ * @param result where to store the encoding (struct GNUNET_CRYPTO_HashAsciiEncoded can be
+ *  safely cast to char*, a '\0' termination is set).
+ */
+void
+GNUNET_CRYPTO_hash_to_enc (const GNUNET_HashCode * block,
+                           struct GNUNET_CRYPTO_HashAsciiEncoded *result)
+{
+  unsigned int wpos;
+  unsigned int rpos;
+  unsigned int bits;
+  unsigned int vbit;
+
+  GNUNET_assert (block != NULL);
+  GNUNET_assert (result != NULL);
+  vbit = 0;
+  wpos = 0;
+  rpos = 0;
+  bits = 0;
+  while ((rpos < sizeof (GNUNET_HashCode)) || (vbit > 0))
+    {
+      if ((rpos < sizeof (GNUNET_HashCode)) && (vbit < 5))
+        {
+          bits = (bits << 8) | ((unsigned char *) block)[rpos++];       /* eat 8 more bits */
+          vbit += 8;
+        }
+      if (vbit < 5)
+        {
+          bits <<= (5 - vbit);  /* zero-padding */
+          GNUNET_assert (vbit == 2);    /* padding by 3: 512+3 mod 5 == 0 */
+          vbit = 5;
+        }
+      GNUNET_assert (wpos <
+                     sizeof (struct GNUNET_CRYPTO_HashAsciiEncoded) - 1);
+      result->encoding[wpos++] = encTable__[(bits >> (vbit - 5)) & 31];
+      vbit -= 5;
+    }
+  GNUNET_assert (wpos == sizeof (struct GNUNET_CRYPTO_HashAsciiEncoded) - 1);
+  GNUNET_assert (vbit == 0);
+  result->encoding[wpos] = '\0';
+}
+
+/**
+ * Convert ASCII encoding back to GNUNET_CRYPTO_hash
+ *
+ * @param enc the encoding
+ * @param result where to store the GNUNET_CRYPTO_hash code
+ * @return GNUNET_OK on success, GNUNET_SYSERR if result has the wrong encoding
+ */
+int
+GNUNET_CRYPTO_hash_from_string (const char *enc, GNUNET_HashCode * result)
+{
+  unsigned int rpos;
+  unsigned int wpos;
+  unsigned int bits;
+  unsigned int vbit;
+
+  if (strlen (enc) != sizeof (struct GNUNET_CRYPTO_HashAsciiEncoded) - 1)
+    return GNUNET_SYSERR;
+
+  vbit = 2;                     /* padding! */
+  wpos = sizeof (GNUNET_HashCode);
+  rpos = sizeof (struct GNUNET_CRYPTO_HashAsciiEncoded) - 1;
+  bits = getValue__ (enc[--rpos]) >> 3;
+  while (wpos > 0)
+    {
+      GNUNET_assert (rpos > 0);
+      bits = (getValue__ (enc[--rpos]) << vbit) | bits;
+      vbit += 5;
+      if (vbit >= 8)
+        {
+          ((unsigned char *) result)[--wpos] = (unsigned char) bits;
+          bits >>= 8;
+          vbit -= 8;
+        }
+    }
+  GNUNET_assert (rpos == 0);
+  GNUNET_assert (vbit == 0);
+  return GNUNET_OK;
+}
+
+/**
+ * Compute the distance between 2 hashcodes.  The computation must be
+ * fast, not involve bits[0] or bits[4] (they're used elsewhere), and be
+ * somewhat consistent. And of course, the result should be a positive
+ * number.
+ *
+ * @returns a positive number which is a measure for
+ *  hashcode proximity.
+ */
+unsigned int
+GNUNET_CRYPTO_hash_distance_u32 (const GNUNET_HashCode * a,
+                                 const GNUNET_HashCode * b)
+{
+  unsigned int x1 = (a->bits[1] - b->bits[1]) >> 16;
+  unsigned int x2 = (b->bits[1] - a->bits[1]) >> 16;
+  return (x1 * x2);
+}
+
+void
+GNUNET_CRYPTO_hash_create_random (GNUNET_HashCode * result)
+{
+  int i;
+  for (i = (sizeof (GNUNET_HashCode) / sizeof (unsigned int)) - 1; i >= 0;
+       i--)
+    result->bits[i] = rand ();
+}
+
+void
+GNUNET_CRYPTO_hash_difference (const GNUNET_HashCode * a,
+                               const GNUNET_HashCode * b,
+                               GNUNET_HashCode * result)
+{
+  int i;
+  for (i = (sizeof (GNUNET_HashCode) / sizeof (unsigned int)) - 1; i >= 0;
+       i--)
+    result->bits[i] = b->bits[i] - a->bits[i];
+}
+
+void
+GNUNET_CRYPTO_hash_sum (const GNUNET_HashCode * a,
+                        const GNUNET_HashCode * delta,
+                        GNUNET_HashCode * result)
+{
+  int i;
+  for (i = (sizeof (GNUNET_HashCode) / sizeof (unsigned int)) - 1; i >= 0;
+       i--)
+    result->bits[i] = delta->bits[i] + a->bits[i];
+}
+
+void
+GNUNET_CRYPTO_hash_xor (const GNUNET_HashCode * a,
+                        const GNUNET_HashCode * b, GNUNET_HashCode * result)
+{
+  int i;
+  for (i = (sizeof (GNUNET_HashCode) / sizeof (unsigned int)) - 1; i >= 0;
+       i--)
+    result->bits[i] = a->bits[i] ^ b->bits[i];
+}
+
+/**
+ * Convert a hashcode into a key.
+ */
+void
+GNUNET_CRYPTO_hash_to_AES_key (const GNUNET_HashCode * hc,
+                               struct GNUNET_CRYPTO_AesSessionKey *skey,
+                               struct GNUNET_CRYPTO_AesInitializationVector
+                               *iv)
+{
+  GNUNET_assert (sizeof (GNUNET_HashCode) >=
+                 GNUNET_CRYPTO_AES_KEY_LENGTH +
+                 sizeof (struct GNUNET_CRYPTO_AesInitializationVector));
+  memcpy (skey, hc, GNUNET_CRYPTO_AES_KEY_LENGTH);
+  skey->crc32 =
+    htonl (GNUNET_CRYPTO_crc32_n (skey, GNUNET_CRYPTO_AES_KEY_LENGTH));
+  memcpy (iv, &((char *) hc)[GNUNET_CRYPTO_AES_KEY_LENGTH],
+          sizeof (struct GNUNET_CRYPTO_AesInitializationVector));
+}
+
+/**
+ * Obtain a bit from a hashcode.
+ * @param code the GNUNET_CRYPTO_hash to index bit-wise
+ * @param bit index into the hashcode, [0...511]
+ * @return Bit \a bit from hashcode \a code, -1 for invalid index
+ */
+int
+GNUNET_CRYPTO_hash_get_bit (const GNUNET_HashCode * code, unsigned int bit)
+{
+  GNUNET_assert (bit < 8 * sizeof (GNUNET_HashCode));
+  return (((unsigned char *) code)[bit >> 3] & (1 << (bit & 7))) > 0;
+}
+
+/**
+ * Compare function for HashCodes, producing a total ordering
+ * of all hashcodes.
+ * @return 1 if h1 > h2, -1 if h1 < h2 and 0 if h1 == h2.
+ */
+int
+GNUNET_CRYPTO_hash_cmp (const GNUNET_HashCode * h1,
+                        const GNUNET_HashCode * h2)
+{
+  unsigned int *i1;
+  unsigned int *i2;
+  int i;
+
+  i1 = (unsigned int *) h1;
+  i2 = (unsigned int *) h2;
+  for (i = (sizeof (GNUNET_HashCode) / sizeof (unsigned int)) - 1; i >= 0;
+       i--)
+    {
+      if (i1[i] > i2[i])
+        return 1;
+      if (i1[i] < i2[i])
+        return -1;
+    }
+  return 0;
+}
+
+/**
+ * Find out which of the two GNUNET_CRYPTO_hash codes is closer to target
+ * in the XOR metric (Kademlia).
+ * @return -1 if h1 is closer, 1 if h2 is closer and 0 if h1==h2.
+ */
+int
+GNUNET_CRYPTO_hash_xorcmp (const GNUNET_HashCode * h1,
+                           const GNUNET_HashCode * h2,
+                           const GNUNET_HashCode * target)
+{
+  int i;
+  unsigned int d1;
+  unsigned int d2;
+
+  for (i = sizeof (GNUNET_HashCode) / sizeof (unsigned int) - 1; i >= 0; i--)
+    {
+      d1 = ((unsigned int *) h1)[i] ^ ((unsigned int *) target)[i];
+      d2 = ((unsigned int *) h2)[i] ^ ((unsigned int *) target)[i];
+      if (d1 > d2)
+        return 1;
+      else if (d1 < d2)
+        return -1;
+    }
+  return 0;
+}
+
+/* end of hashing.c */
diff --git a/src/util/crypto_ksk.c b/src/util/crypto_ksk.c
new file mode 100644
index 000000000..c3461ae61
--- /dev/null
+++ b/src/util/crypto_ksk.c
@@ -0,0 +1,791 @@
+/*
+     This file is part of GNUnet.
+     Copyright (C) 1994, 1996, 1998, 2001, 2002, 2003 Free Software Foundation, Inc.
+     Copyright (C) 2004, 2005, 2006 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.
+
+     Note: This code is based on code from libgcrypt
+     The code was adapted for GNUnet to support RSA-key generation
+     based on weak, pseudo-random keys.  Do NOT use to generate
+     ordinary RSA keys!
+*/
+
+
+/**
+ * @file util/crypto_ksk.c
+ * @brief implementation of RSA-Key generation for KBlocks
+ *        (do NOT use for pseudonyms or hostkeys!)
+ * @author Christian Grothoff
+ */
+
+#include "platform.h"
+#include "gnunet_common.h"
+#include "gnunet_crypto_lib.h"
+#include <gmp.h>
+#include <gcrypt.h>
+
+/**
+ * Log an error message at log-level 'level' that indicates
+ * a failure of the command 'cmd' with the message given
+ * by gcry_strerror(rc).
+ */
+#define LOG_GCRY(level, cmd, rc) do { GNUNET_log(level, _("`%s' failed at %s:%d with error: %s\n"), cmd, __FILE__, __LINE__, gcry_strerror(rc)); } while(0);
+
+
+typedef struct
+{
+  mpz_t n;                      /* public modulus */
+  mpz_t e;                      /* public exponent */
+  mpz_t d;                      /* exponent */
+  mpz_t p;                      /* prime  p. */
+  mpz_t q;                      /* prime  q. */
+  mpz_t u;                      /* inverse of p mod q. */
+} KBlock_secret_key;
+
+/**
+ * The private information of an RSA key pair.
+ * NOTE: this must match the definition in crypto_rsa.c
+ */
+struct GNUNET_CRYPTO_RsaPrivateKey
+{
+  gcry_sexp_t sexp;
+};
+
+
+/* Note: 2 is not included because it can be tested more easily by
+   looking at bit 0. The last entry in this list is marked by a zero */
+static uint16_t small_prime_numbers[] = {
+  3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43,
+  47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97, 101,
+  103, 107, 109, 113, 127, 131, 137, 139, 149, 151,
+  157, 163, 167, 173, 179, 181, 191, 193, 197, 199,
+  211, 223, 227, 229, 233, 239, 241, 251, 257, 263,
+  269, 271, 277, 281, 283, 293, 307, 311, 313, 317,
+  331, 337, 347, 349, 353, 359, 367, 373, 379, 383,
+  389, 397, 401, 409, 419, 421, 431, 433, 439, 443,
+  449, 457, 461, 463, 467, 479, 487, 491, 499, 503,
+  509, 521, 523, 541, 547, 557, 563, 569, 571, 577,
+  587, 593, 599, 601, 607, 613, 617, 619, 631, 641,
+  643, 647, 653, 659, 661, 673, 677, 683, 691, 701,
+  709, 719, 727, 733, 739, 743, 751, 757, 761, 769,
+  773, 787, 797, 809, 811, 821, 823, 827, 829, 839,
+  853, 857, 859, 863, 877, 881, 883, 887, 907, 911,
+  919, 929, 937, 941, 947, 953, 967, 971, 977, 983,
+  991, 997, 1009, 1013, 1019, 1021, 1031, 1033,
+  1039, 1049, 1051, 1061, 1063, 1069, 1087, 1091,
+  1093, 1097, 1103, 1109, 1117, 1123, 1129, 1151,
+  1153, 1163, 1171, 1181, 1187, 1193, 1201, 1213,
+  1217, 1223, 1229, 1231, 1237, 1249, 1259, 1277,
+  1279, 1283, 1289, 1291, 1297, 1301, 1303, 1307,
+  1319, 1321, 1327, 1361, 1367, 1373, 1381, 1399,
+  1409, 1423, 1427, 1429, 1433, 1439, 1447, 1451,
+  1453, 1459, 1471, 1481, 1483, 1487, 1489, 1493,
+  1499, 1511, 1523, 1531, 1543, 1549, 1553, 1559,
+  1567, 1571, 1579, 1583, 1597, 1601, 1607, 1609,
+  1613, 1619, 1621, 1627, 1637, 1657, 1663, 1667,
+  1669, 1693, 1697, 1699, 1709, 1721, 1723, 1733,
+  1741, 1747, 1753, 1759, 1777, 1783, 1787, 1789,
+  1801, 1811, 1823, 1831, 1847, 1861, 1867, 1871,
+  1873, 1877, 1879, 1889, 1901, 1907, 1913, 1931,
+  1933, 1949, 1951, 1973, 1979, 1987, 1993, 1997,
+  1999, 2003, 2011, 2017, 2027, 2029, 2039, 2053,
+  2063, 2069, 2081, 2083, 2087, 2089, 2099, 2111,
+  2113, 2129, 2131, 2137, 2141, 2143, 2153, 2161,
+  2179, 2203, 2207, 2213, 2221, 2237, 2239, 2243,
+  2251, 2267, 2269, 2273, 2281, 2287, 2293, 2297,
+  2309, 2311, 2333, 2339, 2341, 2347, 2351, 2357,
+  2371, 2377, 2381, 2383, 2389, 2393, 2399, 2411,
+  2417, 2423, 2437, 2441, 2447, 2459, 2467, 2473,
+  2477, 2503, 2521, 2531, 2539, 2543, 2549, 2551,
+  2557, 2579, 2591, 2593, 2609, 2617, 2621, 2633,
+  2647, 2657, 2659, 2663, 2671, 2677, 2683, 2687,
+  2689, 2693, 2699, 2707, 2711, 2713, 2719, 2729,
+  2731, 2741, 2749, 2753, 2767, 2777, 2789, 2791,
+  2797, 2801, 2803, 2819, 2833, 2837, 2843, 2851,
+  2857, 2861, 2879, 2887, 2897, 2903, 2909, 2917,
+  2927, 2939, 2953, 2957, 2963, 2969, 2971, 2999,
+  3001, 3011, 3019, 3023, 3037, 3041, 3049, 3061,
+  3067, 3079, 3083, 3089, 3109, 3119, 3121, 3137,
+  3163, 3167, 3169, 3181, 3187, 3191, 3203, 3209,
+  3217, 3221, 3229, 3251, 3253, 3257, 3259, 3271,
+  3299, 3301, 3307, 3313, 3319, 3323, 3329, 3331,
+  3343, 3347, 3359, 3361, 3371, 3373, 3389, 3391,
+  3407, 3413, 3433, 3449, 3457, 3461, 3463, 3467,
+  3469, 3491, 3499, 3511, 3517, 3527, 3529, 3533,
+  3539, 3541, 3547, 3557, 3559, 3571, 3581, 3583,
+  3593, 3607, 3613, 3617, 3623, 3631, 3637, 3643,
+  3659, 3671, 3673, 3677, 3691, 3697, 3701, 3709,
+  3719, 3727, 3733, 3739, 3761, 3767, 3769, 3779,
+  3793, 3797, 3803, 3821, 3823, 3833, 3847, 3851,
+  3853, 3863, 3877, 3881, 3889, 3907, 3911, 3917,
+  3919, 3923, 3929, 3931, 3943, 3947, 3967, 3989,
+  4001, 4003, 4007, 4013, 4019, 4021, 4027, 4049,
+  4051, 4057, 4073, 4079, 4091, 4093, 4099, 4111,
+  4127, 4129, 4133, 4139, 4153, 4157, 4159, 4177,
+  4201, 4211, 4217, 4219, 4229, 4231, 4241, 4243,
+  4253, 4259, 4261, 4271, 4273, 4283, 4289, 4297,
+  4327, 4337, 4339, 4349, 4357, 4363, 4373, 4391,
+  4397, 4409, 4421, 4423, 4441, 4447, 4451, 4457,
+  4463, 4481, 4483, 4493, 4507, 4513, 4517, 4519,
+  4523, 4547, 4549, 4561, 4567, 4583, 4591, 4597,
+  4603, 4621, 4637, 4639, 4643, 4649, 4651, 4657,
+  4663, 4673, 4679, 4691, 4703, 4721, 4723, 4729,
+  4733, 4751, 4759, 4783, 4787, 4789, 4793, 4799,
+  4801, 4813, 4817, 4831, 4861, 4871, 4877, 4889,
+  4903, 4909, 4919, 4931, 4933, 4937, 4943, 4951,
+  4957, 4967, 4969, 4973, 4987, 4993, 4999,
+  0
+};
+
+#define DIM(v) (sizeof(v)/sizeof((v)[0]))
+static int no_of_small_prime_numbers = DIM (small_prime_numbers) - 1;
+
+
+     static unsigned int
+     get_nbits (mpz_t a)
+{
+  return mpz_sizeinbase (a, 2);
+}
+
+/**
+ * Count the number of zerobits at the low end of A
+ */
+static unsigned int
+get_trailing_zeros (mpz_t a)
+{
+  unsigned int count = 0;
+  unsigned int nbits = get_nbits (a);
+
+  while ((mpz_tstbit (a, count)) && (count < nbits))
+    count++;
+  return count;
+}
+
+/**
+ * Set bit N of A. and clear all bits above
+ */
+static void
+set_highbit (mpz_t a, unsigned int n)
+{
+  unsigned int nbits;
+
+  nbits = get_nbits (a);
+  while (nbits > n)
+    mpz_clrbit (a, nbits--);
+  mpz_setbit (a, n);
+}
+
+static void
+mpz_randomize (mpz_t n, unsigned int nbits, GNUNET_HashCode * rnd)
+{
+  GNUNET_HashCode *tmp;
+  int cnt;
+  int i;
+
+  cnt = (nbits / sizeof (GNUNET_HashCode) / 8) + 1;
+  tmp = GNUNET_malloc (sizeof (GNUNET_HashCode) * cnt);
+
+  tmp[0] = *rnd;
+  for (i = 0; i < cnt - 1; i++)
+    {
+      GNUNET_CRYPTO_hash (&tmp[i], sizeof (GNUNET_HashCode), &tmp[i + 1]);
+    }
+  *rnd = tmp[cnt - 1];
+  mpz_import (n, cnt * sizeof (GNUNET_HashCode) / sizeof (unsigned int),
+              1, sizeof (unsigned int), 1, 0, tmp);
+  GNUNET_free (tmp);
+  i = get_nbits (n);
+  while (i > nbits)
+    mpz_clrbit (n, i--);
+}
+
+/**
+ * Return true if n is probably a prime
+ */
+static int
+is_prime (mpz_t n, int steps, GNUNET_HashCode * hc)
+{
+  mpz_t x;
+  mpz_t y;
+  mpz_t z;
+  mpz_t nminus1;
+  mpz_t a2;
+  mpz_t q;
+  unsigned int i, j, k;
+  int rc = 0;
+  unsigned int nbits;
+
+  mpz_init (x);
+  mpz_init (y);
+  mpz_init (z);
+  mpz_init (nminus1);
+  mpz_init_set_ui (a2, 2);
+  nbits = get_nbits (n);
+  mpz_sub_ui (nminus1, n, 1);
+
+  /* Find q and k, so that n = 1 + 2^k * q . */
+  mpz_init_set (q, nminus1);
+  k = get_trailing_zeros (q);
+  mpz_tdiv_q_2exp (q, q, k);
+
+  for (i = 0; i < steps; i++)
+    {
+      if (!i)
+        {
+          mpz_set_ui (x, 2);
+        }
+      else
+        {
+          mpz_randomize (x, nbits, hc);
+
+          /* Make sure that the number is smaller than the prime and
+             keep the randomness of the high bit. */
+          if (mpz_tstbit (x, nbits - 2))
+            {
+              set_highbit (x, nbits - 2);       /* Clear all higher bits. */
+            }
+          else
+            {
+              set_highbit (x, nbits - 2);
+              mpz_clrbit (x, nbits - 2);
+            }
+          GNUNET_assert (mpz_cmp (x, nminus1) < 0 && mpz_cmp_ui (x, 1) > 0);
+        }
+      mpz_powm (y, x, q, n);
+      if (mpz_cmp_ui (y, 1) && mpz_cmp (y, nminus1))
+        {
+          for (j = 1; j < k && mpz_cmp (y, nminus1); j++)
+            {
+              mpz_powm (y, y, a2, n);
+              if (!mpz_cmp_ui (y, 1))
+                goto leave;     /* Not a prime. */
+            }
+          if (mpz_cmp (y, nminus1))
+            goto leave;         /* Not a prime. */
+        }
+    }
+  rc = 1;                       /* May be a prime. */
+
+leave:
+  mpz_clear (x);
+  mpz_clear (y);
+  mpz_clear (z);
+  mpz_clear (nminus1);
+  mpz_clear (q);
+  mpz_clear (a2);
+
+  return rc;
+}
+
+static void
+gen_prime (mpz_t ptest, unsigned int nbits, GNUNET_HashCode * hc)
+{
+  mpz_t prime, pminus1, val_2, val_3, result;
+  int i;
+  unsigned x, step;
+  int *mods;
+  mpz_t tmp;
+
+  GNUNET_assert (nbits >= 16);
+
+  mods = GNUNET_malloc (no_of_small_prime_numbers * sizeof (*mods));
+  /* Make nbits fit into mpz_t implementation. */
+  mpz_init_set_ui (val_2, 2);
+  mpz_init_set_ui (val_3, 3);
+  mpz_init (prime);
+  mpz_init (result);
+  mpz_init (pminus1);
+  mpz_init (ptest);
+  while (1)
+    {
+      /* generate a random number */
+      mpz_randomize (prime, nbits, hc);
+      /* Set high order bit to 1, set low order bit to 1.  If we are
+         generating a secret prime we are most probably doing that
+         for RSA, to make sure that the modulus does have the
+         requested key size we set the 2 high order bits. */
+      set_highbit (prime, nbits - 1);
+      mpz_setbit (prime, nbits - 2);
+      mpz_setbit (prime, 0);
+
+      /* Calculate all remainders. */
+      mpz_init (tmp);
+      for (i = 0; (x = small_prime_numbers[i]); i++)
+        mods[i] = mpz_fdiv_r_ui (tmp, prime, x);
+      mpz_clear (tmp);
+      /* Now try some primes starting with prime. */
+      for (step = 0; step < 20000; step += 2)
+        {
+          /* Check against all the small primes we have in mods. */
+          for (i = 0; (x = small_prime_numbers[i]); i++)
+            {
+              while (mods[i] + step >= x)
+                mods[i] -= x;
+              if (!(mods[i] + step))
+                break;
+            }
+          if (x)
+            continue;           /* Found a multiple of an already known prime. */
+
+          mpz_add_ui (ptest, prime, step);
+          if (!mpz_tstbit (ptest, nbits - 2))
+            break;
+
+          /* Do a fast Fermat test now. */
+          mpz_sub_ui (pminus1, ptest, 1);
+          mpz_powm (result, val_2, pminus1, ptest);
+          if ((!mpz_cmp_ui (result, 1)) && (is_prime (ptest, 5, hc)))
+            {
+              /* Got it. */
+              mpz_clear (val_2);
+              mpz_clear (val_3);
+              mpz_clear (result);
+              mpz_clear (pminus1);
+              mpz_clear (prime);
+              GNUNET_free (mods);
+              return;
+            }
+        }
+    }
+}
+
+/**
+ * Find the greatest common divisor G of A and B.
+ * Return: 1 if this 1, 0 in all other cases
+ */
+static int
+test_gcd (mpz_t g, mpz_t xa, mpz_t xb)
+{
+  mpz_t a, b;
+
+  mpz_init_set (a, xa);
+  mpz_init_set (b, xb);
+
+  /* TAOCP Vol II, 4.5.2, Algorithm A */
+  while (mpz_cmp_ui (b, 0))
+    {
+      mpz_fdiv_r (g, a, b);     /* g used as temorary variable */
+      mpz_set (a, b);
+      mpz_set (b, g);
+    }
+  mpz_set (g, a);
+
+  mpz_clear (a);
+  mpz_clear (b);
+  return (0 == mpz_cmp_ui (g, 1));
+}
+
+/**
+ * Generate a key pair with a key of size NBITS.
+ * @param sk where to store the key
+ * @param nbits the number of bits to use
+ * @param hc the HC to use for PRNG (modified!)
+ */
+static void
+generate_kblock_key (KBlock_secret_key * sk,
+                     unsigned int nbits, GNUNET_HashCode * hc)
+{
+  mpz_t t1, t2;
+  mpz_t phi;                    /* helper: (p-1)(q-1) */
+  mpz_t g;
+  mpz_t f;
+
+  /* make sure that nbits is even so that we generate p, q of equal size */
+  if ((nbits & 1))
+    nbits++;
+
+  mpz_init_set_ui (sk->e, 257);
+  mpz_init (sk->n);
+  mpz_init (sk->p);
+  mpz_init (sk->q);
+  mpz_init (sk->d);
+  mpz_init (sk->u);
+
+  mpz_init (t1);
+  mpz_init (t2);
+  mpz_init (phi);
+  mpz_init (g);
+  mpz_init (f);
+
+  do
+    {
+      do
+        {
+          mpz_clear (sk->p);
+          mpz_clear (sk->q);
+          gen_prime (sk->p, nbits / 2, hc);
+          gen_prime (sk->q, nbits / 2, hc);
+
+          if (mpz_cmp (sk->p, sk->q) > 0)       /* p shall be smaller than q (for calc of u) */
+            mpz_swap (sk->p, sk->q);
+          /* calculate the modulus */
+          mpz_mul (sk->n, sk->p, sk->q);
+        }
+      while (get_nbits (sk->n) != nbits);
+
+      /* calculate Euler totient: phi = (p-1)(q-1) */
+      mpz_sub_ui (t1, sk->p, 1);
+      mpz_sub_ui (t2, sk->q, 1);
+      mpz_mul (phi, t1, t2);
+      mpz_gcd (g, t1, t2);
+      mpz_fdiv_q (f, phi, g);
+
+      while (0 == test_gcd (t1, sk->e, phi))
+        {                       /* (while gcd is not 1) */
+          mpz_add_ui (sk->e, sk->e, 2);
+        }
+
+      /* calculate the secret key d = e^1 mod phi */
+    }
+  while ((0 == mpz_invert (sk->d, sk->e, f)) ||
+         (0 == mpz_invert (sk->u, sk->p, sk->q)));
+
+  mpz_clear (t1);
+  mpz_clear (t2);
+  mpz_clear (phi);
+  mpz_clear (f);
+  mpz_clear (g);
+}
+
+
+/**
+ * Internal representation of the private key.
+ */
+struct KskRsaPrivateKeyBinaryEncoded
+{
+  /**
+   * Total size of the structure, in bytes, in big-endian!
+   */
+  uint16_t len GNUNET_PACKED;
+  uint16_t sizen GNUNET_PACKED; /*  in big-endian! */
+  uint16_t sizee GNUNET_PACKED; /*  in big-endian! */
+  uint16_t sized GNUNET_PACKED; /*  in big-endian! */
+  uint16_t sizep GNUNET_PACKED; /*  in big-endian! */
+  uint16_t sizeq GNUNET_PACKED; /*  in big-endian! */
+  uint16_t sizedmp1 GNUNET_PACKED;      /*  in big-endian! */
+  uint16_t sizedmq1 GNUNET_PACKED;      /*  in big-endian! */
+  /* followed by the actual values */
+};
+
+
+/**
+ * Deterministically (!) create a hostkey using only the
+ * given HashCode as input to the PRNG.
+ */
+static struct KskRsaPrivateKeyBinaryEncoded *
+makeKblockKeyInternal (const GNUNET_HashCode * hc)
+{
+  KBlock_secret_key sk;
+  GNUNET_HashCode hx;
+  void *pbu[6];
+  mpz_t *pkv[6];
+  size_t sizes[6];
+  struct KskRsaPrivateKeyBinaryEncoded *retval;
+  int i;
+  size_t size;
+
+  hx = *hc;
+  generate_kblock_key (&sk, 1024,       /* at least 10x as fast than 2048 bits
+                                           -- we simply cannot afford 2048 bits
+                                           even on modern hardware, and especially
+                                           not since clearly a dictionary attack
+                                           will still be much cheaper
+                                           than breaking a 1024 bit RSA key.
+                                           If an adversary can spend the time to
+                                           break a 1024 bit RSA key just to forge
+                                           a signature -- SO BE IT. [ CG, 6/2005 ] */
+                       &hx);
+  pkv[0] = &sk.n;
+  pkv[1] = &sk.e;
+  pkv[2] = &sk.d;
+  pkv[3] = &sk.p;
+  pkv[4] = &sk.q;
+  pkv[5] = &sk.u;
+  size = sizeof (struct KskRsaPrivateKeyBinaryEncoded);
+  for (i = 0; i < 6; i++)
+    {
+      pbu[i] = mpz_export (NULL, &sizes[i], 1,  /* most significant word first */
+                           1,   /* unit is bytes */
+                           1,   /* big endian */
+                           0,   /* nails */
+                           *pkv[i]);
+      size += sizes[i];
+    }
+  GNUNET_assert (size < 65536);
+  retval = GNUNET_malloc (size);
+  retval->len = htons (size);
+  i = 0;
+  retval->sizen = htons (sizes[0]);
+  memcpy (&((char *) &retval[1])[i], pbu[0], sizes[0]);
+  i += sizes[0];
+  retval->sizee = htons (sizes[1]);
+  memcpy (&((char *) &retval[1])[i], pbu[1], sizes[1]);
+  i += sizes[1];
+  retval->sized = htons (sizes[2]);
+  memcpy (&((char *) &retval[1])[i], pbu[2], sizes[2]);
+  i += sizes[2];
+  /* swap p and q! */
+  retval->sizep = htons (sizes[4]);
+  memcpy (&((char *) &retval[1])[i], pbu[4], sizes[4]);
+  i += sizes[4];
+  retval->sizeq = htons (sizes[3]);
+  memcpy (&((char *) &retval[1])[i], pbu[3], sizes[3]);
+  i += sizes[3];
+  retval->sizedmp1 = htons (0);
+  retval->sizedmq1 = htons (0);
+  memcpy (&((char *) &retval[1])[i], pbu[5], sizes[5]);
+  for (i = 0; i < 6; i++)
+    {
+      mpz_clear (*pkv[i]);
+      free (pbu[i]);
+    }
+  return retval;
+}
+
+
+/**
+ * Decode the internal format into the format used
+ * by libgcrypt.
+ */
+static struct GNUNET_CRYPTO_RsaPrivateKey *
+ksk_decode_key (const struct KskRsaPrivateKeyBinaryEncoded *encoding)
+{
+  struct GNUNET_CRYPTO_RsaPrivateKey *ret;
+  gcry_sexp_t res;
+  gcry_mpi_t n, e, d, p, q, u;
+  int rc;
+  size_t size;
+  int pos;
+
+  pos = 0;
+  size = ntohs (encoding->sizen);
+  rc = gcry_mpi_scan (&n,
+                      GCRYMPI_FMT_USG,
+                      &((const unsigned char *) (&encoding[1]))[pos],
+                      size, &size);
+  pos += ntohs (encoding->sizen);
+  if (rc)
+    {
+      LOG_GCRY (GNUNET_ERROR_TYPE_ERROR, "gcry_mpi_scan", rc);
+      return NULL;
+    }
+  size = ntohs (encoding->sizee);
+  rc = gcry_mpi_scan (&e,
+                      GCRYMPI_FMT_USG,
+                      &((const unsigned char *) (&encoding[1]))[pos],
+                      size, &size);
+  pos += ntohs (encoding->sizee);
+  if (rc)
+    {
+      LOG_GCRY (GNUNET_ERROR_TYPE_ERROR, "gcry_mpi_scan", rc);
+      gcry_mpi_release (n);
+      return NULL;
+    }
+  size = ntohs (encoding->sized);
+  rc = gcry_mpi_scan (&d,
+                      GCRYMPI_FMT_USG,
+                      &((const unsigned char *) (&encoding[1]))[pos],
+                      size, &size);
+  pos += ntohs (encoding->sized);
+  if (rc)
+    {
+      LOG_GCRY (GNUNET_ERROR_TYPE_ERROR, "gcry_mpi_scan", rc);
+      gcry_mpi_release (n);
+      gcry_mpi_release (e);
+      return NULL;
+    }
+  /* swap p and q! */
+  size = ntohs (encoding->sizep);
+  if (size > 0)
+    {
+      rc = gcry_mpi_scan (&q,
+                          GCRYMPI_FMT_USG,
+                          &((const unsigned char *) (&encoding[1]))[pos],
+                          size, &size);
+      pos += ntohs (encoding->sizep);
+      if (rc)
+        {
+          LOG_GCRY (GNUNET_ERROR_TYPE_ERROR, "gcry_mpi_scan", rc);
+          gcry_mpi_release (n);
+          gcry_mpi_release (e);
+          gcry_mpi_release (d);
+          return NULL;
+        }
+    }
+  else
+    q = NULL;
+  size = ntohs (encoding->sizeq);
+  if (size > 0)
+    {
+      rc = gcry_mpi_scan (&p,
+                          GCRYMPI_FMT_USG,
+                          &((const unsigned char *) (&encoding[1]))[pos],
+                          size, &size);
+      pos += ntohs (encoding->sizeq);
+      if (rc)
+        {
+          LOG_GCRY (GNUNET_ERROR_TYPE_ERROR, "gcry_mpi_scan", rc);
+          gcry_mpi_release (n);
+          gcry_mpi_release (e);
+          gcry_mpi_release (d);
+          if (q != NULL)
+            gcry_mpi_release (q);
+          return NULL;
+        }
+    }
+  else
+    p = NULL;
+  pos += ntohs (encoding->sizedmp1);
+  pos += ntohs (encoding->sizedmq1);
+  size =
+    ntohs (encoding->len) - sizeof (struct KskRsaPrivateKeyBinaryEncoded) -
+    pos;
+  if (size > 0)
+    {
+      rc = gcry_mpi_scan (&u,
+                          GCRYMPI_FMT_USG,
+                          &((const unsigned char *) (&encoding[1]))[pos],
+                          size, &size);
+      if (rc)
+        {
+          LOG_GCRY (GNUNET_ERROR_TYPE_ERROR, "gcry_mpi_scan", rc);
+          gcry_mpi_release (n);
+          gcry_mpi_release (e);
+          gcry_mpi_release (d);
+          if (p != NULL)
+            gcry_mpi_release (p);
+          if (q != NULL)
+            gcry_mpi_release (q);
+          return NULL;
+        }
+    }
+  else
+    u = NULL;
+
+  if ((p != NULL) && (q != NULL) && (u != NULL))
+    {
+      rc = gcry_sexp_build (&res, &size,        /* erroff */
+                            "(private-key(rsa(n %m)(e %m)(d %m)(p %m)(q %m)(u %m)))",
+                            n, e, d, p, q, u);
+    }
+  else
+    {
+      if ((p != NULL) && (q != NULL))
+        {
+          rc = gcry_sexp_build (&res, &size,    /* erroff */
+                                "(private-key(rsa(n %m)(e %m)(d %m)(p %m)(q %m)))",
+                                n, e, d, p, q);
+        }
+      else
+        {
+          rc = gcry_sexp_build (&res, &size,    /* erroff */
+                                "(private-key(rsa(n %m)(e %m)(d %m)))",
+                                n, e, d);
+        }
+    }
+  gcry_mpi_release (n);
+  gcry_mpi_release (e);
+  gcry_mpi_release (d);
+  if (p != NULL)
+    gcry_mpi_release (p);
+  if (q != NULL)
+    gcry_mpi_release (q);
+  if (u != NULL)
+    gcry_mpi_release (u);
+
+  if (rc)
+    LOG_GCRY (GNUNET_ERROR_TYPE_ERROR, "gcry_sexp_build", rc);
+#if EXTRA_CHECKS
+  if (gcry_pk_testkey (res))
+    {
+      LOG_GCRY (GNUNET_ERROR_TYPE_ERROR, "gcry_pk_testkey", rc);
+      return NULL;
+    }
+#endif
+  ret = GNUNET_malloc (sizeof (struct GNUNET_CRYPTO_RsaPrivateKey));
+  ret->sexp = res;
+  return ret;
+}
+
+
+
+
+typedef struct
+{
+  GNUNET_HashCode hc;
+  struct KskRsaPrivateKeyBinaryEncoded *pke;
+} KBlockKeyCacheLine;
+
+static KBlockKeyCacheLine **cache;
+static unsigned int cacheSize;
+
+/**
+ * Deterministically (!) create a hostkey using only the
+ * given HashCode as input to the PRNG.
+ */
+struct GNUNET_CRYPTO_RsaPrivateKey *
+GNUNET_CRYPTO_rsa_key_create_from_hash (const GNUNET_HashCode * hc)
+{
+  struct GNUNET_CRYPTO_RsaPrivateKey *ret;
+  KBlockKeyCacheLine *line;
+  int i;
+
+  for (i = 0; i < cacheSize; i++)
+    {
+      if (0 == memcmp (hc, &cache[i]->hc, sizeof (GNUNET_HashCode)))
+        {
+          ret = ksk_decode_key (cache[i]->pke);
+          return ret;
+        }
+    }
+
+  line = GNUNET_malloc (sizeof (KBlockKeyCacheLine));
+  line->hc = *hc;
+  line->pke = makeKblockKeyInternal (hc);
+  GNUNET_array_grow (cache, cacheSize, cacheSize + 1);
+  cache[cacheSize - 1] = line;
+  return ksk_decode_key (line->pke);
+}
+
+void __attribute__ ((constructor)) GNUNET_CRYPTO_ksk_init ()
+{
+  gcry_control (GCRYCTL_DISABLE_SECMEM, 0);
+  if (!gcry_check_version (GCRYPT_VERSION))
+    {
+      fprintf (stderr,
+               _
+               ("libgcrypt has not the expected version (version %s is required).\n"),
+               GCRYPT_VERSION);
+      abort ();
+    }
+#ifdef gcry_fast_random_poll
+  gcry_fast_random_poll ();
+#endif
+}
+
+void __attribute__ ((destructor)) GNUNET_CRYPTO_ksk_fini ()
+{
+  int i;
+  for (i = 0; i < cacheSize; i++)
+    {
+      GNUNET_free (cache[i]->pke);
+      GNUNET_free (cache[i]);
+    }
+  GNUNET_array_grow (cache, cacheSize, 0);
+}
+
+/* end of kblockkey.c */
diff --git a/src/util/crypto_random.c b/src/util/crypto_random.c
new file mode 100644
index 000000000..3f7ac4dd3
--- /dev/null
+++ b/src/util/crypto_random.c
@@ -0,0 +1,136 @@
+/*
+     This file is part of GNUnet.
+     (C) 2001, 2002, 2003, 2004, 2005, 2006 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 util/crypto_random.c
+ * @brief functions to gather random numbers
+ * @author Christian Grothoff
+ */
+#include "platform.h"
+#include "gnunet_common.h"
+#include "gnunet_crypto_lib.h"
+#include <gcrypt.h>
+
+/**
+ * @return a random value in the interval [0,i[.
+ */
+unsigned int
+GNUNET_CRYPTO_random_u32 (enum GNUNET_CRYPTO_Quality mode, unsigned int i)
+{
+#ifdef gcry_fast_random_poll
+  static unsigned int invokeCount;
+#endif
+  unsigned int ret;
+
+  GNUNET_assert (i > 0);
+
+  if (mode == GNUNET_CRYPTO_QUALITY_STRONG)
+    {
+      /* see http://lists.gnupg.org/pipermail/gcrypt-devel/2004-May/000613.html */
+#ifdef gcry_fast_random_poll
+      if ((invokeCount++ % 256) == 0)
+        gcry_fast_random_poll ();
+#endif
+      ret = rand ();            /* in case gcry_randomize fails,
+                                   we at least get a pseudo-
+                                   random number this way */
+      gcry_randomize ((unsigned char *) &ret,
+                      sizeof (unsigned int), GCRY_STRONG_RANDOM);
+      return ret % i;
+    }
+  else
+    {
+      ret = i * ((double) RANDOM () / RAND_MAX);
+      if (ret >= i)
+        ret = i - 1;
+      return ret;
+    }
+}
+
+
+/**
+ * Get an array with a random permutation of the
+ * numbers 0...n-1.
+ * @param mode GNUNET_RANDOM_QUALITY_STRONG if the strong (but expensive)
+ *        PRNG should be used, GNUNET_RANDOM_QUALITY_WEAK otherwise
+ * @param n the size of the array
+ * @return the permutation array (allocated from heap)
+ */
+unsigned int *
+GNUNET_CRYPTO_random_permute (enum GNUNET_CRYPTO_Quality mode, unsigned int n)
+{
+  unsigned int *ret;
+  unsigned int i;
+  unsigned int tmp;
+  unsigned int x;
+
+  GNUNET_assert (n > 0);
+  ret = GNUNET_malloc (n * sizeof (int));
+  for (i = 0; i < n; i++)
+    ret[i] = i;
+  for (i = 0; i < n; i++)
+    {
+      x = GNUNET_CRYPTO_random_u32 (mode, n);
+      tmp = ret[x];
+      ret[x] = ret[i];
+      ret[i] = tmp;
+    }
+  return ret;
+}
+
+/**
+ * Random on unsigned 64-bit values.
+ */
+unsigned long long
+GNUNET_CRYPTO_random_u64 (enum GNUNET_CRYPTO_Quality mode,
+                          unsigned long long u)
+{
+  unsigned long long ret;
+
+  GNUNET_assert (u > 0);
+  if (mode == GNUNET_CRYPTO_QUALITY_STRONG)
+    {
+      gcry_randomize ((unsigned char *) &ret,
+                      sizeof (unsigned long long), GCRY_STRONG_RANDOM);
+      return ret % u;
+    }
+  else
+    {
+      ret = u * ((double) RANDOM () / RAND_MAX);
+      if (ret >= u)
+        ret = u - 1;
+      return ret;
+    }
+}
+
+/**
+ * This function should only be called in testcases
+ * where strong entropy gathering is not desired
+ * (for example, for hostkey generation).
+ */
+void
+GNUNET_CRYPTO_random_disable_entropy_gathering ()
+{
+  gcry_control (GCRYCTL_ENABLE_QUICK_RANDOM, 0);
+}
+
+
+/* end of crypto_random.c */
diff --git a/src/util/crypto_rsa.c b/src/util/crypto_rsa.c
new file mode 100644
index 000000000..b61729e06
--- /dev/null
+++ b/src/util/crypto_rsa.c
@@ -0,0 +1,948 @@
+/*
+     This file is part of GNUnet.
+     (C) 2001, 2002, 2003, 2004, 2005, 2006, 2009 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 util/crypto_rsa.c
+ * @brief public key cryptography (RSA) with libgcrypt
+ * @author Christian Grothoff
+ *
+ * Note that the code locks often needlessly on the gcrypt-locking api.
+ * One would think that simple MPI operations should not require locking
+ * (since only global operations on the random pool must be locked,
+ * strictly speaking).  But libgcrypt does sometimes require locking in
+ * unexpected places, so the safe solution is to always lock even if it
+ * is not required.  The performance impact is minimal anyway.
+ */
+
+#include "platform.h"
+#include <gcrypt.h>
+#include "gnunet_common.h"
+#include "gnunet_crypto_lib.h"
+#include "gnunet_disk_lib.h"
+
+/**
+ * The private information of an RSA key pair.
+ * NOTE: this must match the definition in crypto_ksk.c
+ */
+struct GNUNET_CRYPTO_RsaPrivateKey
+{
+  gcry_sexp_t sexp;
+};
+
+
+/**
+ * GNUnet mandates a certain format for the encoding
+ * of private RSA key information that is provided
+ * by the RSA implementations.  This format is used
+ * to serialize a private RSA key (typically when
+ * writing it to disk).
+ */
+struct RsaPrivateKeyBinaryEncoded
+{
+  /**
+   * Total size of the structure, in bytes, in big-endian!
+   */
+  uint16_t len GNUNET_PACKED;
+  uint16_t sizen GNUNET_PACKED; /*  in big-endian! */
+  uint16_t sizee GNUNET_PACKED; /*  in big-endian! */
+  uint16_t sized GNUNET_PACKED; /*  in big-endian! */
+  uint16_t sizep GNUNET_PACKED; /*  in big-endian! */
+  uint16_t sizeq GNUNET_PACKED; /*  in big-endian! */
+  uint16_t sizedmp1 GNUNET_PACKED;      /*  in big-endian! */
+  uint16_t sizedmq1 GNUNET_PACKED;      /*  in big-endian! */
+  /* followed by the actual values */
+};
+
+
+#define HOSTKEY_LEN 2048
+
+#define EXTRA_CHECKS ALLOW_EXTRA_CHECKS
+
+
+/**
+ * Log an error message at log-level 'level' that indicates
+ * a failure of the command 'cmd' with the message given
+ * by gcry_strerror(rc).
+ */
+#define LOG_GCRY(level, cmd, rc) do { GNUNET_log(level, _("`%s' failed at %s:%d with error: %s\n"), cmd, __FILE__, __LINE__, gcry_strerror(rc)); } while(0);
+
+/**
+ * If target != size, move target bytes to the
+ * end of the size-sized buffer and zero out the
+ * first target-size bytes.
+ */
+static void
+adjust (unsigned char *buf, size_t size, size_t target)
+{
+  if (size < target)
+    {
+      memmove (&buf[target - size], buf, size);
+      memset (buf, 0, target - size);
+    }
+}
+
+/**
+ * This HostKey implementation uses RSA.
+ */
+struct GNUNET_CRYPTO_RsaPrivateKey *
+GNUNET_CRYPTO_rsa_key_create ()
+{
+  struct GNUNET_CRYPTO_RsaPrivateKey *ret;
+  gcry_sexp_t s_key;
+  gcry_sexp_t s_keyparam;
+
+  GNUNET_assert (0 == gcry_sexp_build (&s_keyparam,
+                                       NULL,
+                                       "(genkey(rsa(nbits %d)(rsa-use-e 3:257)))",
+                                       HOSTKEY_LEN));
+  GNUNET_assert (0 == gcry_pk_genkey (&s_key, s_keyparam));
+  gcry_sexp_release (s_keyparam);
+#if EXTRA_CHECKS
+  GNUNET_assert (0 == gcry_pk_testkey (s_key));
+#endif
+  ret = GNUNET_malloc (sizeof (struct GNUNET_CRYPTO_RsaPrivateKey));
+  ret->sexp = s_key;
+  return ret;
+}
+
+/**
+ * Free memory occupied by hostkey
+ */
+void
+GNUNET_CRYPTO_rsa_key_free (struct GNUNET_CRYPTO_RsaPrivateKey *hostkey)
+{
+  gcry_sexp_release (hostkey->sexp);
+  GNUNET_free (hostkey);
+}
+
+static int
+key_from_sexp (gcry_mpi_t * array,
+               gcry_sexp_t sexp, const char *topname, const char *elems)
+{
+  gcry_sexp_t list, l2;
+  const char *s;
+  int i, idx;
+
+  list = gcry_sexp_find_token (sexp, topname, 0);
+  if (!list)
+    {
+      return 1;
+    }
+  l2 = gcry_sexp_cadr (list);
+  gcry_sexp_release (list);
+  list = l2;
+  if (!list)
+    {
+      return 2;
+    }
+
+  idx = 0;
+  for (s = elems; *s; s++, idx++)
+    {
+      l2 = gcry_sexp_find_token (list, s, 1);
+      if (!l2)
+        {
+          for (i = 0; i < idx; i++)
+            {
+              gcry_free (array[i]);
+              array[i] = NULL;
+            }
+          gcry_sexp_release (list);
+          return 3;             /* required parameter not found */
+        }
+      array[idx] = gcry_sexp_nth_mpi (l2, 1, GCRYMPI_FMT_USG);
+      gcry_sexp_release (l2);
+      if (!array[idx])
+        {
+          for (i = 0; i < idx; i++)
+            {
+              gcry_free (array[i]);
+              array[i] = NULL;
+            }
+          gcry_sexp_release (list);
+          return 4;             /* required parameter is invalid */
+        }
+    }
+  gcry_sexp_release (list);
+  return 0;
+}
+
+/**
+ * Extract the public key of the host.
+ * @param hostkey the hostkey to extract into the result.
+ * @param result where to write the result.
+ */
+void
+GNUNET_CRYPTO_rsa_key_get_public (const struct GNUNET_CRYPTO_RsaPrivateKey
+                                  *hostkey,
+                                  struct
+                                  GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded
+                                  *result)
+{
+  gcry_mpi_t skey[2];
+  size_t size;
+  int rc;
+
+  rc = key_from_sexp (skey, hostkey->sexp, "public-key", "ne");
+  if (rc)
+    rc = key_from_sexp (skey, hostkey->sexp, "private-key", "ne");
+  if (rc)
+    rc = key_from_sexp (skey, hostkey->sexp, "rsa", "ne");
+  GNUNET_assert (0 == rc);
+  result->len =
+    htons (sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded) -
+           sizeof (result->padding));
+  result->sizen = htons (GNUNET_CRYPTO_RSA_DATA_ENCODING_LENGTH);
+  result->padding = 0;
+  size = GNUNET_CRYPTO_RSA_DATA_ENCODING_LENGTH;
+  GNUNET_assert (0 == gcry_mpi_print (GCRYMPI_FMT_USG,
+                                      &result->key[0], size, &size, skey[0]));
+  adjust (&result->key[0], size, GNUNET_CRYPTO_RSA_DATA_ENCODING_LENGTH);
+  size =
+    GNUNET_CRYPTO_RSA_KEY_LENGTH - GNUNET_CRYPTO_RSA_DATA_ENCODING_LENGTH;
+  GNUNET_assert (0 ==
+                 gcry_mpi_print (GCRYMPI_FMT_USG,
+                                 &result->
+                                 key[GNUNET_CRYPTO_RSA_DATA_ENCODING_LENGTH],
+                                 size, &size, skey[1]));
+  adjust (&result->key[GNUNET_CRYPTO_RSA_DATA_ENCODING_LENGTH], size,
+          GNUNET_CRYPTO_RSA_KEY_LENGTH -
+          GNUNET_CRYPTO_RSA_DATA_ENCODING_LENGTH);
+  gcry_mpi_release (skey[0]);
+  gcry_mpi_release (skey[1]);
+}
+
+
+/**
+ * Internal: publicKey => RSA-Key.
+ *
+ * Note that the return type is not actually a private
+ * key but rather an sexpression for the public key!
+ */
+static struct GNUNET_CRYPTO_RsaPrivateKey *
+public2PrivateKey (const struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded
+                   *publicKey)
+{
+  struct GNUNET_CRYPTO_RsaPrivateKey *ret;
+  gcry_sexp_t result;
+  gcry_mpi_t n;
+  gcry_mpi_t e;
+  size_t size;
+  size_t erroff;
+  int rc;
+
+  if ((ntohs (publicKey->sizen) != GNUNET_CRYPTO_RSA_DATA_ENCODING_LENGTH) ||
+      (ntohs (publicKey->len) !=
+       sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded) -
+       sizeof (publicKey->padding)))
+    {
+      GNUNET_break (0);
+      return NULL;
+    }
+  size = GNUNET_CRYPTO_RSA_DATA_ENCODING_LENGTH;
+  rc = gcry_mpi_scan (&n, GCRYMPI_FMT_USG, &publicKey->key[0], size, &size);
+  if (rc)
+    {
+      LOG_GCRY (GNUNET_ERROR_TYPE_ERROR, "gcry_mpi_scan", rc);
+      return NULL;
+    }
+  size =
+    GNUNET_CRYPTO_RSA_KEY_LENGTH - GNUNET_CRYPTO_RSA_DATA_ENCODING_LENGTH;
+  rc =
+    gcry_mpi_scan (&e, GCRYMPI_FMT_USG,
+                   &publicKey->key[GNUNET_CRYPTO_RSA_DATA_ENCODING_LENGTH],
+                   size, &size);
+  if (rc)
+    {
+      LOG_GCRY (GNUNET_ERROR_TYPE_ERROR, "gcry_mpi_scan", rc);
+      gcry_mpi_release (n);
+      return NULL;
+    }
+  rc = gcry_sexp_build (&result,
+                        &erroff, "(public-key(rsa(n %m)(e %m)))", n, e);
+  gcry_mpi_release (n);
+  gcry_mpi_release (e);
+  if (rc)
+    {
+      LOG_GCRY (GNUNET_ERROR_TYPE_ERROR, "gcry_sexp_build", rc);        /* erroff gives more info */
+      return NULL;
+    }
+  ret = GNUNET_malloc (sizeof (struct GNUNET_CRYPTO_RsaPrivateKey));
+  ret->sexp = result;
+  return ret;
+}
+
+
+/**
+ * Encode the private key in a format suitable for
+ * storing it into a file.
+ * @returns encoding of the private key.
+ *    The first 4 bytes give the size of the array, as usual.
+ */
+static struct RsaPrivateKeyBinaryEncoded *
+rsa_encode_key (const struct GNUNET_CRYPTO_RsaPrivateKey *hostkey)
+{
+  struct RsaPrivateKeyBinaryEncoded *retval;
+  gcry_mpi_t pkv[6];
+  void *pbu[6];
+  size_t sizes[6];
+  int rc;
+  int i;
+  int size;
+
+#if EXTRA_CHECKS
+  if (gcry_pk_testkey (hostkey->sexp))
+    {
+      GNUNET_break (0);
+      return NULL;
+    }
+#endif
+
+  memset (pkv, 0, sizeof (gcry_mpi_t) * 6);
+  rc = key_from_sexp (pkv, hostkey->sexp, "private-key", "nedpqu");
+  if (rc)
+    rc = key_from_sexp (pkv, hostkey->sexp, "rsa", "nedpqu");
+  if (rc)
+    rc = key_from_sexp (pkv, hostkey->sexp, "private-key", "nedpq");
+  if (rc)
+    rc = key_from_sexp (pkv, hostkey->sexp, "rsa", "nedpq");
+  if (rc)
+    rc = key_from_sexp (pkv, hostkey->sexp, "private-key", "ned");
+  if (rc)
+    rc = key_from_sexp (pkv, hostkey->sexp, "rsa", "ned");
+  GNUNET_assert (0 == rc);
+  size = sizeof (struct RsaPrivateKeyBinaryEncoded);
+  for (i = 0; i < 6; i++)
+    {
+      if (pkv[i] != NULL)
+        {
+          GNUNET_assert (0 == gcry_mpi_aprint (GCRYMPI_FMT_USG,
+                                               (unsigned char **) &pbu[i],
+                                               &sizes[i], pkv[i]));
+          size += sizes[i];
+        }
+      else
+        {
+          pbu[i] = NULL;
+          sizes[i] = 0;
+        }
+    }
+  GNUNET_assert (size < 65536);
+  retval = GNUNET_malloc (size);
+  retval->len = htons (size);
+  i = 0;
+  retval->sizen = htons (sizes[0]);
+  memcpy (&((char *) (&retval[1]))[i], pbu[0], sizes[0]);
+  i += sizes[0];
+  retval->sizee = htons (sizes[1]);
+  memcpy (&((char *) (&retval[1]))[i], pbu[1], sizes[1]);
+  i += sizes[1];
+  retval->sized = htons (sizes[2]);
+  memcpy (&((char *) (&retval[1]))[i], pbu[2], sizes[2]);
+  i += sizes[2];
+  /* swap p and q! */
+  retval->sizep = htons (sizes[4]);
+  memcpy (&((char *) (&retval[1]))[i], pbu[4], sizes[4]);
+  i += sizes[4];
+  retval->sizeq = htons (sizes[3]);
+  memcpy (&((char *) (&retval[1]))[i], pbu[3], sizes[3]);
+  i += sizes[3];
+  retval->sizedmp1 = htons (0);
+  retval->sizedmq1 = htons (0);
+  memcpy (&((char *) (&retval[1]))[i], pbu[5], sizes[5]);
+  for (i = 0; i < 6; i++)
+    {
+      if (pkv[i] != NULL)
+        gcry_mpi_release (pkv[i]);
+      if (pbu[i] != NULL)
+        free (pbu[i]);
+    }
+  return retval;
+}
+
+/**
+ * Decode the private key from the file-format back
+ * to the "normal", internal format.
+ */
+static struct GNUNET_CRYPTO_RsaPrivateKey *
+rsa_decode_key (const struct RsaPrivateKeyBinaryEncoded *encoding)
+{
+  struct GNUNET_CRYPTO_RsaPrivateKey *ret;
+  gcry_sexp_t res;
+  gcry_mpi_t n, e, d, p, q, u;
+  int rc;
+  size_t size;
+  int pos;
+
+  pos = 0;
+  size = ntohs (encoding->sizen);
+  rc = gcry_mpi_scan (&n,
+                      GCRYMPI_FMT_USG,
+                      &((const unsigned char *) (&encoding[1]))[pos],
+                      size, &size);
+  pos += ntohs (encoding->sizen);
+  if (rc)
+    {
+      LOG_GCRY (GNUNET_ERROR_TYPE_ERROR, "gcry_mpi_scan", rc);
+      return NULL;
+    }
+  size = ntohs (encoding->sizee);
+  rc = gcry_mpi_scan (&e,
+                      GCRYMPI_FMT_USG,
+                      &((const unsigned char *) (&encoding[1]))[pos],
+                      size, &size);
+  pos += ntohs (encoding->sizee);
+  if (rc)
+    {
+      LOG_GCRY (GNUNET_ERROR_TYPE_ERROR, "gcry_mpi_scan", rc);
+      gcry_mpi_release (n);
+      return NULL;
+    }
+  size = ntohs (encoding->sized);
+  rc = gcry_mpi_scan (&d,
+                      GCRYMPI_FMT_USG,
+                      &((const unsigned char *) (&encoding[1]))[pos],
+                      size, &size);
+  pos += ntohs (encoding->sized);
+  if (rc)
+    {
+      LOG_GCRY (GNUNET_ERROR_TYPE_ERROR, "gcry_mpi_scan", rc);
+      gcry_mpi_release (n);
+      gcry_mpi_release (e);
+      return NULL;
+    }
+  /* swap p and q! */
+  size = ntohs (encoding->sizep);
+  if (size > 0)
+    {
+      rc = gcry_mpi_scan (&q,
+                          GCRYMPI_FMT_USG,
+                          &((const unsigned char *) (&encoding[1]))[pos],
+                          size, &size);
+      pos += ntohs (encoding->sizep);
+      if (rc)
+        {
+          LOG_GCRY (GNUNET_ERROR_TYPE_ERROR, "gcry_mpi_scan", rc);
+          gcry_mpi_release (n);
+          gcry_mpi_release (e);
+          gcry_mpi_release (d);
+          return NULL;
+        }
+    }
+  else
+    q = NULL;
+  size = ntohs (encoding->sizeq);
+  if (size > 0)
+    {
+      rc = gcry_mpi_scan (&p,
+                          GCRYMPI_FMT_USG,
+                          &((const unsigned char *) (&encoding[1]))[pos],
+                          size, &size);
+      pos += ntohs (encoding->sizeq);
+      if (rc)
+        {
+          LOG_GCRY (GNUNET_ERROR_TYPE_ERROR, "gcry_mpi_scan", rc);
+          gcry_mpi_release (n);
+          gcry_mpi_release (e);
+          gcry_mpi_release (d);
+          if (q != NULL)
+            gcry_mpi_release (q);
+          return NULL;
+        }
+    }
+  else
+    p = NULL;
+  pos += ntohs (encoding->sizedmp1);
+  pos += ntohs (encoding->sizedmq1);
+  size =
+    ntohs (encoding->len) - sizeof (struct RsaPrivateKeyBinaryEncoded) - pos;
+  if (size > 0)
+    {
+      rc = gcry_mpi_scan (&u,
+                          GCRYMPI_FMT_USG,
+                          &((const unsigned char *) (&encoding[1]))[pos],
+                          size, &size);
+      if (rc)
+        {
+          LOG_GCRY (GNUNET_ERROR_TYPE_ERROR, "gcry_mpi_scan", rc);
+          gcry_mpi_release (n);
+          gcry_mpi_release (e);
+          gcry_mpi_release (d);
+          if (p != NULL)
+            gcry_mpi_release (p);
+          if (q != NULL)
+            gcry_mpi_release (q);
+          return NULL;
+        }
+    }
+  else
+    u = NULL;
+
+  if ((p != NULL) && (q != NULL) && (u != NULL))
+    {
+      rc = gcry_sexp_build (&res, &size,        /* erroff */
+                            "(private-key(rsa(n %m)(e %m)(d %m)(p %m)(q %m)(u %m)))",
+                            n, e, d, p, q, u);
+    }
+  else
+    {
+      if ((p != NULL) && (q != NULL))
+        {
+          rc = gcry_sexp_build (&res, &size,    /* erroff */
+                                "(private-key(rsa(n %m)(e %m)(d %m)(p %m)(q %m)))",
+                                n, e, d, p, q);
+        }
+      else
+        {
+          rc = gcry_sexp_build (&res, &size,    /* erroff */
+                                "(private-key(rsa(n %m)(e %m)(d %m)))",
+                                n, e, d);
+        }
+    }
+  gcry_mpi_release (n);
+  gcry_mpi_release (e);
+  gcry_mpi_release (d);
+  if (p != NULL)
+    gcry_mpi_release (p);
+  if (q != NULL)
+    gcry_mpi_release (q);
+  if (u != NULL)
+    gcry_mpi_release (u);
+
+  if (rc)
+    LOG_GCRY (GNUNET_ERROR_TYPE_ERROR, "gcry_sexp_build", rc);
+#if EXTRA_CHECKS
+  if (gcry_pk_testkey (res))
+    {
+      LOG_GCRY (GNUNET_ERROR_TYPE_ERROR, "gcry_pk_testkey", rc);
+      return NULL;
+    }
+#endif
+  ret = GNUNET_malloc (sizeof (struct GNUNET_CRYPTO_RsaPrivateKey));
+  ret->sexp = res;
+  return ret;
+}
+
+
+/**
+ * Create a new private key by reading it from a file.  If the
+ * files does not exist, create a new key and write it to the
+ * file.  Caller must free return value.  Note that this function
+ * can not guarantee that another process might not be trying
+ * the same operation on the same file at the same time.  The
+ * caller must somehow know that the file either already exists
+ * with a valid key OR be sure that no other process is calling
+ * this function at the same time.  If the contents of the file
+ * are invalid the old file is deleted and a fresh key is
+ * created.
+ *
+ * @return new private key, NULL on error (for example,
+ *   permission denied)
+ */
+struct GNUNET_CRYPTO_RsaPrivateKey *
+GNUNET_CRYPTO_rsa_key_create_from_file (const char *filename)
+{
+  struct flock fl;
+  struct GNUNET_CRYPTO_RsaPrivateKey *ret;
+  struct RsaPrivateKeyBinaryEncoded *enc;
+  struct stat sbuf;
+  uint16_t len;
+  int fd;
+  unsigned int cnt;
+  int ec;
+
+  if (GNUNET_SYSERR == GNUNET_DISK_directory_create_for_file (filename))
+    return NULL;
+  while (0 != STAT (filename, &sbuf))
+    {
+      fd = open (filename, O_WRONLY | O_CREAT | O_EXCL, S_IRUSR | S_IWUSR);
+      if (-1 == fd)
+        {
+          if (errno == EEXIST)
+            continue;
+          GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_ERROR,
+                                    "open", filename);
+          return NULL;
+        }
+      memset (&fl, 0, sizeof (struct flock));
+      fl.l_type = F_WRLCK;
+      fl.l_whence = SEEK_SET;
+      fl.l_len = sizeof (struct RsaPrivateKeyBinaryEncoded);
+      cnt = 0;
+      while (0 != fcntl (fd, F_SETLK, &fl))
+        {
+          sleep (1);
+          if (0 == ++cnt % 10)
+            {
+              ec = errno;
+              fl.l_type = F_GETLK;
+              fcntl (fd, F_GETLK, &fl);
+              GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                          _
+                          ("Could not aquire lock on file `%s' due to process %u: %s...\n"),
+                          filename, fl.l_pid, STRERROR (errno));
+            }
+          memset (&fl, 0, sizeof (struct flock));
+          fl.l_type = F_WRLCK;
+          fl.l_whence = SEEK_SET;
+          fl.l_len = sizeof (struct RsaPrivateKeyBinaryEncoded);
+        }
+      GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                  _("Creating a new private key.  This may take a while.\n"));
+      ret = GNUNET_CRYPTO_rsa_key_create ();
+      GNUNET_assert (ret != NULL);
+      enc = rsa_encode_key (ret);
+      GNUNET_assert (enc != NULL);
+      GNUNET_assert (ntohs (enc->len) == WRITE (fd, enc, ntohs (enc->len)));
+      GNUNET_free (enc);
+      fdatasync (fd);
+      memset (&fl, 0, sizeof (struct flock));
+      fl.l_type = F_UNLCK;
+      fl.l_whence = SEEK_SET;
+      fl.l_len = sizeof (struct RsaPrivateKeyBinaryEncoded);
+      cnt = 0;
+      if (0 != fcntl (fd, F_SETLK, &fl))
+        GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING,
+                                  "fcntl", filename);
+      GNUNET_assert (0 == CLOSE (fd));
+      GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                  _("Stored new private key in `%s'.\n"), filename);
+      return ret;
+    }
+  /* hostkey file exists already, read it! */
+  fd = open (filename, O_RDONLY);
+  if (-1 == fd)
+    {
+      GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_ERROR, "open", filename);
+      return NULL;
+    }
+  cnt = 0;
+  while (1)
+    {
+      memset (&fl, 0, sizeof (struct flock));
+      fl.l_type = F_RDLCK;
+      fl.l_whence = SEEK_SET;
+      fl.l_len = sizeof (struct RsaPrivateKeyBinaryEncoded);
+      if (0 != fcntl (fd, F_SETLK, &fl))
+        {
+          if (0 == ++cnt % 10)
+            {
+              ec = errno;
+              fl.l_type = F_GETLK;
+              fcntl (fd, F_GETLK, &fl);
+              GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                          _
+                          ("Could not aquire lock on file `%s' due to process %u: %s...\n"),
+                          filename, fl.l_pid, STRERROR (errno));
+              GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                          _
+                          ("This may be ok if someone is currently generating a hostkey.\n"));
+            }
+          sleep (1);
+          continue;
+        }
+      if (0 != STAT (filename, &sbuf))
+        {
+          /* eh, what!? File we opened is now gone!? */
+          GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_ERROR,
+                                    "stat", filename);
+          memset (&fl, 0, sizeof (struct flock));
+          fl.l_type = F_UNLCK;
+          fl.l_whence = SEEK_SET;
+          fl.l_len = sizeof (struct RsaPrivateKeyBinaryEncoded);
+          if (0 != fcntl (fd, F_SETLK, &fl))
+            GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING,
+                                      "fcntl", filename);
+          GNUNET_assert (0 == CLOSE (fd));
+          return NULL;
+        }
+      if (sbuf.st_size < sizeof (struct RsaPrivateKeyBinaryEncoded))
+        {
+          /* maybe we got the read lock before the hostkey generating
+             process had a chance to get the write lock; give it up! */
+          memset (&fl, 0, sizeof (struct flock));
+          fl.l_type = F_UNLCK;
+          fl.l_whence = SEEK_SET;
+          fl.l_len = sizeof (struct RsaPrivateKeyBinaryEncoded);
+          if (0 != fcntl (fd, F_SETLK, &fl))
+            GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING,
+                                      "fcntl", filename);
+          if (0 == ++cnt % 10)
+            {
+              GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                          _
+                          ("When trying to read hostkey file `%s' I found %u bytes but I need at least %u.\n"),
+                          filename, (unsigned int) sbuf.st_size,
+                          (unsigned int) sizeof (struct
+                                                 RsaPrivateKeyBinaryEncoded));
+              GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                          _
+                          ("This may be ok if someone is currently generating a hostkey.\n"));
+            }
+          sleep (2);            /* wait a bit longer! */
+          continue;
+        }
+      break;
+    }
+  enc = GNUNET_malloc (sbuf.st_size);
+  GNUNET_assert (sbuf.st_size == READ (fd, enc, sbuf.st_size));
+  len = ntohs (enc->len);
+  if ((len != sbuf.st_size) || (NULL == (ret = rsa_decode_key (enc))))
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                  _
+                  ("File `%s' does not contain a valid private key.  You should delete it.\n"),
+                  filename);
+      GNUNET_free (enc);
+    }
+  memset (&fl, 0, sizeof (struct flock));
+  fl.l_type = F_UNLCK;
+  fl.l_whence = SEEK_SET;
+  fl.l_len = sizeof (struct RsaPrivateKeyBinaryEncoded);
+  if (0 != fcntl (fd, F_SETLK, &fl))
+    GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING, "fcntl", filename);
+  GNUNET_assert (0 == CLOSE (fd));
+  return ret;
+}
+
+
+/**
+ * Encrypt a block with the public key of another host that uses the
+ * same cyper.
+ *
+ * @param block the block to encrypt
+ * @param size the size of block
+ * @param publicKey the encoded public key used to encrypt
+ * @param target where to store the encrypted block
+ * @returns GNUNET_SYSERR on error, GNUNET_OK if ok
+ */
+int
+GNUNET_CRYPTO_rsa_encrypt (const void *block,
+                           uint16_t size,
+                           const struct
+                           GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *publicKey,
+                           struct GNUNET_CRYPTO_RsaEncryptedData *target)
+{
+  gcry_sexp_t result;
+  gcry_sexp_t data;
+  struct GNUNET_CRYPTO_RsaPrivateKey *pubkey;
+  gcry_mpi_t val;
+  gcry_mpi_t rval;
+  size_t isize;
+  size_t erroff;
+
+  GNUNET_assert (size <= sizeof (GNUNET_HashCode));
+  pubkey = public2PrivateKey (publicKey);
+  isize = size;
+  GNUNET_assert (0 ==
+                 gcry_mpi_scan (&val, GCRYMPI_FMT_USG, block, isize, &isize));
+  GNUNET_assert (0 ==
+                 gcry_sexp_build (&data, &erroff,
+                                  "(data (flags pkcs1)(value %m))", val));
+  gcry_mpi_release (val);
+  GNUNET_assert (0 == gcry_pk_encrypt (&result, data, pubkey->sexp));
+  gcry_sexp_release (data);
+  GNUNET_CRYPTO_rsa_key_free (pubkey);
+
+  GNUNET_assert (0 == key_from_sexp (&rval, result, "rsa", "a"));
+  gcry_sexp_release (result);
+  isize = sizeof (struct GNUNET_CRYPTO_RsaEncryptedData);
+  GNUNET_assert (0 == gcry_mpi_print (GCRYMPI_FMT_USG,
+                                      (unsigned char *) target, isize, &isize,
+                                      rval));
+  gcry_mpi_release (rval);
+  adjust (&target->encoding[0], isize,
+          sizeof (struct GNUNET_CRYPTO_RsaEncryptedData));
+  return GNUNET_OK;
+}
+
+/**
+ * Decrypt a given block with the hostkey.
+ *
+ * @param hostkey the hostkey with which to decrypt this block
+ * @param block the data to decrypt, encoded as returned by encrypt
+ * @param result pointer to a location where the result can be stored
+ * @param max the maximum number of bits to store for the result, if
+ *        the decrypted block is bigger, an error is returned
+ * @returns the size of the decrypted block, -1 on error
+ */
+int
+GNUNET_CRYPTO_rsa_decrypt (const struct GNUNET_CRYPTO_RsaPrivateKey *hostkey,
+                           const struct GNUNET_CRYPTO_RsaEncryptedData *block,
+                           void *result, uint16_t max)
+{
+  gcry_sexp_t resultsexp;
+  gcry_sexp_t data;
+  size_t erroff;
+  size_t size;
+  gcry_mpi_t val;
+  unsigned char *endp;
+  unsigned char *tmp;
+
+#if EXTRA_CHECKS
+  GNUNET_assert (0 == gcry_pk_testkey (hostkey->sexp));
+#endif
+  size = sizeof (struct GNUNET_CRYPTO_RsaEncryptedData);
+  GNUNET_assert (0 == gcry_mpi_scan (&val,
+                                     GCRYMPI_FMT_USG, &block->encoding[0],
+                                     size, &size));
+  GNUNET_assert (0 ==
+                 gcry_sexp_build (&data, &erroff,
+                                  "(enc-val(flags)(rsa(a %m)))", val));
+  gcry_mpi_release (val);
+  GNUNET_assert (0 == gcry_pk_decrypt (&resultsexp, data, hostkey->sexp));
+  gcry_sexp_release (data);
+  /* resultsexp has format "(value %m)" */
+  GNUNET_assert (NULL !=
+                 (val = gcry_sexp_nth_mpi (resultsexp, 1, GCRYMPI_FMT_USG)));
+  gcry_sexp_release (resultsexp);
+  tmp = GNUNET_malloc (max + HOSTKEY_LEN / 8);
+  size = max + HOSTKEY_LEN / 8;
+  GNUNET_assert (0 ==
+                 gcry_mpi_print (GCRYMPI_FMT_USG, tmp, size, &size, val));
+  gcry_mpi_release (val);
+  endp = tmp;
+  endp += (size - max);
+  size = max;
+  memcpy (result, endp, size);
+  GNUNET_free (tmp);
+  return size;
+}
+
+
+/**
+ * Sign a given block.
+ *
+ * @param hostkey private key to use for the signing
+ * @param purpose what to sign (size, purpose)
+ * @param result where to write the signature
+ * @return GNUNET_SYSERR on error, GNUNET_OK on success
+ */
+int
+GNUNET_CRYPTO_rsa_sign (const struct GNUNET_CRYPTO_RsaPrivateKey *hostkey,
+                        const struct GNUNET_CRYPTO_RsaSignaturePurpose
+                        *purpose, struct GNUNET_CRYPTO_RsaSignature *sig)
+{
+  gcry_sexp_t result;
+  gcry_sexp_t data;
+  size_t ssize;
+  gcry_mpi_t rval;
+  GNUNET_HashCode hc;
+  char *buff;
+  int bufSize;
+
+  GNUNET_CRYPTO_hash (purpose, ntohl (purpose->size), &hc);
+#define FORMATSTRING "(4:data(5:flags5:pkcs1)(4:hash6:sha51264:0123456789012345678901234567890123456789012345678901234567890123))"
+  bufSize = strlen (FORMATSTRING) + 1;
+  buff = GNUNET_malloc (bufSize);
+  memcpy (buff, FORMATSTRING, bufSize);
+  memcpy (&buff
+          [bufSize -
+           strlen
+           ("0123456789012345678901234567890123456789012345678901234567890123))")
+           - 1], &hc, sizeof (GNUNET_HashCode));
+  GNUNET_assert (0 == gcry_sexp_new (&data, buff, bufSize, 0));
+  GNUNET_free (buff);
+  GNUNET_assert (0 == gcry_pk_sign (&result, data, hostkey->sexp));
+  gcry_sexp_release (data);
+  GNUNET_assert (0 == key_from_sexp (&rval, result, "rsa", "s"));
+  gcry_sexp_release (result);
+  ssize = sizeof (struct GNUNET_CRYPTO_RsaSignature);
+  GNUNET_assert (0 == gcry_mpi_print (GCRYMPI_FMT_USG,
+                                      (unsigned char *) sig, ssize, &ssize,
+                                      rval));
+  gcry_mpi_release (rval);
+  adjust (sig->sig, ssize, sizeof (struct GNUNET_CRYPTO_RsaSignature));
+  return GNUNET_OK;
+}
+
+
+/**
+ * Verify signature.
+ *
+ * @param purpose what is the purpose that the signature should have?
+ * @param validate block to validate (size, purpose, data)
+ * @param sig signature that is being validated
+ * @param publicKey public key of the signer
+ * @returns GNUNET_OK if ok, GNUNET_SYSERR if invalid
+ */
+int
+GNUNET_CRYPTO_rsa_verify (uint32_t purpose,
+                          const struct GNUNET_CRYPTO_RsaSignaturePurpose
+                          *validate,
+                          const struct GNUNET_CRYPTO_RsaSignature *sig,
+                          const struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded
+                          *publicKey)
+{
+  gcry_sexp_t data;
+  gcry_sexp_t sigdata;
+  size_t size;
+  gcry_mpi_t val;
+  struct GNUNET_CRYPTO_RsaPrivateKey *hostkey;
+  GNUNET_HashCode hc;
+  char *buff;
+  int bufSize;
+  size_t erroff;
+  int rc;
+
+  if (purpose != ntohl (validate->purpose))
+    return GNUNET_SYSERR;       /* purpose mismatch */
+  GNUNET_CRYPTO_hash (validate, ntohl (validate->size), &hc);
+  size = sizeof (struct GNUNET_CRYPTO_RsaSignature);
+  GNUNET_assert (0 == gcry_mpi_scan (&val,
+                                     GCRYMPI_FMT_USG,
+                                     (const unsigned char *) sig, size,
+                                     &size));
+  GNUNET_assert (0 ==
+                 gcry_sexp_build (&sigdata, &erroff, "(sig-val(rsa(s %m)))",
+                                  val));
+  gcry_mpi_release (val);
+  bufSize = strlen (FORMATSTRING) + 1;
+  buff = GNUNET_malloc (bufSize);
+  memcpy (buff, FORMATSTRING, bufSize);
+  memcpy (&buff[strlen (FORMATSTRING) -
+                strlen
+                ("0123456789012345678901234567890123456789012345678901234567890123))")],
+          &hc, sizeof (GNUNET_HashCode));
+  GNUNET_assert (0 == gcry_sexp_new (&data, buff, bufSize, 0));
+  GNUNET_free (buff);
+  hostkey = public2PrivateKey (publicKey);
+  if (hostkey == NULL)
+    {
+      gcry_sexp_release (data);
+      gcry_sexp_release (sigdata);
+      return GNUNET_SYSERR;
+    }
+  rc = gcry_pk_verify (sigdata, data, hostkey->sexp);
+  GNUNET_CRYPTO_rsa_key_free (hostkey);
+  gcry_sexp_release (data);
+  gcry_sexp_release (sigdata);
+  if (rc)
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                  _("RSA signature verification failed at %s:%d: %s\n"),
+                  __FILE__, __LINE__, gcry_strerror (rc));
+      return GNUNET_SYSERR;
+    }
+  return GNUNET_OK;
+}
+
+
+/* end of crypto_rsa.c */
diff --git a/src/util/disk.c b/src/util/disk.c
new file mode 100644
index 000000000..f0fe9341b
--- /dev/null
+++ b/src/util/disk.c
@@ -0,0 +1,954 @@
+/*
+     This file is part of GNUnet.
+     (C) 2001, 2002, 2005, 2006 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 util/disk.c
+ * @brief disk IO convenience methods
+ * @author Christian Grothoff
+ */
+
+#include "platform.h"
+#include "gnunet_common.h"
+#include "gnunet_directories.h"
+#include "gnunet_disk_lib.h"
+#include "gnunet_scheduler_lib.h"
+#include "gnunet_strings_lib.h"
+
+
+#if LINUX || CYGWIN
+#include <sys/vfs.h>
+#else
+#ifdef SOMEBSD
+#include <sys/param.h>
+#include <sys/mount.h>
+#else
+#ifdef OSX
+#include <sys/param.h>
+#include <sys/mount.h>
+#else
+#ifdef SOLARIS
+#include <sys/types.h>
+#include <sys/statvfs.h>
+#else
+#ifdef MINGW
+#define         _IFMT           0170000 /* type of file */
+#define         _IFLNK          0120000 /* symbolic link */
+#define  S_ISLNK(m)     (((m)&_IFMT) == _IFLNK)
+#else
+#error PORT-ME: need to port statfs (how much space is left on the drive?)
+#endif
+#endif
+#endif
+#endif
+#endif
+
+#ifndef SOMEBSD
+#ifndef WINDOWS
+#ifndef OSX
+#include <wordexp.h>
+#endif
+#endif
+#endif
+
+typedef struct
+{
+  unsigned long long total;
+  int include_sym_links;
+} GetFileSizeData;
+
+static int
+getSizeRec (void *ptr, const char *fn)
+{
+  GetFileSizeData *gfsd = ptr;
+#ifdef HAVE_STAT64
+  struct stat64 buf;
+#else
+  struct stat buf;
+#endif
+
+#ifdef HAVE_STAT64
+  if (0 != STAT64 (fn, &buf))
+    {
+      GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING, "stat64", fn);
+      return GNUNET_SYSERR;
+    }
+#else
+  if (0 != STAT (fn, &buf))
+    {
+      GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING, "stat", fn);
+      return GNUNET_SYSERR;
+    }
+#endif
+  if ((!S_ISLNK (buf.st_mode)) || (gfsd->include_sym_links == GNUNET_YES))
+    gfsd->total += buf.st_size;
+  if ((S_ISDIR (buf.st_mode)) &&
+      (0 == ACCESS (fn, X_OK)) &&
+      ((!S_ISLNK (buf.st_mode)) || (gfsd->include_sym_links == GNUNET_YES)))
+    {
+      if (GNUNET_SYSERR == GNUNET_DISK_directory_scan (fn, &getSizeRec, gfsd))
+        return GNUNET_SYSERR;
+    }
+  return GNUNET_OK;
+}
+
+/**
+ * Get the size of the file (or directory)
+ * of the given file (in bytes).
+ *
+ * @return GNUNET_SYSERR on error, GNUNET_OK on success
+ */
+int
+GNUNET_DISK_file_size (const char *filename,
+                       unsigned long long *size, int includeSymLinks)
+{
+  GetFileSizeData gfsd;
+  int ret;
+
+  GNUNET_assert (size != NULL);
+  gfsd.total = 0;
+  gfsd.include_sym_links = includeSymLinks;
+  ret = getSizeRec (&gfsd, filename);
+  *size = gfsd.total;
+  return ret;
+}
+
+/**
+ * Get the number of blocks that are left on the partition that
+ * contains the given file (for normal users).
+ *
+ * @param part a file on the partition to check
+ * @return -1 on errors, otherwise the number of free blocks
+ */
+long
+GNUNET_DISK_get_blocks_available (const char *part)
+{
+#ifdef SOLARIS
+  struct statvfs buf;
+
+  if (0 != statvfs (part, &buf))
+    {
+      GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING, "statfs", part);
+      return -1;
+    }
+  return buf.f_bavail;
+#elif MINGW
+  DWORD dwDummy;
+  DWORD dwBlocks;
+  char szDrive[4];
+
+  memcpy (szDrive, part, 3);
+  szDrive[3] = 0;
+  if (!GetDiskFreeSpace (szDrive, &dwDummy, &dwDummy, &dwBlocks, &dwDummy))
+    {
+      GNUNET_GE_LOG (GNUNET_ERROR_TYPE_WARNING,
+                     _("`%s' failed for drive `%s': %u\n"),
+                     "GetDiskFreeSpace", szDrive, GetLastError ());
+
+      return -1;
+    }
+  return dwBlocks;
+#else
+  struct statfs s;
+  if (0 != statfs (part, &s))
+    {
+      GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING, "statfs", part);
+      return -1;
+    }
+  return s.f_bavail;
+#endif
+}
+
+/**
+ * Test if fil is a directory.
+ *
+ * @return GNUNET_YES if yes, GNUNET_NO if not, GNUNET_SYSERR if it
+ *   does not exist
+ */
+int
+GNUNET_DISK_directory_test (const char *fil)
+{
+  struct stat filestat;
+  int ret;
+
+  ret = STAT (fil, &filestat);
+  if (ret != 0)
+    {
+      if (errno != ENOENT)
+        {
+          GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING, "stat", fil);
+          return GNUNET_SYSERR;
+        }
+      return GNUNET_NO;
+    }
+  if (!S_ISDIR (filestat.st_mode))
+    return GNUNET_NO;
+  if (ACCESS (fil, R_OK | X_OK) < 0)
+    {
+      GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING, "access", fil);
+      return GNUNET_SYSERR;
+    }
+  return GNUNET_YES;
+}
+
+/**
+ * Check that fil corresponds to a filename
+ * (of a file that exists and that is not a directory).
+ * @returns GNUNET_YES if yes, GNUNET_NO if not a file, GNUNET_SYSERR if something
+ * else (will print an error message in that case, too).
+ */
+int
+GNUNET_DISK_file_test (const char *fil)
+{
+  struct stat filestat;
+  int ret;
+  char *rdir;
+
+  rdir = GNUNET_STRINGS_filename_expand (fil);
+  if (rdir == NULL)
+    return GNUNET_SYSERR;
+
+  ret = STAT (rdir, &filestat);
+  if (ret != 0)
+    {
+      if (errno != ENOENT)
+        {
+          GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING, "stat", rdir);
+          GNUNET_free (rdir);
+          return GNUNET_SYSERR;
+        }
+      GNUNET_free (rdir);
+      return GNUNET_NO;
+    }
+  if (!S_ISREG (filestat.st_mode))
+    {
+      GNUNET_free (rdir);
+      return GNUNET_NO;
+    }
+  if (ACCESS (rdir, R_OK) < 0)
+    {
+      GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING, "access", rdir);
+      GNUNET_free (rdir);
+      return GNUNET_SYSERR;
+    }
+  GNUNET_free (rdir);
+  return GNUNET_YES;
+}
+
+/**
+ * Implementation of "mkdir -p"
+ * @param dir the directory to create
+ * @returns GNUNET_OK on success, GNUNET_SYSERR on failure
+ */
+int
+GNUNET_DISK_directory_create (const char *dir)
+{
+  char *rdir;
+  int len;
+  int pos;
+  int ret = GNUNET_OK;
+
+  rdir = GNUNET_STRINGS_filename_expand (dir);
+  if (rdir == NULL)
+    return GNUNET_SYSERR;
+
+  len = strlen (rdir);
+#ifndef MINGW
+  pos = 1;                      /* skip heading '/' */
+#else
+  /* Local or Network path? */
+  if (strncmp (rdir, "\\\\", 2) == 0)
+    {
+      pos = 2;
+      while (rdir[pos])
+        {
+          if (rdir[pos] == '\\')
+            {
+              pos++;
+              break;
+            }
+          pos++;
+        }
+    }
+  else
+    {
+      pos = 3;                  /* strlen("C:\\") */
+    }
+#endif
+  while (pos <= len)
+    {
+      if ((rdir[pos] == DIR_SEPARATOR) || (pos == len))
+        {
+          rdir[pos] = '\0';
+          ret = GNUNET_DISK_directory_test (rdir);
+          if (ret == GNUNET_SYSERR)
+            {
+              GNUNET_free (rdir);
+              return GNUNET_SYSERR;
+            }
+          if (ret == GNUNET_NO)
+            {
+#ifndef MINGW
+              ret = mkdir (rdir, S_IRUSR | S_IWUSR | S_IXUSR | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH);  /* 755 */
+#else
+              ret = mkdir (rdir);
+#endif
+              if ((ret != 0) && (errno != EEXIST))
+                {
+                  GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_ERROR, "mkdir",
+                                            rdir);
+                  GNUNET_free (rdir);
+                  return GNUNET_SYSERR;
+                }
+            }
+          rdir[pos] = DIR_SEPARATOR;
+        }
+      pos++;
+    }
+  GNUNET_free (rdir);
+  return GNUNET_OK;
+}
+
+
+/**
+ * Create the directory structure for storing
+ * a file.
+ *
+ * @param filename name of a file in the directory
+ * @returns GNUNET_OK on success,
+ *          GNUNET_SYSERR on failure,
+ *          GNUNET_NO if the directory
+ *          exists but is not writeable for us
+ */
+int
+GNUNET_DISK_directory_create_for_file (const char *dir)
+{
+  char *rdir;
+  int len;
+  int ret;
+
+  rdir = GNUNET_STRINGS_filename_expand (dir);
+  if (rdir == NULL)
+    return GNUNET_SYSERR;
+  len = strlen (rdir);
+  while ((len > 0) && (rdir[len] != DIR_SEPARATOR))
+    len--;
+  rdir[len] = '\0';
+  ret = GNUNET_DISK_directory_create (rdir);
+  if ((ret == GNUNET_OK) && (0 != ACCESS (rdir, W_OK)))
+    ret = GNUNET_NO;
+  GNUNET_free (rdir);
+  return ret;
+}
+
+/**
+ * Read the contents of a binary file into a buffer.
+ * @param fileName the name of the file, not freed,
+ *        must already be expanded!
+ * @param len the maximum number of bytes to read
+ * @param result the buffer to write the result to
+ * @return the number of bytes read on success, -1 on failure
+ */
+int
+GNUNET_DISK_file_read (const char *fileName, int len, void *result)
+{
+  /* open file, must exist, open read only */
+  int handle;
+  int size;
+
+  GNUNET_assert (fileName != NULL);
+  GNUNET_assert (len > 0);
+  if (len == 0)
+    return 0;
+  GNUNET_assert (result != NULL);
+  handle = GNUNET_DISK_file_open (fileName, O_RDONLY, S_IRUSR);
+  if (handle < 0)
+    return -1;
+  size = READ (handle, result, len);
+  GNUNET_DISK_file_close (fileName, handle);
+  return size;
+}
+
+
+/**
+ * Convert string to value ('755' for chmod-call)
+ */
+static int
+atoo (const char *s)
+{
+  int n = 0;
+
+  while (('0' <= *s) && (*s < '8'))
+    {
+      n <<= 3;
+      n += *s++ - '0';
+    }
+  return n;
+}
+
+/**
+ * Write a buffer to a file.
+ * @param fileName the name of the file, NOT freed!
+ * @param buffer the data to write
+ * @param n number of bytes to write
+ * @param mode permissions to set on the file
+ * @return GNUNET_OK on success, GNUNET_SYSERR on error
+ */
+int
+GNUNET_DISK_file_write (const char *fileName,
+                        const void *buffer, unsigned int n, const char *mode)
+{
+  int handle;
+  char *fn;
+
+  /* open file, open with 600, create if not
+     present, otherwise overwrite */
+  GNUNET_assert (fileName != NULL);
+  fn = GNUNET_STRINGS_filename_expand (fileName);
+  handle = GNUNET_DISK_file_open (fn, O_CREAT | O_WRONLY, S_IRUSR | S_IWUSR);
+  if (handle == -1)
+    {
+      GNUNET_free (fn);
+      return GNUNET_SYSERR;
+    }
+  GNUNET_assert ((n == 0) || (buffer != NULL));
+  /* write the buffer take length from the beginning */
+  if (n != WRITE (handle, buffer, n))
+    {
+      GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING, "write", fn);
+      GNUNET_DISK_file_close (fn, handle);
+      GNUNET_free (fn);
+      return GNUNET_SYSERR;
+    }
+  GNUNET_DISK_file_close (fn, handle);
+  if (0 != CHMOD (fn, atoo (mode)))
+    {
+      GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING, "chmod", fn);
+    }
+  GNUNET_free (fn);
+  return GNUNET_OK;
+}
+
+/**
+ * Scan a directory for files. The name of the directory
+ * must be expanded first (!).
+ * @param dirName the name of the directory
+ * @param callback the method to call for each file,
+ *        can be NULL, in that case, we only count
+ * @param data argument to pass to callback
+ * @return the number of files found, GNUNET_SYSERR on error or
+ *         ieration aborted by callback returning GNUNET_SYSERR
+ */
+int
+GNUNET_DISK_directory_scan (const char *dirName,
+                            GNUNET_FileNameCallback callback, void *data)
+{
+  DIR *dinfo;
+  struct dirent *finfo;
+  struct stat istat;
+  int count = 0;
+  char *name;
+  char *dname;
+  unsigned int name_len;
+  unsigned int n_size;
+
+  GNUNET_assert (dirName != NULL);
+  dname = GNUNET_STRINGS_filename_expand (dirName);
+  while ((strlen (dname) > 0) && (dname[strlen (dname) - 1] == DIR_SEPARATOR))
+    dname[strlen (dname) - 1] = '\0';
+  if (0 != STAT (dname, &istat))
+    {
+      GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING, "stat", dname);
+      GNUNET_free (dname);
+      return GNUNET_SYSERR;
+    }
+  if (!S_ISDIR (istat.st_mode))
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                  _("Expected `%s' to be a directory!\n"), dirName);
+      GNUNET_free (dname);
+      return GNUNET_SYSERR;
+    }
+  errno = 0;
+  dinfo = OPENDIR (dname);
+  if ((errno == EACCES) || (dinfo == NULL))
+    {
+      GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING, "opendir", dname);
+      if (dinfo != NULL)
+        closedir (dinfo);
+      GNUNET_free (dname);
+      return GNUNET_SYSERR;
+    }
+  name_len = 256;
+  n_size = strlen (dname) + name_len + 2;
+  name = GNUNET_malloc (n_size);
+  while ((finfo = readdir (dinfo)) != NULL)
+    {
+      if ((0 == strcmp (finfo->d_name, ".")) ||
+          (0 == strcmp (finfo->d_name, "..")))
+        continue;
+      if (callback != NULL)
+        {
+          if (name_len < strlen (finfo->d_name))
+            {
+              GNUNET_free (name);
+              name_len = strlen (finfo->d_name);
+              n_size = strlen (dname) + name_len + 2;
+              name = GNUNET_malloc (n_size);
+            }
+          /* dname can end in "/" only if dname == "/";
+             if dname does not end in "/", we need to add
+             a "/" (otherwise, we must not!) */
+          GNUNET_snprintf (name,
+                           n_size,
+                           "%s%s%s",
+                           dname,
+                           (strcmp (dname, DIR_SEPARATOR_STR) ==
+                            0) ? "" : DIR_SEPARATOR_STR, finfo->d_name);
+          if (GNUNET_OK != callback (data, name))
+            {
+              closedir (dinfo);
+              GNUNET_free (name);
+              GNUNET_free (dname);
+              return GNUNET_SYSERR;
+            }
+        }
+      count++;
+    }
+  closedir (dinfo);
+  GNUNET_free (name);
+  GNUNET_free (dname);
+  return count;
+}
+
+
+/**
+ * Opaque handle used for iterating over a directory.
+ */
+struct GNUNET_DISK_DirectoryIterator
+{
+  /**
+   * Our scheduler.
+   */
+  struct GNUNET_SCHEDULER_Handle *sched;
+
+  /**
+   * Function to call on directory entries.
+   */
+  GNUNET_DISK_DirectoryIteratorCallback callback;
+
+  /**
+   * Closure for callback.
+   */
+  void *callback_cls;
+
+  /**
+   * Reference to directory.
+   */
+  DIR *directory;
+
+  /**
+   * Directory name.
+   */
+  char *dirname;
+
+  /**
+   * Next filename to process.
+   */
+  char *next_name;
+
+  /**
+   * Our priority.
+   */
+  enum GNUNET_SCHEDULER_Priority priority;
+
+};
+
+
+/**
+ * Task used by the directory iterator.
+ */
+static void
+directory_iterator_task (void *cls,
+                         const struct GNUNET_SCHEDULER_TaskContext *tc)
+{
+  struct GNUNET_DISK_DirectoryIterator *iter = cls;
+  char *name;
+
+  name = iter->next_name;
+  GNUNET_assert (name != NULL);
+  iter->next_name = NULL;
+  iter->callback (iter->callback_cls, iter, name, iter->dirname);
+  GNUNET_free (name);
+}
+
+
+/**
+ * This function must be called during the DiskIteratorCallback
+ * (exactly once) to schedule the task to process the next
+ * filename in the directory (if there is one).
+ *
+ * @param iter opaque handle for the iterator
+ * @param can set to GNUNET_YES to terminate the iteration early
+ * @return GNUNET_YES if iteration will continue,
+ *         GNUNET_NO if this was the last entry (and iteration is complete),
+ *         GNUNET_SYSERR if abort was YES
+ */
+int
+GNUNET_DISK_directory_iterator_next (struct GNUNET_DISK_DirectoryIterator
+                                     *iter, int can)
+{
+  struct dirent *finfo;
+
+  GNUNET_assert (iter->next_name == NULL);
+  if (can == GNUNET_YES)
+    {
+      closedir (iter->directory);
+      GNUNET_free (iter->dirname);
+      GNUNET_free (iter);
+      return GNUNET_SYSERR;
+    }
+  while (NULL != (finfo = readdir (iter->directory)))
+    {
+      if ((0 == strcmp (finfo->d_name, ".")) ||
+          (0 == strcmp (finfo->d_name, "..")))
+        continue;
+      GNUNET_asprintf (&iter->next_name,
+                       "%s%s%s",
+                       iter->dirname, DIR_SEPARATOR_STR, finfo->d_name);
+      break;
+    }
+  if (finfo == NULL)
+    {
+      GNUNET_DISK_directory_iterator_next (iter, GNUNET_YES);
+      return GNUNET_NO;
+    }
+  GNUNET_SCHEDULER_add_after (iter->sched,
+                              GNUNET_YES,
+                              iter->priority,
+                              GNUNET_SCHEDULER_NO_PREREQUISITE_TASK,
+                              &directory_iterator_task, iter);
+  return GNUNET_YES;
+}
+
+
+/**
+ * Scan a directory for files using the scheduler to run a task for
+ * each entry.  The name of the directory must be expanded first (!).
+ * If a scheduler does not need to be used, GNUNET_DISK_directory_scan
+ * may provide a simpler API.
+ *
+ * @param sched scheduler to use
+ * @param prio priority to use
+ * @param dirName the name of the directory
+ * @param callback the method to call for each file
+ * @param callback_cls closure for callback
+ */
+void
+GNUNET_DISK_directory_iterator_start (struct GNUNET_SCHEDULER_Handle *sched,
+                                      enum GNUNET_SCHEDULER_Priority prio,
+                                      const char *dirName,
+                                      GNUNET_DISK_DirectoryIteratorCallback
+                                      callback, void *callback_cls)
+{
+  struct GNUNET_DISK_DirectoryIterator *di;
+
+  di = GNUNET_malloc (sizeof (struct GNUNET_DISK_DirectoryIterator));
+  di->sched = sched;
+  di->callback = callback;
+  di->callback_cls = callback_cls;
+  di->directory = OPENDIR (dirName);
+  di->dirname = GNUNET_strdup (dirName);
+  di->priority = prio;
+  GNUNET_DISK_directory_iterator_next (di, GNUNET_NO);
+}
+
+
+static int
+remove_helper (void *unused, const char *fn)
+{
+  GNUNET_DISK_directory_remove (fn);
+  return GNUNET_OK;
+}
+
+/**
+ * Remove all files in a directory (rm -rf). Call with
+ * caution.
+ *
+ *
+ * @param fileName the file to remove
+ * @return GNUNET_OK on success, GNUNET_SYSERR on error
+ */
+int
+GNUNET_DISK_directory_remove (const char *fileName)
+{
+  struct stat istat;
+
+  if (0 != LSTAT (fileName, &istat))
+    return GNUNET_NO;           /* file may not exist... */
+  if (UNLINK (fileName) == 0)
+    return GNUNET_OK;
+  if ((errno != EISDIR) &&
+      /* EISDIR is not sufficient in all cases, e.g.
+         sticky /tmp directory may result in EPERM on BSD.
+         So we also explicitly check "isDirectory" */
+      (GNUNET_YES != GNUNET_DISK_directory_test (fileName)))
+    {
+      GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING, "rmdir", fileName);
+      return GNUNET_SYSERR;
+    }
+  if (GNUNET_SYSERR ==
+      GNUNET_DISK_directory_scan (fileName, remove_helper, NULL))
+    return GNUNET_SYSERR;
+  if (0 != RMDIR (fileName))
+    {
+      GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING, "rmdir", fileName);
+      return GNUNET_SYSERR;
+    }
+  return GNUNET_OK;
+}
+
+void
+GNUNET_DISK_file_close (const char *filename, int fd)
+{
+  if (0 != CLOSE (fd))
+    GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING, "close", filename);
+}
+
+int
+GNUNET_DISK_file_open (const char *filename, int oflag, ...)
+{
+  char *fn;
+  int mode;
+  int ret;
+#ifdef MINGW
+  char szFile[_MAX_PATH + 1];
+  long lRet;
+
+  if ((lRet = plibc_conv_to_win_path (filename, szFile)) != ERROR_SUCCESS)
+    {
+      errno = ENOENT;
+      SetLastError (lRet);
+      GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING,
+                                "plibc_conv_to_win_path", filename);
+      return -1;
+    }
+  fn = GNUNET_strdup (szFile);
+#else
+  fn = GNUNET_STRINGS_filename_expand (filename);
+#endif
+  if (oflag & O_CREAT)
+    {
+      va_list arg;
+      va_start (arg, oflag);
+      mode = va_arg (arg, int);
+      va_end (arg);
+    }
+  else
+    {
+      mode = 0;
+    }
+#ifdef MINGW
+  /* set binary mode */
+  oflag |= O_BINARY;
+#endif
+  ret = OPEN (fn, oflag, mode);
+  if (ret == -1)
+    GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING, "open", fn);
+  GNUNET_free (fn);
+  return ret;
+}
+
+#define COPY_BLK_SIZE 65536
+
+/**
+ * Copy a file.
+ * @return GNUNET_OK on success, GNUNET_SYSERR on error
+ */
+int
+GNUNET_DISK_file_copy (const char *src, const char *dst)
+{
+  char *buf;
+  unsigned long long pos;
+  unsigned long long size;
+  unsigned long long len;
+  int in;
+  int out;
+
+  if (GNUNET_OK != GNUNET_DISK_file_size (src, &size, GNUNET_YES))
+    return GNUNET_SYSERR;
+  pos = 0;
+  in = GNUNET_DISK_file_open (src, O_RDONLY | O_LARGEFILE);
+  if (in == -1)
+    return GNUNET_SYSERR;
+  out = GNUNET_DISK_file_open (dst,
+                               O_LARGEFILE | O_WRONLY | O_CREAT | O_EXCL,
+                               S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP);
+  if (out == -1)
+    {
+      GNUNET_DISK_file_close (src, in);
+      return GNUNET_SYSERR;
+    }
+  buf = GNUNET_malloc (COPY_BLK_SIZE);
+  while (pos < size)
+    {
+      len = COPY_BLK_SIZE;
+      if (len > size - pos)
+        len = size - pos;
+      if (len != READ (in, buf, len))
+        goto FAIL;
+      if (len != WRITE (out, buf, len))
+        goto FAIL;
+      pos += len;
+    }
+  GNUNET_free (buf);
+  GNUNET_DISK_file_close (src, in);
+  GNUNET_DISK_file_close (dst, out);
+  return GNUNET_OK;
+FAIL:
+  GNUNET_free (buf);
+  GNUNET_DISK_file_close (src, in);
+  GNUNET_DISK_file_close (dst, out);
+  return GNUNET_SYSERR;
+}
+
+
+/**
+ * @brief Removes special characters as ':' from a filename.
+ * @param fn the filename to canonicalize
+ */
+void
+GNUNET_DISK_filename_canonicalize (char *fn)
+{
+  char *idx;
+  char c;
+
+  idx = fn;
+  while (*idx)
+    {
+      c = *idx;
+
+      if (c == '/' || c == '\\' || c == ':' || c == '*' || c == '?' ||
+          c == '"' || c == '<' || c == '>' || c == '|')
+        {
+          *idx = '_';
+        }
+
+      idx++;
+    }
+}
+
+
+
+/**
+ * @brief Change owner of a file
+ */
+int
+GNUNET_DISK_file_change_owner (const char *filename, const char *user)
+{
+#ifndef MINGW
+  struct passwd *pws;
+
+  pws = getpwnam (user);
+  if (pws == NULL)
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                  _("Cannot obtain information about user `%s': %s\n"),
+                  user, STRERROR (errno));
+      return GNUNET_SYSERR;
+    }
+  if (0 != chown (filename, pws->pw_uid, pws->pw_gid))
+    GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING, "chown", filename);
+#endif
+  return GNUNET_OK;
+}
+
+
+/**
+ * Construct full path to a file inside of the private
+ * directory used by GNUnet.  Also creates the corresponding
+ * directory.  If the resulting name is supposed to be
+ * a directory, end the last argument in '/' (or pass
+ * DIR_SEPARATOR_STR as the last argument before NULL).
+ *
+ * @param serviceName name of the service
+ * @param varargs is NULL-terminated list of
+ *                path components to append to the
+ *                private directory name.
+ * @return the constructed filename
+ */
+char *
+GNUNET_DISK_get_home_filename (struct GNUNET_CONFIGURATION_Handle *cfg,
+                               const char *serviceName, ...)
+{
+  const char *c;
+  char *pfx;
+  char *ret;
+  va_list ap;
+  unsigned int needed;
+
+  if (GNUNET_OK !=
+      GNUNET_CONFIGURATION_get_value_filename (cfg,
+                                               serviceName, "HOME", &pfx))
+    return NULL;
+  if (pfx == NULL)
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                  _("No `%s' specified for service `%s' in configuration.\n"),
+                  "HOME", serviceName);
+      return NULL;
+    }
+  needed = strlen (pfx) + 2;
+  if ((pfx[strlen (pfx) - 1] != '/') && (pfx[strlen (pfx) - 1] != '\\'))
+    needed++;
+  va_start (ap, serviceName);
+  while (1)
+    {
+      c = va_arg (ap, const char *);
+      if (c == NULL)
+        break;
+      needed += strlen (c);
+      if ((c[strlen (c) - 1] != '/') && (c[strlen (c) - 1] != '\\'))
+        needed++;
+    }
+  va_end (ap);
+  ret = GNUNET_malloc (needed);
+  strcpy (ret, pfx);
+  GNUNET_free (pfx);
+  va_start (ap, serviceName);
+  while (1)
+    {
+      c = va_arg (ap, const char *);
+      if (c == NULL)
+        break;
+      if ((c[strlen (c) - 1] != '/') && (c[strlen (c) - 1] != '\\'))
+        strcat (ret, DIR_SEPARATOR_STR);
+      strcat (ret, c);
+    }
+  va_end (ap);
+  if ((ret[strlen (ret) - 1] != '/') && (ret[strlen (ret) - 1] != '\\'))
+    GNUNET_DISK_directory_create_for_file (ret);
+  else
+    GNUNET_DISK_directory_create (ret);
+  return ret;
+}
+
+
+
+/* end of disk.c */
diff --git a/src/util/getopt.c b/src/util/getopt.c
new file mode 100644
index 000000000..e069e76f7
--- /dev/null
+++ b/src/util/getopt.c
@@ -0,0 +1,1077 @@
+/* Getopt for GNU.
+   NOTE: getopt is now part of the C library, so if you don't know what
+   "Keep this file name-space clean" means, talk to roland@gnu.ai.mit.edu
+   before changing it!
+
+   Copyright (C) 1987, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97
+     Free Software Foundation, Inc.
+
+NOTE: The canonical source of this file is maintained with the GNU C Library.
+Bugs can be reported to bug-glibc@prep.ai.mit.edu.
+
+This program 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.
+
+This program 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 this program; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
+USA.
+
+
+This code was heavily modified for GNUnet.
+Copyright (C) 2006 Christian Grothoff
+*/
+
+/**
+ * @file util/getopt.c
+ * @brief GNU style option parsing
+ *
+ * TODO: get rid of statics (make reentrant) and
+ * replace main GNU getopt parser with one that
+ * actually fits our API.
+ */
+
+#include "platform.h"
+#include "gnunet_common.h"
+#include "gnunet_getopt_lib.h"
+
+#ifdef VMS
+# include <unixlib.h>
+# if HAVE_STRING_H - 0
+#  include <string.h>
+# endif
+#endif
+
+#if defined (WIN32) && !defined (__CYGWIN32__)
+/* It's not Unix, really.  See?  Capital letters.  */
+# include <windows.h>
+# define getpid() GetCurrentProcessId()
+#endif
+
+#ifndef _
+/* This is for other GNU distributions with internationalized messages.
+   When compiling libc, the _ macro is predefined.  */
+# ifdef HAVE_LIBINTL_H
+#  include <libintl.h>
+#  define _(msgid)  gettext (msgid)
+# else
+#  define _(msgid)  (msgid)
+# endif
+#endif
+
+/* Describe the long-named options requested by the application.
+   The LONG_OPTIONS argument to getopt_long or getopt_long_only is a vector
+   of `struct GNoption' terminated by an element containing a name which is
+   zero.
+
+   The field `has_arg' is:
+   no_argument          (or 0) if the option does not take an argument,
+   required_argument  (or 1) if the option requires an argument,
+   optional_argument   (or 2) if the option takes an optional argument.
+
+   If the field `flag' is not NULL, it points to a variable that is set
+   to the value given in the field `val' when the option is found, but
+   left unchanged if the option is not found.
+
+   To have a long-named option do something other than set an `int' to
+   a compiled-in constant, such as set a value from `GNoptarg', set the
+   option's `flag' field to zero and its `val' field to a nonzero
+   value (the equivalent single-letter option character, if there is
+   one).  For long options that have a zero `flag' field, `getopt'
+   returns the contents of the `val' field.  */
+
+struct GNoption
+{
+  const char *name;
+  /* has_arg can't be an enum because some compilers complain about
+     type mismatches in all the code that assumes it is an int.  */
+  int has_arg;
+  int *flag;
+  int val;
+};
+
+
+/* This version of `getopt' appears to the caller like standard Unix `getopt'
+   but it behaves differently for the user, since it allows the user
+   to intersperse the options with the other arguments.
+
+   As `getopt' works, it permutes the elements of ARGV so that,
+   when it is done, all the options precede everything else.  Thus
+   all application programs are extended to handle flexible argument order.
+
+   Setting the environment variable POSIXLY_CORRECT disables permutation.
+   Then the behavior is completely standard.
+
+   GNU application programs can use a third alternative mode in which
+   they can distinguish the relative order of options and other arguments.  */
+
+/* For communication from `getopt' to the caller.
+   When `getopt' finds an option that takes an argument,
+   the argument value is returned here.
+   Also, when `ordering' is RETURN_IN_ORDER,
+   each non-option ARGV-element is returned here.  */
+
+static char *GNoptarg = NULL;
+
+/* Index in ARGV of the next element to be scanned.
+   This is used for communication to and from the caller
+   and for communication between successive calls to `getopt'.
+
+   On entry to `getopt', zero means this is the first call; initialize.
+
+   When `getopt' returns -1, this is the index of the first of the
+   non-option elements that the caller should itself scan.
+
+   Otherwise, `GNoptind' communicates from one call to the next
+   how much of ARGV has been scanned so far.  */
+
+/* 1003.2 says this must be 1 before any call.  */
+static int GNoptind = 1;
+
+/* Formerly, initialization of getopt depended on GNoptind==0, which
+   causes problems with re-calling getopt as programs generally don't
+   know that. */
+
+static int __getopt_initialized = 0;
+
+/* The next char to be scanned in the option-element
+   in which the last option character we returned was found.
+   This allows us to pick up the scan where we left off.
+
+   If this is zero, or a null string, it means resume the scan
+   by advancing to the next ARGV-element.  */
+
+static char *nextchar;
+
+/* Callers store zero here to inhibit the error message
+   for unrecognized options.  */
+
+static int GNopterr = 1;
+
+/* Set to an option character which was unrecognized.
+   This must be initialized on some systems to avoid linking in the
+   system's own getopt implementation.  */
+
+static int GNoptopt = '?';
+
+/* Describe how to deal with options that follow non-option ARGV-elements.
+
+   If the caller did not specify anything,
+   the default is REQUIRE_ORDER if the environment variable
+   POSIXLY_CORRECT is defined, PERMUTE otherwise.
+
+   REQUIRE_ORDER means don't recognize them as options;
+   stop option processing when the first non-option is seen.
+   This is what Unix does.
+   This mode of operation is selected by either setting the environment
+   variable POSIXLY_CORRECT, or using `+' as the first character
+   of the list of option characters.
+
+   PERMUTE is the default.  We GNUNET_CRYPTO_random_permute the contents of ARGV as we scan,
+   so that eventually all the non-options are at the end.  This allows options
+   to be given in any order, even with programs that were not written to
+   expect this.
+
+   RETURN_IN_ORDER is an option available to programs that were written
+   to expect GNoptions and other ARGV-elements in any order and that care about
+   the ordering of the two.  We describe each non-option ARGV-element
+   as if it were the argument of an option with character code 1.
+   Using `-' as the first character of the list of option characters
+   selects this mode of operation.
+
+   The special argument `--' forces an end of option-scanning regardless
+   of the value of `ordering'.  In the case of RETURN_IN_ORDER, only
+   `--' can cause `getopt' to return -1 with `GNoptind' != ARGC.  */
+
+static enum
+{
+  REQUIRE_ORDER, PERMUTE, RETURN_IN_ORDER
+} ordering;
+
+/* Value of POSIXLY_CORRECT environment variable.  */
+static char *posixly_correct;
+
+#ifdef  __GNU_LIBRARY__
+/* We want to avoid inclusion of string.h with non-GNU libraries
+   because there are many ways it can cause trouble.
+   On some systems, it contains special magic macros that don't work
+   in GCC.  */
+#include <string.h>
+#define  my_index       strchr
+#else
+
+/* Avoid depending on library functions or files
+   whose names are inconsistent.  */
+
+char *getenv ();
+
+static char *
+my_index (str, chr)
+     const char *str;
+     int chr;
+{
+  while (*str)
+    {
+      if (*str == chr)
+        return (char *) str;
+      str++;
+    }
+  return 0;
+}
+
+/* If using GCC, we can safely declare strlen this way.
+   If not using GCC, it is ok not to declare it.  */
+#ifdef __GNUC__
+/* Note that Motorola Delta 68k R3V7 comes with GCC but not stddef.h.
+   That was relevant to code that was here before.  */
+#if !defined (__STDC__) || !__STDC__
+/* gcc with -traditional declares the built-in strlen to return int,
+   and has done so at least since version 2.4.5. -- rms.  */
+extern int strlen (const char *);
+#endif /* not __STDC__ */
+#endif /* __GNUC__ */
+
+#endif /* not __GNU_LIBRARY__ */
+
+/* Handle permutation of arguments.  */
+
+/* Describe the part of ARGV that contains non-options that have
+   been skipped.  `first_nonopt' is the index in ARGV of the first of them;
+   `last_nonopt' is the index after the last of them.  */
+
+static int first_nonopt;
+static int last_nonopt;
+
+#ifdef _LIBC
+/* Bash 2.0 gives us an environment variable containing flags
+   indicating ARGV elements that should not be considered arguments.  */
+
+/* Defined in getopt_init.c  */
+extern char *__getopt_nonoption_flags;
+
+static int nonoption_flags_max_len;
+static int nonoption_flags_len;
+
+static int original_argc;
+static char *const *original_argv;
+
+extern pid_t __libc_pid;
+
+/* Make sure the environment variable bash 2.0 puts in the environment
+   is valid for the getopt call we must make sure that the ARGV passed
+   to getopt is that one passed to the process.  */
+static void
+  __attribute__ ((unused)) store_args_and_env (int argc, char *const *argv)
+{
+  /* XXX This is no good solution.  We should rather copy the args so
+     that we can compare them later.  But we must not use malloc(3).  */
+  original_argc = argc;
+  original_argv = argv;
+}
+
+text_set_element (__libc_subinit, store_args_and_env);
+
+# define SWAP_FLAGS(ch1, ch2) \
+  if (nonoption_flags_len > 0)                                                \
+    {                                                                 \
+      char __tmp = __getopt_nonoption_flags[ch1];                     \
+      __getopt_nonoption_flags[ch1] = __getopt_nonoption_flags[ch2];        \
+      __getopt_nonoption_flags[ch2] = __tmp;                          \
+    }
+#else /* !_LIBC */
+# define SWAP_FLAGS(ch1, ch2)
+#endif /* _LIBC */
+
+/* Exchange two adjacent subsequences of ARGV.
+   One subsequence is elements [first_nonopt,last_nonopt)
+   which contains all the non-options that have been skipped so far.
+   The other is elements [last_nonopt,GNoptind), which contains all
+   the options processed since those non-options were skipped.
+
+   `first_nonopt' and `last_nonopt' are relocated so that they describe
+   the new indices of the non-options in ARGV after they are moved.  */
+
+#if defined (__STDC__) && __STDC__
+static void exchange (char **);
+#endif
+
+static void
+exchange (argv)
+     char **argv;
+{
+  int bottom = first_nonopt;
+  int middle = last_nonopt;
+  int top = GNoptind;
+  char *tem;
+
+  /* Exchange the shorter segment with the far end of the longer segment.
+     That puts the shorter segment into the right place.
+     It leaves the longer segment in the right place overall,
+     but it consists of two parts that need to be swapped next.  */
+
+#ifdef _LIBC
+  /* First make sure the handling of the `__getopt_nonoption_flags'
+     string can work normally.  Our top argument must be in the range
+     of the string.  */
+  if (nonoption_flags_len > 0 && top >= nonoption_flags_max_len)
+    {
+      /* We must extend the array.  The user plays games with us and
+         presents new arguments.  */
+      char *new_str = malloc (top + 1);
+      if (new_str == NULL)
+        nonoption_flags_len = nonoption_flags_max_len = 0;
+      else
+        {
+          memcpy (new_str, __getopt_nonoption_flags, nonoption_flags_max_len);
+          memset (&new_str[nonoption_flags_max_len], '\0',
+                  top + 1 - nonoption_flags_max_len);
+          nonoption_flags_max_len = top + 1;
+          __getopt_nonoption_flags = new_str;
+        }
+    }
+#endif
+
+  while (top > middle && middle > bottom)
+    {
+      if (top - middle > middle - bottom)
+        {
+          /* Bottom segment is the short one.  */
+          int len = middle - bottom;
+          register int i;
+
+          /* Swap it with the top part of the top segment.  */
+          for (i = 0; i < len; i++)
+            {
+              tem = argv[bottom + i];
+              argv[bottom + i] = argv[top - (middle - bottom) + i];
+              argv[top - (middle - bottom) + i] = tem;
+              SWAP_FLAGS (bottom + i, top - (middle - bottom) + i);
+            }
+          /* Exclude the moved bottom segment from further swapping.  */
+          top -= len;
+        }
+      else
+        {
+          /* Top segment is the short one.  */
+          int len = top - middle;
+          register int i;
+
+          /* Swap it with the bottom part of the bottom segment.  */
+          for (i = 0; i < len; i++)
+            {
+              tem = argv[bottom + i];
+              argv[bottom + i] = argv[middle + i];
+              argv[middle + i] = tem;
+              SWAP_FLAGS (bottom + i, middle + i);
+            }
+          /* Exclude the moved top segment from further swapping.  */
+          bottom += len;
+        }
+    }
+
+  /* Update records for the slots the non-options now occupy.  */
+
+  first_nonopt += (GNoptind - last_nonopt);
+  last_nonopt = GNoptind;
+}
+
+/* Initialize the internal data when the first call is made.  */
+
+#if defined (__STDC__) && __STDC__
+static const char *_getopt_initialize (int, char *const *, const char *);
+#endif
+static const char *
+_getopt_initialize (argc, argv, optstring)
+     int argc;
+     char *const *argv;
+     const char *optstring;
+{
+  /* Start processing options with ARGV-element 1 (since ARGV-element 0
+     is the program name); the sequence of previously skipped
+     non-option ARGV-elements is empty.  */
+
+  first_nonopt = last_nonopt = GNoptind;
+
+  nextchar = NULL;
+
+  posixly_correct = getenv ("POSIXLY_CORRECT");
+
+  /* Determine how to handle the ordering of options and nonoptions.  */
+
+  if (optstring[0] == '-')
+    {
+      ordering = RETURN_IN_ORDER;
+      ++optstring;
+    }
+  else if (optstring[0] == '+')
+    {
+      ordering = REQUIRE_ORDER;
+      ++optstring;
+    }
+  else if (posixly_correct != NULL)
+    ordering = REQUIRE_ORDER;
+  else
+    ordering = PERMUTE;
+
+#ifdef _LIBC
+  if (posixly_correct == NULL
+      && argc == original_argc && argv == original_argv)
+    {
+      if (nonoption_flags_max_len == 0)
+        {
+          if (__getopt_nonoption_flags == NULL
+              || __getopt_nonoption_flags[0] == '\0')
+            nonoption_flags_max_len = -1;
+          else
+            {
+              const char *orig_str = __getopt_nonoption_flags;
+              int len = nonoption_flags_max_len = strlen (orig_str);
+              if (nonoption_flags_max_len < argc)
+                nonoption_flags_max_len = argc;
+              __getopt_nonoption_flags =
+                (char *) malloc (nonoption_flags_max_len);
+              if (__getopt_nonoption_flags == NULL)
+                nonoption_flags_max_len = -1;
+              else
+                {
+                  memcpy (__getopt_nonoption_flags, orig_str, len);
+                  memset (&__getopt_nonoption_flags[len], '\0',
+                          nonoption_flags_max_len - len);
+                }
+            }
+        }
+      nonoption_flags_len = nonoption_flags_max_len;
+    }
+  else
+    nonoption_flags_len = 0;
+#endif
+
+  return optstring;
+}
+
+/* Scan elements of ARGV (whose length is ARGC) for option characters
+   given in OPTSTRING.
+
+   If an element of ARGV starts with '-', and is not exactly "-" or "--",
+   then it is an option element.  The characters of this element
+   (aside from the initial '-') are option characters.  If `getopt'
+   is called repeatedly, it returns successively each of the option characters
+   from each of the option elements.
+
+   If `getopt' finds another option character, it returns that character,
+   updating `GNoptind' and `nextchar' so that the next call to `getopt' can
+   resume the scan with the following option character or ARGV-element.
+
+   If there are no more option characters, `getopt' returns -1.
+   Then `GNoptind' is the index in ARGV of the first ARGV-element
+   that is not an option.  (The ARGV-elements have been permuted
+   so that those that are not options now come last.)
+
+   OPTSTRING is a string containing the legitimate option characters.
+   If an option character is seen that is not listed in OPTSTRING,
+   return '?' after printing an error message.  If you set `GNopterr' to
+   zero, the error message is suppressed but we still return '?'.
+
+   If a char in OPTSTRING is followed by a colon, that means it wants an arg,
+   so the following text in the same ARGV-element, or the text of the following
+   ARGV-element, is returned in `GNoptarg'.  Two colons mean an option that
+   wants an optional arg; if there is text in the current ARGV-element,
+   it is returned in `GNoptarg', otherwise `GNoptarg' is set to zero.
+
+   If OPTSTRING starts with `-' or `+', it requests different methods of
+   handling the non-option ARGV-elements.
+   See the comments about RETURN_IN_ORDER and REQUIRE_ORDER, above.
+
+   Long-named options begin with `--' instead of `-'.
+   Their names may be abbreviated as long as the abbreviation is unique
+   or is an exact match for some defined option.  If they have an
+   argument, it follows the option name in the same ARGV-element, separated
+   from the option name by a `=', or else the in next ARGV-element.
+   When `getopt' finds a long-named option, it returns 0 if that option's
+   `flag' field is nonzero, the value of the option's `val' field
+   if the `flag' field is zero.
+
+   The elements of ARGV aren't really const, because we GNUNET_CRYPTO_random_permute them.
+   But we pretend they're const in the prototype to be compatible
+   with other systems.
+
+   LONGOPTS is a vector of `struct GNoption' terminated by an
+   element containing a name which is zero.
+
+   LONGIND returns the index in LONGOPT of the long-named option found.
+   It is only valid when a long-named option has been found by the most
+   recent call.
+
+   If LONG_ONLY is nonzero, '-' as well as '--' can introduce
+   long-named options.  */
+
+static int
+GN_getopt_internal (argc, argv, optstring, longopts, longind, long_only)
+     int argc;
+     char *const *argv;
+     const char *optstring;
+     const struct GNoption *longopts;
+     int *longind;
+     int long_only;
+{
+  GNoptarg = NULL;
+
+  if (GNoptind == 0 || !__getopt_initialized)
+    {
+      if (GNoptind == 0)
+        GNoptind = 1;           /* Don't scan ARGV[0], the program name.  */
+      optstring = _getopt_initialize (argc, argv, optstring);
+      __getopt_initialized = 1;
+    }
+
+  /* Test whether ARGV[GNoptind] points to a non-option argument.
+     Either it does not have option syntax, or there is an environment flag
+     from the shell indicating it is not an option.  The later information
+     is only used when the used in the GNU libc.  */
+#ifdef _LIBC
+#define NONOPTION_P (argv[GNoptind][0] != '-' || argv[GNoptind][1] == '\0'        \
+             || (GNoptind < nonoption_flags_len                       \
+                 && __getopt_nonoption_flags[GNoptind] == '1'))
+#else
+#define NONOPTION_P (argv[GNoptind][0] != '-' || argv[GNoptind][1] == '\0')
+#endif
+
+  if (nextchar == NULL || *nextchar == '\0')
+    {
+      /* Advance to the next ARGV-element.  */
+
+      /* Give FIRST_NONOPT & LAST_NONOPT rational values if GNoptind has been
+         moved back by the user (who may also have changed the arguments).  */
+      if (last_nonopt > GNoptind)
+        last_nonopt = GNoptind;
+      if (first_nonopt > GNoptind)
+        first_nonopt = GNoptind;
+
+      if (ordering == PERMUTE)
+        {
+          /* If we have just processed some options following some non-options,
+             exchange them so that the options come first.  */
+
+          if (first_nonopt != last_nonopt && last_nonopt != GNoptind)
+            exchange ((char **) argv);
+          else if (last_nonopt != GNoptind)
+            first_nonopt = GNoptind;
+
+          /* Skip any additional non-options
+             and extend the range of non-options previously skipped.  */
+
+          while (GNoptind < argc && NONOPTION_P)
+            GNoptind++;
+          last_nonopt = GNoptind;
+        }
+
+      /* The special ARGV-element `--' means premature end of options.
+         Skip it like a null option,
+         then exchange with previous non-options as if it were an option,
+         then skip everything else like a non-option.  */
+      if (GNoptind != argc && !strcmp (argv[GNoptind], "--"))
+        {
+          GNoptind++;
+
+          if (first_nonopt != last_nonopt && last_nonopt != GNoptind)
+            exchange ((char **) argv);
+          else if (first_nonopt == last_nonopt)
+            first_nonopt = GNoptind;
+          last_nonopt = argc;
+
+          GNoptind = argc;
+        }
+
+      /* If we have done all the ARGV-elements, stop the scan
+         and back over any non-options that we skipped and permuted.  */
+
+      if (GNoptind == argc)
+        {
+          /* Set the next-arg-index to point at the non-options
+             that we previously skipped, so the caller will digest them.  */
+          if (first_nonopt != last_nonopt)
+            GNoptind = first_nonopt;
+          return -1;
+        }
+
+      /* If we have come to a non-option and did not permute it,
+         either stop the scan or describe it to the caller and pass it by.  */
+
+      if (NONOPTION_P)
+        {
+          if (ordering == REQUIRE_ORDER)
+            return -1;
+          GNoptarg = argv[GNoptind++];
+          return 1;
+        }
+
+      /* We have found another option-ARGV-element.
+         Skip the initial punctuation.  */
+
+      nextchar = (argv[GNoptind] + 1
+                  + (longopts != NULL && argv[GNoptind][1] == '-'));
+    }
+
+  /* Decode the current option-ARGV-element.  */
+
+  /* Check whether the ARGV-element is a long option.
+
+     If long_only and the ARGV-element has the form "-f", where f is
+     a valid short option, don't consider it an abbreviated form of
+     a long option that starts with f.  Otherwise there would be no
+     way to give the -f short option.
+
+     On the other hand, if there's a long option "fubar" and
+     the ARGV-element is "-fu", do consider that an abbreviation of
+     the long option, just like "--fu", and not "-f" with arg "u".
+
+     This distinction seems to be the most useful approach.  */
+
+  if (longopts != NULL
+      && (argv[GNoptind][1] == '-'
+          || (long_only
+              && (argv[GNoptind][2]
+                  || !my_index (optstring, argv[GNoptind][1])))))
+    {
+      char *nameend;
+      const struct GNoption *p;
+      const struct GNoption *pfound = NULL;
+      int exact = 0;
+      int ambig = 0;
+      int indfound = -1;
+      int option_index;
+
+      for (nameend = nextchar; *nameend && *nameend != '='; nameend++)
+        /* Do nothing.  */ ;
+
+      /* Test all long options for either exact match
+         or abbreviated matches.  */
+      for (p = longopts, option_index = 0; p->name; p++, option_index++)
+        if (!strncmp (p->name, nextchar, nameend - nextchar))
+          {
+            if ((unsigned int) (nameend - nextchar)
+                == (unsigned int) strlen (p->name))
+              {
+                /* Exact match found.  */
+                pfound = p;
+                indfound = option_index;
+                exact = 1;
+                break;
+              }
+            else if (pfound == NULL)
+              {
+                /* First nonexact match found.  */
+                pfound = p;
+                indfound = option_index;
+              }
+            else
+              /* Second or later nonexact match found.  */
+              ambig = 1;
+          }
+
+      if (ambig && !exact)
+        {
+          if (GNopterr)
+            fprintf (stderr, _("%s: option `%s' is ambiguous\n"),
+                     argv[0], argv[GNoptind]);
+          nextchar += strlen (nextchar);
+          GNoptind++;
+          GNoptopt = 0;
+          return '?';
+        }
+
+      if (pfound != NULL)
+        {
+          option_index = indfound;
+          GNoptind++;
+          if (*nameend)
+            {
+              /* Don't test has_arg with >, because some C compilers don't
+                 allow it to be used on enums.  */
+              if (pfound->has_arg)
+                GNoptarg = nameend + 1;
+              else
+                {
+                  if (GNopterr)
+                    {
+                      if (argv[GNoptind - 1][1] == '-')
+                        /* --option */
+                        fprintf (stderr,
+                                 _
+                                 ("%s: option `--%s' does not allow an argument\n"),
+                                 argv[0], pfound->name);
+                      else
+                        /* +option or -option */
+                        fprintf (stderr,
+                                 _
+                                 ("%s: option `%c%s' does not allow an argument\n"),
+                                 argv[0], argv[GNoptind - 1][0],
+                                 pfound->name);
+                    }
+                  nextchar += strlen (nextchar);
+
+                  GNoptopt = pfound->val;
+                  return '?';
+                }
+            }
+          else if (pfound->has_arg == 1)
+            {
+              if (GNoptind < argc)
+                {
+                  GNoptarg = argv[GNoptind++];
+                }
+              else
+                {
+                  if (GNopterr)
+                    {
+                      fprintf (stderr,
+                               _("%s: option `%s' requires an argument\n"),
+                               argv[0], argv[GNoptind - 1]);
+                    }
+                  nextchar += strlen (nextchar);
+                  GNoptopt = pfound->val;
+                  return (optstring[0] == ':') ? ':' : '?';
+                }
+            }
+          nextchar += strlen (nextchar);
+          if (longind != NULL)
+            *longind = option_index;
+          if (pfound->flag)
+            {
+              *(pfound->flag) = pfound->val;
+              return 0;
+            }
+          return pfound->val;
+        }
+
+      /* Can't find it as a long option.  If this is not getopt_long_only,
+         or the option starts with '--' or is not a valid short
+         option, then it's an error.
+         Otherwise interpret it as a short option.  */
+      if (!long_only || argv[GNoptind][1] == '-'
+          || my_index (optstring, *nextchar) == NULL)
+        {
+          if (GNopterr)
+            {
+              if (argv[GNoptind][1] == '-')
+                /* --option */
+                fprintf (stderr, _("%s: unrecognized option `--%s'\n"),
+                         argv[0], nextchar);
+              else
+                /* +option or -option */
+                fprintf (stderr, _("%s: unrecognized option `%c%s'\n"),
+                         argv[0], argv[GNoptind][0], nextchar);
+            }
+          nextchar = (char *) "";
+          GNoptind++;
+          GNoptopt = 0;
+          return '?';
+        }
+    }
+
+  /* Look at and handle the next short option-character.  */
+
+  {
+    char c = *nextchar++;
+    char *temp = my_index (optstring, c);
+
+    /* Increment `GNoptind' when we start to process its last character.  */
+    if (*nextchar == '\0')
+      ++GNoptind;
+
+    if (temp == NULL || c == ':')
+      {
+        if (GNopterr)
+          {
+            if (posixly_correct)
+              /* 1003.2 specifies the format of this message.  */
+              fprintf (stderr, _("%s: illegal option -- %c\n"), argv[0], c);
+            else
+              fprintf (stderr, _("%s: invalid option -- %c\n"), argv[0], c);
+          }
+        GNoptopt = c;
+        return '?';
+      }
+    /* Convenience. Treat POSIX -W foo same as long option --foo */
+    if (temp[0] == 'W' && temp[1] == ';')
+      {
+        char *nameend;
+        const struct GNoption *p;
+        const struct GNoption *pfound = NULL;
+        int exact = 0;
+        int ambig = 0;
+        int indfound = 0;
+        int option_index;
+
+        /* This is an option that requires an argument.  */
+        if (*nextchar != '\0')
+          {
+            GNoptarg = nextchar;
+            /* If we end this ARGV-element by taking the rest as an arg,
+               we must advance to the next element now.  */
+            GNoptind++;
+          }
+        else if (GNoptind == argc)
+          {
+            if (GNopterr)
+              {
+                /* 1003.2 specifies the format of this message.  */
+                fprintf (stderr, _("%s: option requires an argument -- %c\n"),
+                         argv[0], c);
+              }
+            GNoptopt = c;
+            if (optstring[0] == ':')
+              c = ':';
+            else
+              c = '?';
+            return c;
+          }
+        else
+          /* We already incremented `GNoptind' once;
+             increment it again when taking next ARGV-elt as argument.  */
+          GNoptarg = argv[GNoptind++];
+
+        /* GNoptarg is now the argument, see if it's in the
+           table of longopts.  */
+
+        for (nextchar = nameend = GNoptarg; *nameend && *nameend != '=';
+             nameend++)
+          /* Do nothing.  */ ;
+
+        /* Test all long options for either exact match
+           or abbreviated matches.  */
+        for (p = longopts, option_index = 0; p->name; p++, option_index++)
+          if (!strncmp (p->name, nextchar, nameend - nextchar))
+            {
+              if ((unsigned int) (nameend - nextchar) == strlen (p->name))
+                {
+                  /* Exact match found.  */
+                  pfound = p;
+                  indfound = option_index;
+                  exact = 1;
+                  break;
+                }
+              else if (pfound == NULL)
+                {
+                  /* First nonexact match found.  */
+                  pfound = p;
+                  indfound = option_index;
+                }
+              else
+                /* Second or later nonexact match found.  */
+                ambig = 1;
+            }
+        if (ambig && !exact)
+          {
+            if (GNopterr)
+              fprintf (stderr, _("%s: option `-W %s' is ambiguous\n"),
+                       argv[0], argv[GNoptind]);
+            nextchar += strlen (nextchar);
+            GNoptind++;
+            return '?';
+          }
+        if (pfound != NULL)
+          {
+            option_index = indfound;
+            if (*nameend)
+              {
+                /* Don't test has_arg with >, because some C compilers don't
+                   allow it to be used on enums.  */
+                if (pfound->has_arg)
+                  GNoptarg = nameend + 1;
+                else
+                  {
+                    if (GNopterr)
+                      fprintf (stderr, _("\
+%s: option `-W %s' does not allow an argument\n"), argv[0], pfound->name);
+
+                    nextchar += strlen (nextchar);
+                    return '?';
+                  }
+              }
+            else if (pfound->has_arg == 1)
+              {
+                if (GNoptind < argc)
+                  GNoptarg = argv[GNoptind++];
+                else
+                  {
+                    if (GNopterr)
+                      fprintf (stderr,
+                               _("%s: option `%s' requires an argument\n"),
+                               argv[0], argv[GNoptind - 1]);
+                    nextchar += strlen (nextchar);
+                    return optstring[0] == ':' ? ':' : '?';
+                  }
+              }
+            nextchar += strlen (nextchar);
+            if (longind != NULL)
+              *longind = option_index;
+            if (pfound->flag)
+              {
+                *(pfound->flag) = pfound->val;
+                return 0;
+              }
+            return pfound->val;
+          }
+        nextchar = NULL;
+        return 'W';             /* Let the application handle it.   */
+      }
+    if (temp[1] == ':')
+      {
+        if (temp[2] == ':')
+          {
+            /* This is an option that accepts an argument optionally.  */
+            if (*nextchar != '\0')
+              {
+                GNoptarg = nextchar;
+                GNoptind++;
+              }
+            else
+              GNoptarg = NULL;
+            nextchar = NULL;
+          }
+        else
+          {
+            /* This is an option that requires an argument.  */
+            if (*nextchar != '\0')
+              {
+                GNoptarg = nextchar;
+                /* If we end this ARGV-element by taking the rest as an arg,
+                   we must advance to the next element now.  */
+                GNoptind++;
+              }
+            else if (GNoptind == argc)
+              {
+                if (GNopterr)
+                  {
+                    /* 1003.2 specifies the format of this message.  */
+                    fprintf (stderr,
+                             _("%s: option requires an argument -- %c\n"),
+                             argv[0], c);
+                  }
+                GNoptopt = c;
+                if (optstring[0] == ':')
+                  c = ':';
+                else
+                  c = '?';
+              }
+            else
+              /* We already incremented `GNoptind' once;
+                 increment it again when taking next ARGV-elt as argument.  */
+              GNoptarg = argv[GNoptind++];
+            nextchar = NULL;
+          }
+      }
+    return c;
+  }
+}
+
+static int
+GNgetopt_long (int argc,
+               char *const *argv,
+               const char *options,
+               const struct GNoption *long_options, int *opt_index)
+{
+  return GN_getopt_internal (argc, argv, options, long_options, opt_index, 0);
+}
+
+/* ******************** now the GNUnet specific modifications... ********************* */
+
+/**
+ * Parse the command line.
+ *
+ * @param binaryName name of the binary / application with options
+ * @param cfg for storing/accessing configuration data
+ * @param allOptions defined options and handlers
+ * @param argc number of arguments
+ * @param argv actual arguments
+ * @return index into argv with first non-option
+ *   argument, or -1 on error
+ */
+int
+GNUNET_GETOPT_run (const char *binaryOptions,
+                   struct GNUNET_CONFIGURATION_Handle *cfg,
+                   const struct GNUNET_GETOPT_CommandLineOption *allOptions,
+                   unsigned int argc, char *const *argv)
+{
+  struct GNoption *long_options;
+  struct GNUNET_GETOPT_CommandLineProcessorContext clpc;
+  int count;
+  int i;
+  char *shorts;
+  int spos;
+  int cont;
+  int c;
+
+  GNUNET_assert (argc > 0);
+  GNoptind = 0;
+  clpc.binaryName = argv[0];
+  clpc.binaryOptions = binaryOptions;
+  clpc.allOptions = allOptions;
+  clpc.argv = argv;
+  clpc.argc = argc;
+  clpc.cfg = cfg;
+  count = 0;
+  while (allOptions[count].name != NULL)
+    count++;
+  long_options = GNUNET_malloc (sizeof (struct GNoption) * (count + 1));
+  shorts = GNUNET_malloc (count * 2 + 1);
+  spos = 0;
+  for (i = 0; i < count; i++)
+    {
+      long_options[i].name = allOptions[i].name;
+      long_options[i].has_arg = allOptions[i].require_argument;
+      long_options[i].flag = NULL;
+      long_options[i].val = allOptions[i].shortName;
+      shorts[spos++] = allOptions[i].shortName;
+      if (allOptions[i].require_argument != 0)
+        shorts[spos++] = ':';
+    }
+  long_options[count].name = NULL;
+  long_options[count].has_arg = 0;
+  long_options[count].flag = NULL;
+  long_options[count].val = '\0';
+  shorts[spos++] = '\0';
+  cont = GNUNET_OK;
+  /* main getopt loop */
+  while (cont == GNUNET_OK)
+    {
+      int option_index = 0;
+      c = GNgetopt_long (argc, argv, shorts, long_options, &option_index);
+
+      if (c == GNUNET_SYSERR)
+        break;                  /* No more flags to process */
+
+      for (i = 0; i < count; i++)
+        {
+          clpc.currentArgument = GNoptind - 1;
+          if ((char) c == allOptions[i].shortName)
+            {
+              cont = allOptions[i].processor (&clpc,
+                                              allOptions[i].scls,
+                                              allOptions[i].name, GNoptarg);
+              break;
+            }
+        }
+      if (i == count)
+        {
+          fprintf (stderr, _("Use --help to get a list of options.\n"));
+          cont = GNUNET_SYSERR;
+        }
+    }
+
+  GNUNET_free (shorts);
+  GNUNET_free (long_options);
+  if (cont == GNUNET_SYSERR)
+    return GNUNET_SYSERR;
+  return GNoptind;
+}
+
+/* end of getopt.c */
diff --git a/src/util/getopt_helpers.c b/src/util/getopt_helpers.c
new file mode 100644
index 000000000..3aea5d102
--- /dev/null
+++ b/src/util/getopt_helpers.c
@@ -0,0 +1,200 @@
+/*
+     This file is part of GNUnet
+     (C) 2006 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/util/getopt_helpers.c
+ * @brief implements command line that sets option
+ * @author Christian Grothoff
+ */
+
+#include "platform.h"
+#include "gnunet_common.h"
+#include "gnunet_getopt_lib.h"
+
+
+int
+GNUNET_GETOPT_print_version_ (struct GNUNET_GETOPT_CommandLineProcessorContext
+                              *ctx, void *scls, const char *option,
+                              const char *value)
+{
+  const char *version = scls;
+
+  printf ("%s v%s\n", ctx->binaryName, version);
+  return GNUNET_SYSERR;
+}
+
+
+
+#define BORDER 29
+
+int
+GNUNET_GETOPT_format_help_ (struct GNUNET_GETOPT_CommandLineProcessorContext
+                            *ctx, void *scls, const char *option,
+                            const char *value)
+{
+  const char *about = scls;
+  int slen;
+  int i;
+  int j;
+  int ml;
+  int p;
+  char *scp;
+  const char *trans;
+  const struct GNUNET_GETOPT_CommandLineOption *opt;
+
+  printf ("%s\n%s\n", ctx->binaryOptions, gettext (about));
+  printf (_
+          ("Arguments mandatory for long options are also mandatory for short options.\n"));
+  slen = 0;
+  i = 0;
+  opt = ctx->allOptions;
+  while (opt[i].description != NULL)
+    {
+      if (opt[i].shortName == '\0')
+        printf ("      ");
+      else
+        printf ("  -%c, ", opt[i].shortName);
+      printf ("--%s", opt[i].name);
+      slen = 8 + strlen (opt[i].name);
+      if (opt[i].argumentHelp != NULL)
+        {
+          printf ("=%s", opt[i].argumentHelp);
+          slen += 1 + strlen (opt[i].argumentHelp);
+        }
+      if (slen > BORDER)
+        {
+          printf ("\n%*s", BORDER, "");
+          slen = BORDER;
+        }
+      if (slen < BORDER)
+        {
+          printf ("%*s", BORDER - slen, "");
+          slen = BORDER;
+        }
+      trans = gettext (opt[i].description);
+      ml = strlen (trans);
+      p = 0;
+    OUTER:
+      while (ml - p > 78 - slen)
+        {
+          for (j = p + 78 - slen; j > p; j--)
+            {
+              if (isspace (trans[j]))
+                {
+                  scp = GNUNET_malloc (j - p + 1);
+                  memcpy (scp, &trans[p], j - p);
+                  scp[j - p] = '\0';
+                  printf ("%s\n%*s", scp, BORDER + 2, "");
+                  GNUNET_free (scp);
+                  p = j + 1;
+                  slen = BORDER + 2;
+                  goto OUTER;
+                }
+            }
+          /* could not find space to break line */
+          scp = GNUNET_malloc (78 - slen + 1);
+          memcpy (scp, &trans[p], 78 - slen);
+          scp[78 - slen] = '\0';
+          printf ("%s\n%*s", scp, BORDER + 2, "");
+          GNUNET_free (scp);
+          slen = BORDER + 2;
+          p = p + 78 - slen;
+        }
+      /* print rest */
+      if (p < ml)
+        printf ("%s\n", &trans[p]);
+      if (strlen (trans) == 0)
+        printf ("\n");
+      i++;
+    }
+  printf ("Report bugs to gnunet-developers@gnu.org.\n"
+          "GNUnet home page: http://www.gnu.org/software/gnunet/\n"
+          "General help using GNU software: http://www.gnu.org/gethelp/\n");
+  return GNUNET_SYSERR;
+}
+
+
+int
+GNUNET_GETOPT_increment_value (struct
+                               GNUNET_GETOPT_CommandLineProcessorContext *ctx,
+                               void *scls, const char *cmdLineOption,
+                               const char *value)
+{
+  int *val = scls;
+  (*val)++;
+  return GNUNET_OK;
+}
+
+int
+GNUNET_GETOPT_set_one (struct GNUNET_GETOPT_CommandLineProcessorContext *ctx,
+                       void *scls, const char *option, const char *value)
+{
+  int *val = scls;
+  *val = 1;
+  return GNUNET_OK;
+}
+
+int
+GNUNET_GETOPT_set_string (struct GNUNET_GETOPT_CommandLineProcessorContext
+                          *ctx, void *scls, const char *option,
+                          const char *value)
+{
+  char **val = scls;
+
+  GNUNET_assert (value != NULL);
+  if (NULL != *val)
+    GNUNET_free (*val);
+  *val = GNUNET_strdup (value);
+  return GNUNET_OK;
+}
+
+int
+GNUNET_GETOPT_set_ulong (struct GNUNET_GETOPT_CommandLineProcessorContext
+                         *ctx, void *scls, const char *option,
+                         const char *value)
+{
+  unsigned long long *val = scls;
+  if (1 != SSCANF (value, "%llu", val))
+    {
+      fprintf (stderr,
+               _("You must pass a number to the `%s' option.\n"), "-X");
+      return GNUNET_SYSERR;
+    }
+  return GNUNET_OK;
+}
+
+
+int
+GNUNET_GETOPT_set_uint (struct GNUNET_GETOPT_CommandLineProcessorContext *ctx,
+                        void *scls, const char *option, const char *value)
+{
+  unsigned int *val = scls;
+
+  if (1 != SSCANF (value, "%u", val))
+    {
+      fprintf (stderr,
+               _("You must pass a number to the `%s' option.\n"), "-X");
+      return GNUNET_SYSERR;
+    }
+  return GNUNET_OK;
+}
+
+
+/* end of getopt_helpers.c */
diff --git a/src/util/network.c b/src/util/network.c
new file mode 100644
index 000000000..22c1ca632
--- /dev/null
+++ b/src/util/network.c
@@ -0,0 +1,1239 @@
+/*
+     This file is part of GNUnet.
+     (C) 2009 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 util/network/network.c
+ * @brief basic, low-level TCP networking interface
+ * @author Christian Grothoff
+ *
+ * This code is rather complex.  Only modify it if you
+ * 1) Have a NEW testcase showing that the new code
+ *    is needed and correct
+ * 2) All EXISTING testcases pass with the new code
+ * These rules should apply in general, but for this
+ * module they are VERY, VERY important.
+ *
+ * TODO:
+ * - can we merge receive_ready and receive_again?
+ * - can we integrate the nth.timeout_task with the write_task's timeout?
+ */
+
+#include "platform.h"
+#include "gnunet_common.h"
+#include "gnunet_network_lib.h"
+#include "gnunet_scheduler_lib.h"
+
+#define DEBUG_NETWORK GNUNET_NO
+
+struct GNUNET_NETWORK_TransmitHandle
+{
+
+  /**
+   * Function to call if the send buffer has notify_size
+   * bytes available.
+   */
+  GNUNET_NETWORK_TransmitReadyNotify notify_ready;
+
+  /**
+   * Closure for notify_ready.
+   */
+  void *notify_ready_cls;
+
+  /**
+   * Our socket handle.
+   */
+  struct GNUNET_NETWORK_SocketHandle *sh;
+
+  /**
+   * Timeout for receiving (in absolute time).
+   */
+  struct GNUNET_TIME_Absolute transmit_timeout;
+
+  /**
+   * Task called on timeout.
+   */
+  GNUNET_SCHEDULER_TaskIdentifier timeout_task;
+
+  /**
+   * At what number of bytes available in the
+   * write buffer should the notify method be called?
+   */
+  size_t notify_size;
+
+};
+
+/**
+ * @brief handle for a network socket
+ */
+struct GNUNET_NETWORK_SocketHandle
+{
+
+  /**
+   * Scheduler that was used for the connect task.
+   */
+  struct GNUNET_SCHEDULER_Handle *sched;
+
+  /**
+   * Address information for connect (may be NULL).
+   */
+  struct addrinfo *ai;
+
+  /**
+   * Index for the next struct addrinfo for connect attempts (may be NULL)
+   */
+  struct addrinfo *ai_pos;
+
+  /**
+   * Network address of the other end-point, may be NULL.
+   */
+  struct sockaddr *addr;
+
+  /**
+   * Pointer to our write buffer.
+   */
+  char *write_buffer;
+
+  /**
+   * Size of our write buffer.
+   */
+  size_t write_buffer_size;
+
+  /**
+   * Current write-offset in write buffer (where
+   * would we write next).
+   */
+  size_t write_buffer_off;
+
+  /**
+   * Current read-offset in write buffer (how many
+   * bytes have already been send).
+   */
+  size_t write_buffer_pos;
+
+  /**
+   * Length of addr.
+   */
+  socklen_t addrlen;
+
+  /**
+   * Connect task that we may need to wait for.
+   */
+  GNUNET_SCHEDULER_TaskIdentifier connect_task;
+
+  /**
+   * Read task that we may need to wait for.
+   */
+  GNUNET_SCHEDULER_TaskIdentifier read_task;
+
+  /**
+   * Write task that we may need to wait for.
+   */
+  GNUNET_SCHEDULER_TaskIdentifier write_task;
+
+  /**
+   * The handle we return for GNUNET_NETWORK_notify_transmit_ready.
+   */
+  struct GNUNET_NETWORK_TransmitHandle nth;
+
+  /**
+   * Underlying OS's socket, set to -1 after fatal errors.
+   */
+  int sock;
+
+  /**
+   * Port to connect to.
+   */
+  uint16_t port;
+
+  /**
+   * Function to call on data received, NULL
+   * if no receive is pending.
+   */
+  GNUNET_NETWORK_Receiver receiver;
+
+  /**
+   * Closure for receiver.
+   */
+  void *receiver_cls;
+
+  /**
+   * Timeout for receiving (in absolute time).
+   */
+  struct GNUNET_TIME_Absolute receive_timeout;
+
+  /**
+   * Maximum number of bytes to read
+   * (for receiving).
+   */
+  size_t max;
+
+};
+
+
+/**
+ * Create a socket handle by boxing an existing OS socket.  The OS
+ * socket should henceforth be no longer used directly.
+ * GNUNET_socket_destroy will close it.
+ *
+ * @param sched scheduler to use
+ * @param osSocket existing socket to box
+ * @param maxbuf maximum write buffer size for the socket (use
+ *        0 for sockets that need no write buffers, such as listen sockets)
+ * @return the boxed socket handle
+ */
+struct GNUNET_NETWORK_SocketHandle *
+GNUNET_NETWORK_socket_create_from_existing (struct GNUNET_SCHEDULER_Handle
+                                            *sched, int osSocket,
+                                            size_t maxbuf)
+{
+  struct GNUNET_NETWORK_SocketHandle *ret;
+  ret = GNUNET_malloc (sizeof (struct GNUNET_NETWORK_SocketHandle) + maxbuf);
+  ret->write_buffer = (char *) &ret[1];
+  ret->write_buffer_size = maxbuf;
+  ret->sock = osSocket;
+  ret->sched = sched;
+  return ret;
+}
+
+
+/**
+ * Create a socket handle by accepting on a listen socket.  This
+ * function may block if the listen socket has no connection ready.
+ *
+ * @param sched scheduler to use
+ * @param access function to use to check if access is allowed
+ * @param access_cls closure for access
+ * @param lsock listen socket
+ * @param maxbuf maximum write buffer size for the socket (use
+ *        0 for sockets that need no write buffers, such as listen sockets)
+ * @return the socket handle, NULL on error
+ */
+struct GNUNET_NETWORK_SocketHandle *
+GNUNET_NETWORK_socket_create_from_accept (struct GNUNET_SCHEDULER_Handle
+                                          *sched,
+                                          GNUNET_NETWORK_AccessCheck access,
+                                          void *access_cls, int lsock,
+                                          size_t maxbuf)
+{
+  struct GNUNET_NETWORK_SocketHandle *ret;
+  char addr[32];
+  char msg[INET6_ADDRSTRLEN];
+  socklen_t addrlen;
+  int fam;
+  int fd;
+  int aret;
+  struct sockaddr_in *v4;
+  struct sockaddr_in6 *v6;
+  struct sockaddr *sa;
+  void *uaddr;
+
+  addrlen = sizeof (addr);
+  fd = accept (lsock, (struct sockaddr *) &addr, &addrlen);
+  if (fd == -1)
+    {
+      GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "accept");
+      return NULL;
+    }
+  if (0 != fcntl (fd, F_SETFD, fcntl (fd, F_GETFD) | FD_CLOEXEC))
+    GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
+                         "fcntl");
+  if (addrlen > sizeof (addr))
+    {
+      GNUNET_break (0);
+      GNUNET_break (0 == CLOSE (fd));
+      return NULL;
+    }
+
+  sa = (struct sockaddr *) addr;
+  v6 = (struct sockaddr_in6 *) addr;
+  if ((sa->sa_family == AF_INET6) && (IN6_IS_ADDR_V4MAPPED (&v6->sin6_addr)))
+    {
+      /* convert to V4 address */
+      v4 = GNUNET_malloc (sizeof (struct sockaddr_in));
+      memset (v4, 0, sizeof (struct sockaddr_in));
+      v4->sin_family = AF_INET;
+      memcpy (&v4->sin_addr,
+              &((char *) &v6->sin6_addr)[sizeof (struct in6_addr) -
+                                         sizeof (struct in_addr)],
+              sizeof (struct in_addr));
+      v4->sin_port = v6->sin6_port;
+      uaddr = v4;
+      addrlen = sizeof (struct sockaddr_in);
+    }
+  else
+    {
+      uaddr = GNUNET_malloc (addrlen);
+      memcpy (uaddr, addr, addrlen);
+    }
+
+  if ((access != NULL) &&
+      (GNUNET_YES != (aret = access (access_cls, uaddr, addrlen))))
+    {
+      if (aret == GNUNET_NO)
+        {
+          fam = ((struct sockaddr *) addr)->sa_family;
+          GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                      _("Access denied to `%s'\n"),
+                      inet_ntop (fam,
+                                 (fam == AF_INET6)
+                                 ? (const void *) &((struct sockaddr_in6 *)
+                                                    &addr)->
+                                 sin6_addr : (const void *)
+                                 &((struct sockaddr_in *) &addr)->sin_addr,
+                                 msg, sizeof (msg)));
+        }
+      GNUNET_break (0 == SHUTDOWN (fd, SHUT_RDWR));
+      GNUNET_break (0 == CLOSE (fd));
+      GNUNET_free (uaddr);
+      return NULL;
+    }
+  ret = GNUNET_malloc (sizeof (struct GNUNET_NETWORK_SocketHandle) + maxbuf);
+  ret->write_buffer = (char *) &ret[1];
+  ret->write_buffer_size = maxbuf;
+  ret->addr = uaddr;
+  ret->addrlen = addrlen;
+  ret->sock = fd;
+  ret->sched = sched;
+  return ret;
+}
+
+/**
+ * Obtain the network address of the other party.
+ *
+ * @param sock the client to get the address for
+ * @param addr where to store the address
+ * @param addrlen where to store the length of the address
+ * @return GNUNET_OK on success
+ */
+int
+GNUNET_NETWORK_socket_get_address (struct GNUNET_NETWORK_SocketHandle *sock,
+                                   void **addr, size_t * addrlen)
+{
+  if ((sock->addr == NULL) || (sock->addrlen == 0))
+    return GNUNET_NO;
+  *addr = GNUNET_malloc (sock->addrlen);
+  memcpy (*addr, sock->addr, sock->addrlen);
+  *addrlen = sock->addrlen;
+  return GNUNET_OK;
+}
+
+
+/**
+ * Set if a socket should use blocking or non-blocking IO.
+ *
+ * @return GNUNET_OK on success, GNUNET_SYSERR on error
+ */
+static int
+socket_set_blocking (int handle, int doBlock)
+{
+#if MINGW
+  u_long mode;
+  mode = !doBlock;
+#if HAVE_PLIBC_FD
+  if (ioctlsocket (plibc_fd_get_handle (handle), FIONBIO, &mode) ==
+      SOCKET_ERROR)
+    {
+      SetErrnoFromWinsockError (WSAGetLastError ());
+      GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "ioctlsocket");
+      return GNUNET_SYSERR;
+    }
+#else
+  if (ioctlsocket (handle, FIONBIO, &mode) == SOCKET_ERROR)
+    {
+      SetErrnoFromWinsockError (WSAGetLastError ());
+      GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "ioctlsocket");
+      return GNUNET_SYSERR;
+    }
+#endif
+  /* store the blocking mode */
+#if HAVE_PLIBC_FD
+  plibc_fd_set_blocking (handle, doBlock);
+#else
+  __win_SetHandleBlockingMode (handle, doBlock);
+#endif
+  return GNUNET_OK;
+
+#else
+  /* not MINGW */
+  int flags = fcntl (handle, F_GETFL);
+  if (flags == -1)
+    {
+      GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "fcntl");
+      return GNUNET_SYSERR;
+    }
+  if (doBlock)
+    flags &= ~O_NONBLOCK;
+  else
+    flags |= O_NONBLOCK;
+  if (0 != fcntl (handle, F_SETFL, flags))
+    {
+      GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "fcntl");
+      return GNUNET_SYSERR;
+    }
+  return GNUNET_OK;
+#endif
+}
+
+
+/**
+ * Initiate asynchronous TCP connect request.
+ *
+ * @param sock what socket to connect
+ * @return GNUNET_SYSERR error (no more addresses to try)
+ */
+static int
+try_connect (struct GNUNET_NETWORK_SocketHandle *sock)
+{
+  int s;
+
+  if (sock->addr != NULL)
+    {
+      GNUNET_free (sock->addr);
+      sock->addr = NULL;
+      sock->addrlen = 0;
+    }
+  while (1)
+    {
+      if (sock->ai_pos == NULL)
+        {
+          /* no more addresses to try, fatal! */
+          return GNUNET_SYSERR;
+        }
+      switch (sock->ai_pos->ai_family)
+        {
+        case AF_INET:
+          ((struct sockaddr_in *) sock->ai_pos->ai_addr)->sin_port =
+            htons (sock->port);
+          break;
+        case AF_INET6:
+          ((struct sockaddr_in6 *) sock->ai_pos->ai_addr)->sin6_port =
+            htons (sock->port);
+          break;
+        default:
+          sock->ai_pos = sock->ai_pos->ai_next;
+          continue;
+        }
+      s = SOCKET (sock->ai_pos->ai_family, SOCK_STREAM, 0);
+      if (s == -1)
+        {
+          /* maybe unsupported address family, try next */
+          GNUNET_log_strerror (GNUNET_ERROR_TYPE_INFO, "socket");
+          sock->ai_pos = sock->ai_pos->ai_next;
+          continue;
+        }
+      if (0 != fcntl (s, F_SETFD, fcntl (s, F_GETFD) | FD_CLOEXEC))
+        GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
+                             "fcntl");
+      if (GNUNET_SYSERR == socket_set_blocking (s, GNUNET_NO))
+        {
+          /* we'll treat this one as fatal */
+          GNUNET_break (0 == CLOSE (s));
+          return GNUNET_SYSERR;
+        }
+      if ((0 != CONNECT (s,
+                         sock->ai_pos->ai_addr,
+                         sock->ai_pos->ai_addrlen)) && (errno != EINPROGRESS))
+        {
+          /* maybe refused / unsupported address, try next */
+          GNUNET_log_strerror (GNUNET_ERROR_TYPE_INFO, "connect");
+          GNUNET_break (0 == CLOSE (s));
+          continue;
+        }
+      break;
+    }
+  /* got one! copy address information! */
+  sock->addrlen = sock->ai_pos->ai_addrlen;
+  sock->addr = GNUNET_malloc (sock->addrlen);
+  memcpy (sock->addr, sock->ai_pos->ai_addr, sock->addrlen);
+  sock->ai_pos = sock->ai_pos->ai_next;
+  sock->sock = s;
+  return GNUNET_OK;
+}
+
+
+/**
+ * Scheduler let us know that we're either ready to
+ * write on the socket OR connect timed out.  Do the
+ * right thing.
+ */
+static void
+connect_continuation (void *cls,
+                      const struct GNUNET_SCHEDULER_TaskContext *tc)
+{
+  struct GNUNET_NETWORK_SocketHandle *sock = cls;
+  unsigned int len;
+  int error;
+
+  /* nobody needs to wait for us anymore... */
+  sock->connect_task = GNUNET_SCHEDULER_NO_PREREQUISITE_TASK;
+  /* Note: write-ready does NOT mean connect succeeded,
+     we need to use getsockopt to be sure */
+  len = sizeof (error);
+  errno = 0;
+  error = 0;
+  if ((0 == (tc->reason & GNUNET_SCHEDULER_REASON_WRITE_READY)) ||
+      (0 != getsockopt (sock->sock, SOL_SOCKET, SO_ERROR, &error, &len)) ||
+      (error != 0) || (errno != 0))
+    {
+      /* connect failed / timed out */
+      GNUNET_break (0 == CLOSE (sock->sock));
+      sock->sock = -1;
+      if (GNUNET_SYSERR == try_connect (sock))
+        {
+          /* failed for good */
+          GNUNET_break (sock->ai_pos == NULL);
+          freeaddrinfo (sock->ai);
+          sock->ai = NULL;
+          return;
+        }
+      sock->connect_task = GNUNET_SCHEDULER_add_write (tc->sched, GNUNET_NO,    /* abort on shutdown */
+                                                       GNUNET_SCHEDULER_PRIORITY_KEEP,
+                                                       GNUNET_SCHEDULER_NO_PREREQUISITE_TASK,
+                                                       GNUNET_NETWORK_CONNECT_RETRY_TIMEOUT,
+                                                       sock->sock,
+                                                       &connect_continuation,
+                                                       sock);
+      return;
+    }
+  /* connect succeeded! clean up "ai" */
+#if DEBUG_NETWORK
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Connection succeeded!\n");
+#endif
+  freeaddrinfo (sock->ai);
+  sock->ai_pos = NULL;
+  sock->ai = NULL;
+}
+
+
+/**
+ * Create a socket handle by (asynchronously) connecting to a host.
+ * This function returns immediately, even if the connection has not
+ * yet been established.  This function only creates TCP connections.
+ *
+ * @param sched scheduler to use
+ * @param hostname name of the host to connect to
+ * @param port port to connect to
+ * @param maxbuf maximum write buffer size for the socket (use
+ *        0 for sockets that need no write buffers, such as listen sockets)
+ * @return the socket handle
+ */
+struct GNUNET_NETWORK_SocketHandle *
+GNUNET_NETWORK_socket_create_from_connect (struct GNUNET_SCHEDULER_Handle
+                                           *sched, const char *hostname,
+                                           uint16_t port, size_t maxbuf)
+{
+  struct GNUNET_NETWORK_SocketHandle *ret;
+  struct addrinfo hints;
+  int ec;
+
+  ret = GNUNET_malloc (sizeof (struct GNUNET_NETWORK_SocketHandle) + maxbuf);
+  ret->sock = -1;
+  ret->sched = sched;
+  ret->write_buffer = (char *) &ret[1];
+  ret->write_buffer_size = maxbuf;
+  ret->port = port;
+  memset (&hints, 0, sizeof (hints));
+  hints.ai_family = AF_UNSPEC;
+  hints.ai_socktype = SOCK_STREAM;
+  if (0 != (ec = getaddrinfo (hostname, NULL, &hints, &ret->ai)))
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_INFO | GNUNET_ERROR_TYPE_BULK,
+                  "`%s' failed for hostname `%s': %s\n",
+                  "getaddrinfo", hostname, gai_strerror (ec));
+      GNUNET_free (ret);
+      return NULL;
+    }
+  ret->ai_pos = ret->ai;
+  if (GNUNET_SYSERR == try_connect (ret))
+    {
+      freeaddrinfo (ret->ai);
+      GNUNET_free (ret);
+      return NULL;
+    }
+  ret->connect_task = GNUNET_SCHEDULER_add_write (sched, GNUNET_NO,     /* abort on shutdown */
+                                                  GNUNET_SCHEDULER_PRIORITY_KEEP,
+                                                  GNUNET_SCHEDULER_NO_PREREQUISITE_TASK,
+                                                  GNUNET_NETWORK_CONNECT_RETRY_TIMEOUT,
+                                                  ret->sock,
+                                                  &connect_continuation, ret);
+  return ret;
+
+}
+
+
+/**
+ * Create a socket handle by (asynchronously) connecting to a host.
+ * This function returns immediately, even if the connection has not
+ * yet been established.  This function only creates TCP connections.
+ *
+ * @param sched scheduler to use
+ * @param af_family address family to use
+ * @param serv_addr server address
+ * @param addrlen length of server address
+ * @param maxbuf maximum write buffer size for the socket (use
+ *        0 for sockets that need no write buffers, such as listen sockets)
+ * @return the socket handle
+ */
+struct GNUNET_NETWORK_SocketHandle *
+GNUNET_NETWORK_socket_create_from_sockaddr (struct GNUNET_SCHEDULER_Handle
+                                            *sched, int af_family,
+                                            const struct sockaddr *serv_addr,
+                                            socklen_t addrlen, size_t maxbuf)
+{
+  int s;
+
+  s = SOCKET (af_family, SOCK_STREAM, 0);
+  if (s == -1)
+    {
+      GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING |
+                           GNUNET_ERROR_TYPE_BULK, "socket");
+      return NULL;
+    }
+  if (0 != fcntl (s, F_SETFD, fcntl (s, F_GETFD) | FD_CLOEXEC))
+    GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
+                         "fcntl");
+  if (GNUNET_SYSERR == socket_set_blocking (s, GNUNET_NO))
+    {
+      /* we'll treat this one as fatal */
+      GNUNET_break (0 == CLOSE (s));
+      return NULL;
+    }
+  if ((0 != CONNECT (s, serv_addr, addrlen)) && (errno != EINPROGRESS))
+    {
+      /* maybe refused / unsupported address, try next */
+      GNUNET_log_strerror (GNUNET_ERROR_TYPE_INFO, "connect");
+      GNUNET_break (0 == CLOSE (s));
+      return NULL;
+    }
+  return GNUNET_NETWORK_socket_create_from_existing (sched, s, maxbuf);
+}
+
+
+/**
+ * Check if socket is valid (no fatal errors have happened so far).
+ * Note that a socket that is still trying to connect is considered
+ * valid.
+ *
+ * @param sock socket to check
+ * @return GNUNET_YES if valid, GNUNET_NO otherwise
+ */
+int
+GNUNET_NETWORK_socket_check (struct GNUNET_NETWORK_SocketHandle *sock)
+{
+  if (sock->ai != NULL)
+    return GNUNET_YES;          /* still trying to connect */
+  return (sock->sock == -1) ? GNUNET_NO : GNUNET_YES;
+}
+
+
+/**
+ * Scheduler let us know that the connect task is finished (or was
+ * cancelled due to shutdown).  Now really clean up.
+ */
+static void
+destroy_continuation (void *cls,
+                      const struct GNUNET_SCHEDULER_TaskContext *tc)
+{
+  struct GNUNET_NETWORK_SocketHandle *sock = cls;
+  GNUNET_NETWORK_TransmitReadyNotify notify;
+
+  if (sock->write_task != GNUNET_SCHEDULER_NO_PREREQUISITE_TASK)
+    {
+#if DEBUG_NETWORK
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "Destroy code waiting for writes to complete.\n");
+#endif
+      GNUNET_SCHEDULER_add_after (sock->sched,
+                                  GNUNET_YES,
+                                  GNUNET_SCHEDULER_PRIORITY_KEEP,
+                                  sock->write_task,
+                                  &destroy_continuation, sock);
+      return;
+    }
+  if (sock->sock != -1)
+    {
+#if DEBUG_NETWORK
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Shutting down socket.\n");
+#endif
+      SHUTDOWN (sock->sock, SHUT_RDWR);
+    }
+  if (sock->read_task != GNUNET_SCHEDULER_NO_PREREQUISITE_TASK)
+    {
+#if DEBUG_NETWORK
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "Destroy code waiting for receive to complete.\n");
+#endif
+      GNUNET_SCHEDULER_add_after (sock->sched,
+                                  GNUNET_YES,
+                                  GNUNET_SCHEDULER_PRIORITY_KEEP,
+                                  sock->read_task,
+                                  &destroy_continuation, sock);
+      return;
+    }
+  if (NULL != (notify = sock->nth.notify_ready))
+    {
+      sock->nth.notify_ready = NULL;
+      notify (sock->nth.notify_ready_cls, 0, NULL);
+      if (sock->nth.timeout_task != GNUNET_SCHEDULER_NO_PREREQUISITE_TASK)
+        {
+          GNUNET_SCHEDULER_cancel (sock->sched, sock->nth.timeout_task);
+          sock->nth.timeout_task = GNUNET_SCHEDULER_NO_PREREQUISITE_TASK;
+        }
+    }
+  if (sock->sock != -1)
+    {
+#if DEBUG_NETWORK
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Closing socket.\n");
+#endif
+      GNUNET_break (0 == CLOSE (sock->sock));
+    }
+  GNUNET_free_non_null (sock->addr);
+  if (sock->ai != NULL)
+    freeaddrinfo (sock->ai);
+  GNUNET_free (sock);
+}
+
+
+/**
+ * Close the socket and free associated resources. Pending
+ * transmissions are simply dropped.  A pending receive call will be
+ * called with an error code of "EPIPE".
+ *
+ * @param sock socket to destroy
+ */
+void
+GNUNET_NETWORK_socket_destroy (struct GNUNET_NETWORK_SocketHandle *sock)
+{
+#if DEBUG_NETWORK
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Network asked to destroy socket %p\n", sock);
+#endif
+  if (sock->write_buffer_off == 0)
+    sock->ai_pos = NULL;        /* if we're still trying to connect and have
+                                   no message pending, stop trying! */
+  GNUNET_assert (sock->sched != NULL);
+  GNUNET_SCHEDULER_add_after (sock->sched,
+                              GNUNET_YES,
+                              GNUNET_SCHEDULER_PRIORITY_KEEP,
+                              sock->connect_task,
+                              &destroy_continuation, sock);
+}
+
+/**
+ * Tell the receiver callback that a timeout was reached.
+ */
+static void
+signal_timeout (struct GNUNET_NETWORK_SocketHandle *sh)
+{
+  GNUNET_NETWORK_Receiver receiver;
+
+#if DEBUG_NETWORK
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Network signals timeout to receiver!\n");
+#endif
+  GNUNET_assert (NULL != (receiver = sh->receiver));
+  sh->receiver = NULL;
+  receiver (sh->receiver_cls, NULL, 0, NULL, 0, 0);
+}
+
+
+/**
+ * Tell the receiver callback that we had an IO error.
+ */
+static void
+signal_error (struct GNUNET_NETWORK_SocketHandle *sh, int errcode)
+{
+  GNUNET_NETWORK_Receiver receiver;
+  GNUNET_assert (NULL != (receiver = sh->receiver));
+  sh->receiver = NULL;
+  receiver (sh->receiver_cls, NULL, 0, sh->addr, sh->addrlen, errcode);
+}
+
+
+/**
+ * This function is called once we either timeout
+ * or have data ready to read.
+ */
+static void
+receive_ready (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+{
+  struct GNUNET_NETWORK_SocketHandle *sh = cls;
+  struct GNUNET_TIME_Absolute now;
+  char buffer[sh->max];
+  ssize_t ret;
+  GNUNET_NETWORK_Receiver receiver;
+
+  sh->read_task = GNUNET_SCHEDULER_NO_PREREQUISITE_TASK;
+  now = GNUNET_TIME_absolute_get ();
+  if ((now.value > sh->receive_timeout.value) ||
+      (0 != (tc->reason & GNUNET_SCHEDULER_REASON_TIMEOUT)) ||
+      (0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN)))
+    {
+#if DEBUG_NETWORK
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "Receive encounters error: timeout...\n");
+#endif
+      signal_timeout (sh);
+      return;
+    }
+  if (sh->sock == -1)
+    {
+      /* connect failed for good */
+#if DEBUG_NETWORK
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "Receive encounters error, socket closed...\n");
+#endif
+      signal_error (sh, ECONNREFUSED);
+      return;
+    }
+  GNUNET_assert (FD_ISSET (sh->sock, tc->read_ready));
+RETRY:
+  ret = RECV (sh->sock, buffer, sh->max, MSG_DONTWAIT);
+  if (ret == -1)
+    {
+      if (errno == EINTR)
+        goto RETRY;
+#if DEBUG_NETWORK
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "Error receiving: %s\n", STRERROR (errno));
+#endif
+      signal_error (sh, errno);
+      return;
+    }
+#if DEBUG_NETWORK
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Receive got %d bytes from OS!\n", ret);
+#endif
+  GNUNET_assert (NULL != (receiver = sh->receiver));
+  sh->receiver = NULL;
+  receiver (sh->receiver_cls, buffer, ret, sh->addr, sh->addrlen, 0);
+}
+
+
+/**
+ * This function is called after establishing a connection either has
+ * succeeded or timed out.  Note that it is possible that the attempt
+ * timed out and that we're immediately retrying.  If we are retrying,
+ * we need to wait again (or timeout); if we succeeded, we need to
+ * wait for data (or timeout).
+ */
+static void
+receive_again (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+{
+  struct GNUNET_NETWORK_SocketHandle *sh = cls;
+  struct GNUNET_TIME_Absolute now;
+
+  sh->read_task = GNUNET_SCHEDULER_NO_PREREQUISITE_TASK;
+  if ((sh->sock == -1) &&
+      (sh->connect_task == GNUNET_SCHEDULER_NO_PREREQUISITE_TASK))
+    {
+      /* not connected and no longer trying */
+#if DEBUG_NETWORK
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "Receive encounters error, socket closed...\n");
+#endif
+      signal_error (sh, ECONNREFUSED);
+      return;
+    }
+  now = GNUNET_TIME_absolute_get ();
+  if ((now.value > sh->receive_timeout.value) ||
+      (0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN)))
+    {
+#if DEBUG_NETWORK
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "Receive encounters error: timeout...\n");
+#endif
+      signal_timeout (sh);
+      return;
+    }
+  if (sh->connect_task != GNUNET_SCHEDULER_NO_PREREQUISITE_TASK)
+    {
+      /* connect was retried */
+#if DEBUG_NETWORK
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "Receive still waits on connect...\n");
+#endif
+      sh->read_task = GNUNET_SCHEDULER_add_after (tc->sched,
+                                                  GNUNET_YES,
+                                                  GNUNET_SCHEDULER_PRIORITY_KEEP,
+                                                  sh->connect_task,
+                                                  &receive_again, sh);
+    }
+  else
+    {
+      /* connect succeeded, wait for data! */
+#if DEBUG_NETWORK
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "Receive now waits for socket...\n");
+#endif
+      sh->read_task = GNUNET_SCHEDULER_add_read (tc->sched,
+                                                 GNUNET_YES,
+                                                 GNUNET_SCHEDULER_PRIORITY_KEEP,
+                                                 sh->connect_task,
+                                                 GNUNET_TIME_absolute_get_remaining
+                                                 (sh->receive_timeout),
+                                                 sh->sock, &receive_ready,
+                                                 sh);
+    }
+}
+
+
+/**
+ * Receive data from the given socket.  Note that this function will
+ * call "receiver" asynchronously using the scheduler.  It will
+ * "immediately" return.  Note that there MUST only be one active
+ * receive call per socket at any given point in time (so do not
+ * call receive again until the receiver callback has been invoked).
+ *
+ * @param sched scheduler to use
+ * @param sock socket handle
+ * @param max maximum number of bytes to read
+ * @param timeout maximum amount of time to wait (use -1 for "forever")
+ * @param receiver function to call with received data
+ * @param receiver_cls closure for receiver
+ * @return scheduler task ID used for receiving, GNUNET_SCHEDULER_NO_PREREQUISITE_TASK on error
+ */
+GNUNET_SCHEDULER_TaskIdentifier
+GNUNET_NETWORK_receive (struct GNUNET_NETWORK_SocketHandle *sock,
+                        size_t max,
+                        struct GNUNET_TIME_Relative timeout,
+                        GNUNET_NETWORK_Receiver receiver, void *receiver_cls)
+{
+  struct GNUNET_SCHEDULER_TaskContext tc;
+#if DEBUG_NETWORK
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Network asked to receive from socket...\n");
+#endif
+  GNUNET_assert ((sock->read_task == GNUNET_SCHEDULER_NO_PREREQUISITE_TASK) &&
+                 (sock->receiver == NULL));
+  sock->receiver = receiver;
+  sock->receiver_cls = receiver_cls;
+  sock->receive_timeout = GNUNET_TIME_relative_to_absolute (timeout);
+  sock->max = max;
+  memset (&tc, 0, sizeof (tc));
+  tc.sched = sock->sched;
+  tc.reason = GNUNET_SCHEDULER_REASON_PREREQ_DONE;
+  receive_again (sock, &tc);
+  return sock->read_task;
+}
+
+
+/**
+ * Cancel receive job on the given socket.  Note that the
+ * receiver callback must not have been called yet in order
+ * for the cancellation to be valid.
+ *
+ * @param sock socket handle
+ * @param task task identifier returned from the receive call
+ * @return closure of the original receiver callback
+ */
+void *
+GNUNET_NETWORK_receive_cancel (struct GNUNET_NETWORK_SocketHandle *sock,
+                               GNUNET_SCHEDULER_TaskIdentifier task)
+{
+  GNUNET_assert (sock->read_task == task);
+  GNUNET_assert (sock == GNUNET_SCHEDULER_cancel (sock->sched, task));
+  sock->read_task = GNUNET_SCHEDULER_NO_PREREQUISITE_TASK;
+  sock->receiver = NULL;
+  return sock->receiver_cls;
+}
+
+
+/**
+ * Try to call the transmit notify method (check if we do
+ * have enough space available first)!
+ *
+ * @param sock socket for which we should do this processing
+ * @return GNUNET_YES if we were able to call notify
+ */
+static int
+process_notify (struct GNUNET_NETWORK_SocketHandle *sock)
+{
+  size_t used;
+  size_t avail;
+  size_t size;
+  GNUNET_NETWORK_TransmitReadyNotify notify;
+
+  GNUNET_assert (sock->write_task == GNUNET_SCHEDULER_NO_PREREQUISITE_TASK);
+  if (NULL == (notify = sock->nth.notify_ready))
+    return GNUNET_NO;
+  used = sock->write_buffer_off - sock->write_buffer_pos;
+  avail = sock->write_buffer_size - used;
+  size = sock->nth.notify_size;
+  if (sock->nth.notify_size > avail)
+    return GNUNET_NO;
+  sock->nth.notify_ready = NULL;
+  if (sock->nth.timeout_task != GNUNET_SCHEDULER_NO_PREREQUISITE_TASK)
+    {
+      GNUNET_SCHEDULER_cancel (sock->sched, sock->nth.timeout_task);
+      sock->nth.timeout_task = GNUNET_SCHEDULER_NO_PREREQUISITE_TASK;
+    }
+  if (sock->write_buffer_size - sock->write_buffer_off < size)
+    {
+      /* need to compact */
+      memmove (sock->write_buffer,
+               &sock->write_buffer[sock->write_buffer_pos], used);
+      sock->write_buffer_off -= sock->write_buffer_pos;
+      sock->write_buffer_pos = 0;
+    }
+  GNUNET_assert (sock->write_buffer_size - sock->write_buffer_off >= size);
+  size = notify (sock->nth.notify_ready_cls,
+                 sock->write_buffer_size - sock->write_buffer_off,
+                 &sock->write_buffer[sock->write_buffer_off]);
+  sock->write_buffer_off += size;
+  return GNUNET_YES;
+}
+
+
+/**
+ * Task invoked by the scheduler when a call to transmit
+ * is timing out (we never got enough buffer space to call
+ * the callback function before the specified timeout
+ * expired).
+ *
+ * This task notifies the client about the timeout.
+ */
+static void
+transmit_timeout (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+{
+  struct GNUNET_NETWORK_SocketHandle *sock = cls;
+  GNUNET_NETWORK_TransmitReadyNotify notify;
+
+#if DEBUG_NETWORK
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Transmit fails, time out reached.\n");
+#endif
+  notify = sock->nth.notify_ready;
+  sock->nth.notify_ready = NULL;
+  notify (sock->nth.notify_ready_cls, 0, NULL);
+}
+
+
+static void
+transmit_error (struct GNUNET_NETWORK_SocketHandle *sock)
+{
+  if (sock->nth.notify_ready == NULL)
+    return;                     /* nobody to tell about it */
+  if (sock->nth.timeout_task != GNUNET_SCHEDULER_NO_PREREQUISITE_TASK)
+    {
+      GNUNET_SCHEDULER_cancel (sock->sched, sock->nth.timeout_task);
+      sock->nth.timeout_task = GNUNET_SCHEDULER_NO_PREREQUISITE_TASK;
+    }
+  transmit_timeout (sock, NULL);
+}
+
+
+/**
+ * See if we are now connected.  If not, wait longer for
+ * connect to succeed.  If connected, we should be able
+ * to write now as well, unless we timed out.
+ */
+static void
+transmit_ready (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+{
+  struct GNUNET_NETWORK_SocketHandle *sock = cls;
+  ssize_t ret;
+  size_t have;
+
+#if DEBUG_NETWORK
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Transmit ready called --- will try to send\n");
+#endif
+  GNUNET_assert (sock->write_task != GNUNET_SCHEDULER_NO_PREREQUISITE_TASK);
+  sock->write_task = GNUNET_SCHEDULER_NO_PREREQUISITE_TASK;
+  if (sock->connect_task != GNUNET_SCHEDULER_NO_PREREQUISITE_TASK)
+    {
+      /* still waiting for connect */
+#if DEBUG_NETWORK
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "Transmission still waiting for connect...\n");
+#endif
+      GNUNET_assert (sock->write_task ==
+                     GNUNET_SCHEDULER_NO_PREREQUISITE_TASK);
+      sock->write_task =
+        GNUNET_SCHEDULER_add_delayed (tc->sched, GNUNET_NO,
+                                      GNUNET_SCHEDULER_PRIORITY_KEEP,
+                                      sock->connect_task,
+                                      GNUNET_TIME_UNIT_ZERO, &transmit_ready,
+                                      sock);
+      return;
+    }
+  if (sock->sock == -1)
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                  _
+                  ("Did not transmit request, socket closed or connect failed.\n"));
+      transmit_error (sock);
+      return;                   /* connect failed for good, we're finished */
+    }
+  if ((tc->write_ready == NULL) || (!FD_ISSET (sock->sock, tc->write_ready)))
+    {
+#if DEBUG_NETWORK
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "Socket not yet ready for writing, will wait for that.\n");
+#endif
+      goto SCHEDULE_WRITE;
+    }
+  GNUNET_assert (sock->write_buffer_off >= sock->write_buffer_pos);
+  process_notify (sock);
+  have = sock->write_buffer_off - sock->write_buffer_pos;
+  if (have == 0)
+    {
+#if DEBUG_NETWORK
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "No data ready for writing.\n");
+#endif
+      return;
+    }
+RETRY:
+  ret = SEND (sock->sock,
+              &sock->write_buffer[sock->write_buffer_pos],
+              have, MSG_DONTWAIT | MSG_NOSIGNAL);
+  if (ret == -1)
+    {
+      if (errno == EINTR)
+        goto RETRY;
+#if DEBUG_NETWORK
+      GNUNET_log_strerror (GNUNET_ERROR_TYPE_DEBUG, "send");
+#endif
+      SHUTDOWN (sock->sock, SHUT_RDWR);
+      GNUNET_break (0 == CLOSE (sock->sock));
+      sock->sock = -1;
+      transmit_error (sock);
+      return;
+    }
+#if DEBUG_NETWORK
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Transmitted %d bytes to OS\n", ret);
+#endif
+  sock->write_buffer_pos += ret;
+  if (sock->write_buffer_pos == sock->write_buffer_off)
+    {
+      /* transmitted all pending data */
+      sock->write_buffer_pos = 0;
+      sock->write_buffer_off = 0;
+#if DEBUG_NETWORK
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "Transmission buffer now empty.\n", ret);
+#endif
+    }
+  if ((sock->write_buffer_off == 0) && (NULL == sock->nth.notify_ready))
+    return;                     /* all data sent! */
+  /* not done writing, schedule more */
+#if DEBUG_NETWORK
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "More data ready for transmission, scheduling task again!\n");
+#endif
+SCHEDULE_WRITE:
+  if (sock->write_task == GNUNET_SCHEDULER_NO_PREREQUISITE_TASK)
+    sock->write_task =
+      GNUNET_SCHEDULER_add_write (tc->sched,
+                                  GNUNET_NO,
+                                  GNUNET_SCHEDULER_PRIORITY_KEEP,
+                                  GNUNET_SCHEDULER_NO_PREREQUISITE_TASK,
+                                  GNUNET_TIME_UNIT_FOREVER_REL,
+                                  sock->sock, &transmit_ready, sock);
+}
+
+
+/**
+ * Ask the socket to call us once the specified number of bytes
+ * are free in the transmission buffer.  May call the notify
+ * method immediately if enough space is available.
+ *
+ * @param sock socket
+ * @param size number of bytes to send
+ * @param timeout after how long should we give up (and call
+ *        notify with buf NULL and size 0)?
+ * @param notify function to call
+ * @param notify_cls closure for notify
+ * @return non-NULL if the notify callback was queued,
+ *         NULL if we are already going to notify someone else (busy)
+ */
+struct GNUNET_NETWORK_TransmitHandle *
+GNUNET_NETWORK_notify_transmit_ready (struct GNUNET_NETWORK_SocketHandle
+                                      *sock, size_t size,
+                                      struct GNUNET_TIME_Relative timeout,
+                                      GNUNET_NETWORK_TransmitReadyNotify
+                                      notify, void *notify_cls)
+{
+  if (sock->nth.notify_ready != NULL)
+    return NULL;
+  GNUNET_assert (notify != NULL);
+  GNUNET_assert (sock->write_buffer_size >= size);
+
+  if ((sock->sock == -1) &&
+      (sock->connect_task == GNUNET_SCHEDULER_NO_PREREQUISITE_TASK))
+    {
+#if DEBUG_NETWORK
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "Transmit fails, connection failed.\n");
+#endif
+      notify (notify_cls, 0, NULL);
+      return &sock->nth;
+    }
+  GNUNET_assert (sock->write_buffer_off <= sock->write_buffer_size);
+  GNUNET_assert (sock->write_buffer_pos <= sock->write_buffer_size);
+  GNUNET_assert (sock->write_buffer_pos <= sock->write_buffer_off);
+  sock->nth.notify_ready = notify;
+  sock->nth.notify_ready_cls = notify_cls;
+  sock->nth.sh = sock;
+  sock->nth.notify_size = size;
+  sock->nth.transmit_timeout = GNUNET_TIME_relative_to_absolute (timeout);
+  sock->nth.timeout_task = GNUNET_SCHEDULER_add_delayed (sock->sched,
+                                                         GNUNET_NO,
+                                                         GNUNET_SCHEDULER_PRIORITY_KEEP,
+                                                         GNUNET_SCHEDULER_NO_PREREQUISITE_TASK,
+                                                         timeout,
+                                                         &transmit_timeout,
+                                                         sock);
+#if DEBUG_NETWORK
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Scheduling asynchronous transmission once connect is done...\n");
+#endif
+  if (sock->write_task == GNUNET_SCHEDULER_NO_PREREQUISITE_TASK)
+    sock->write_task = GNUNET_SCHEDULER_add_delayed (sock->sched,
+                                                     GNUNET_NO,
+                                                     GNUNET_SCHEDULER_PRIORITY_KEEP,
+                                                     sock->connect_task,
+                                                     GNUNET_TIME_UNIT_ZERO,
+                                                     &transmit_ready, sock);
+  return &sock->nth;
+}
+
+
+/**
+ * Cancel the specified transmission-ready
+ * notification.
+ */
+void
+GNUNET_NETWORK_notify_transmit_ready_cancel (struct
+                                             GNUNET_NETWORK_TransmitHandle *h)
+{
+  GNUNET_assert (h->notify_ready != NULL);
+  GNUNET_SCHEDULER_cancel (h->sh->sched, h->timeout_task);
+  h->timeout_task = GNUNET_SCHEDULER_NO_PREREQUISITE_TASK;
+  h->notify_ready = NULL;
+}
+
+
+#if 0                           /* keep Emacsens' auto-indent happy */
+{
+#endif
+#ifdef __cplusplus
+}
+#endif
diff --git a/src/util/os_installation.c b/src/util/os_installation.c
new file mode 100644
index 000000000..201095544
--- /dev/null
+++ b/src/util/os_installation.c
@@ -0,0 +1,443 @@
+/*
+     This file is part of GNUnet.
+     (C) 2006 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/util/os_installation.c
+ * @brief get paths used by the program
+ * @author Milan
+ */
+
+#ifdef __cplusplus
+extern "C"
+{
+#if 0                           /* keep Emacsens' auto-indent happy */
+}
+#endif
+#endif
+
+#include <sys/stat.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+
+#include "platform.h"
+#include "gnunet_common.h"
+#include "gnunet_configuration_lib.h"
+#include "gnunet_disk_lib.h"
+#include "gnunet_os_lib.h"
+#if OSX
+#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;
+  char *dir;
+  FILE *f;
+
+  GNUNET_snprintf (fn, 64, "/proc/%u/maps", getpid ());
+  line = GNUNET_malloc (1024);
+  dir = GNUNET_malloc (1024);
+  f = fopen (fn, "r");
+  if (f != NULL)
+    {
+      while (NULL != fgets (line, 1024, f))
+        {
+          if ((1 == sscanf (line,
+                            "%*x-%*x %*c%*c%*c%*c %*x %*2u:%*2u %*u%*[ ]%s",
+                            dir)) && (NULL != strstr (dir, "libgnunetutil")))
+            {
+              strstr (dir, "libgnunetutil")[0] = '\0';
+              fclose (f);
+              GNUNET_free (line);
+              return dir;
+            }
+        }
+      fclose (f);
+    }
+  GNUNET_free (dir);
+  GNUNET_free (line);
+  return NULL;
+}
+
+/**
+ * Try to determine path by reading /proc/PID/exe
+ */
+static char *
+get_path_from_proc_exe ()
+{
+  char fn[64];
+  char *lnk;
+  size_t size;
+
+  GNUNET_snprintf (fn, 64, "/proc/%u/exe", getpid ());
+  lnk = GNUNET_malloc (1024);
+  size = readlink (fn, lnk, 1023);
+  if ((size == 0) || (size >= 1024))
+    {
+      GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_ERROR, "readlink", fn);
+      GNUNET_free (lnk);
+      return NULL;
+    }
+  lnk[size] = '\0';
+  while ((lnk[size] != '/') && (size > 0))
+    size--;
+  if ((size < 4) || (lnk[size - 4] != '/'))
+    {
+      /* not installed in "/bin/" -- binary path probably useless */
+      GNUNET_free (lnk);
+      return NULL;
+    }
+  lnk[size] = '\0';
+  return lnk;
+}
+#endif
+
+#if WINDOWS
+/**
+ * Try to determine path with win32-specific function
+ */
+static char *
+get_path_from_module_filename ()
+{
+  char *path;
+  char *idx;
+
+  path = GNUNET_malloc (4097);
+  GetModuleFileName (NULL, path, 4096);
+  idx = path + strlen (path);
+  while ((idx > path) && (*idx != '\\') && (*idx != '/'))
+    idx--;
+  *idx = '\0';
+  return path;
+}
+#endif
+
+#if OSX
+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;
+  size_t size;
+
+  p = getenv ("PATH");
+  if (p == NULL)
+    return NULL;
+  path = GNUNET_strdup (p);     /* because we write on it */
+  buf = GNUNET_malloc (strlen (path) + 20);
+  size = strlen (path);
+  pos = path;
+
+  while (NULL != (end = strchr (pos, ':')))
+    {
+      *end = '\0';
+      sprintf (buf, "%s/%s", pos, "gnunetd");
+      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, "gnunetd");
+  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_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 OSX
+  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 */
+  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;
+
+#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 OSX
+  ret = get_path_from_NSGetExecutablePath ();
+  if (ret != NULL)
+    return ret;
+#endif
+  /* other attempts here */
+  return NULL;
+}
+
+
+
+/**
+ * @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_OS_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"
+          DIR_SEPARATOR_STR;
+      else
+        dirname = DIR_SEPARATOR_STR "gnunet" DIR_SEPARATOR_STR;
+      break;
+    case GNUNET_OS_IPK_DATADIR:
+      dirname =
+        DIR_SEPARATOR_STR "share" DIR_SEPARATOR_STR "gnunet"
+        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;
+}
+
+#if 0                           /* keep Emacsens' auto-indent happy */
+{
+#endif
+#ifdef __cplusplus
+}
+#endif
+/* end of installpath.c */
diff --git a/src/util/os_load.c b/src/util/os_load.c
new file mode 100644
index 000000000..d1115e33f
--- /dev/null
+++ b/src/util/os_load.c
@@ -0,0 +1,653 @@
+/*
+     This file is part of GNUnet.
+     (C) 2001, 2002, 2003, 2005, 2006 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 util/os_load_cpu.c
+ * @brief calls to determine current CPU load
+ * @author Tzvetan Horozov
+ * @author Christian Grothoff
+ * @author Igor Wronsky
+ * @author Alex Harper (OS X portion)
+ */
+
+#include "platform.h"
+#include "gnunet_common.h"
+#include "gnunet_os_lib.h"
+#include "gnunet_strings_lib.h"
+
+#if SOLARIS
+#if HAVE_KSTAT_H
+#include <kstat.h>
+#endif
+#if HAVE_SYS_SYSINFO_H
+#include <sys/sysinfo.h>
+#endif
+#if HAVE_KVM_H
+#include <kvm.h>
+#endif
+#endif
+#if SOMEBSD
+#if HAVE_KVM_H
+#include <kvm.h>
+#endif
+#endif
+
+#ifdef OSX
+#include <mach/mach.h>
+
+static processor_cpu_load_info_t prev_cpu_load;
+#endif
+
+#define DEBUG_STATUSCALLS GNUNET_NO
+
+#ifdef LINUX
+static FILE *proc_stat;
+#endif
+
+/**
+ * Current CPU load, as percentage of CPU cycles not idle or
+ * blocked on IO.
+ */
+static int currentCPULoad;
+
+static double agedCPULoad = -1;
+
+/**
+ * Current IO load, as percentage of CPU cycles blocked on IO.
+ */
+static int currentIOLoad;
+
+static double agedIOLoad = -1;
+
+#ifdef OSX
+static int
+initMachCpuStats ()
+{
+  unsigned int cpu_count;
+  processor_cpu_load_info_t cpu_load;
+  mach_msg_type_number_t cpu_msg_count;
+  kern_return_t kret;
+  int i, j;
+
+  kret = host_processor_info (mach_host_self (),
+                              PROCESSOR_CPU_LOAD_INFO,
+                              &cpu_count,
+                              (processor_info_array_t *) & cpu_load,
+                              &cpu_msg_count);
+  if (kret != KERN_SUCCESS)
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
+                  "host_processor_info failed.");
+      return GNUNET_SYSERR;
+    }
+  prev_cpu_load = GNUNET_malloc (cpu_count * sizeof (*prev_cpu_load));
+  for (i = 0; i < cpu_count; i++)
+    {
+      for (j = 0; j < CPU_STATE_MAX; j++)
+        {
+          prev_cpu_load[i].cpu_ticks[j] = cpu_load[i].cpu_ticks[j];
+        }
+    }
+  vm_deallocate (mach_task_self (),
+                 (vm_address_t) cpu_load,
+                 (vm_size_t) (cpu_msg_count * sizeof (*cpu_load)));
+  return GNUNET_OK;
+}
+#endif
+
+/**
+ * Update the currentCPU and currentIO load values.
+ *
+ * Before its first invocation the method initStatusCalls() must be called.
+ * If there is an error the method returns -1.
+ */
+static int
+updateUsage ()
+{
+  currentIOLoad = -1;
+  currentCPULoad = -1;
+#ifdef LINUX
+  /* under linux, first try %idle/usage using /proc/stat;
+     if that does not work, disable /proc/stat for the future
+     by closing the file and use the next-best method. */
+  if (proc_stat != NULL)
+    {
+      static unsigned long long last_cpu_results[5] = { 0, 0, 0, 0, 0 };
+      static int have_last_cpu = GNUNET_NO;
+      int ret;
+      char line[256];
+      unsigned long long user_read, system_read, nice_read, idle_read,
+        iowait_read;
+      unsigned long long user, system, nice, idle, iowait;
+      unsigned long long usage_time = 0, total_time = 1;
+
+      /* Get the first line with the data */
+      rewind (proc_stat);
+      fflush (proc_stat);
+      if (NULL == fgets (line, 256, proc_stat))
+        {
+          GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_ERROR |
+                                    GNUNET_ERROR_TYPE_BULK,
+                                    "fgets", "/proc/stat");
+          fclose (proc_stat);
+          proc_stat = NULL;     /* don't try again */
+        }
+      else
+        {
+          iowait_read = 0;
+          ret = sscanf (line, "%*s %llu %llu %llu %llu %llu",
+                        &user_read,
+                        &system_read, &nice_read, &idle_read, &iowait_read);
+          if (ret < 4)
+            {
+              GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_ERROR |
+                                        GNUNET_ERROR_TYPE_BULK,
+                                        "fgets-sscanf", "/proc/stat");
+              fclose (proc_stat);
+              proc_stat = NULL; /* don't try again */
+              have_last_cpu = GNUNET_NO;
+            }
+          else
+            {
+              /* Store the current usage */
+              user = user_read - last_cpu_results[0];
+              system = system_read - last_cpu_results[1];
+              nice = nice_read - last_cpu_results[2];
+              idle = idle_read - last_cpu_results[3];
+              iowait = iowait_read - last_cpu_results[4];
+              /* Calculate the % usage */
+              usage_time = user + system + nice;
+              total_time = usage_time + idle + iowait;
+              if ((total_time > 0) && (have_last_cpu == GNUNET_YES))
+                {
+                  currentCPULoad = (int) (100L * usage_time / total_time);
+                  if (ret > 4)
+                    currentIOLoad = (int) (100L * iowait / total_time);
+                  else
+                    currentIOLoad = -1; /* 2.4 kernel */
+                }
+              /* Store the values for the next calculation */
+              last_cpu_results[0] = user_read;
+              last_cpu_results[1] = system_read;
+              last_cpu_results[2] = nice_read;
+              last_cpu_results[3] = idle_read;
+              last_cpu_results[4] = iowait_read;
+              have_last_cpu = GNUNET_YES;
+              return GNUNET_OK;
+            }
+        }
+    }
+#endif
+
+#ifdef OSX
+  {
+    unsigned int cpu_count;
+    processor_cpu_load_info_t cpu_load;
+    mach_msg_type_number_t cpu_msg_count;
+    unsigned long long t_sys, t_user, t_nice, t_idle, t_total;
+    unsigned long long t_idle_all, t_total_all;
+    kern_return_t kret;
+    int i, j;
+
+    t_idle_all = t_total_all = 0;
+    kret = host_processor_info (mach_host_self (), PROCESSOR_CPU_LOAD_INFO,
+                                &cpu_count,
+                                (processor_info_array_t *) & cpu_load,
+                                &cpu_msg_count);
+    if (kret == KERN_SUCCESS)
+      {
+        for (i = 0; i < cpu_count; i++)
+          {
+            if (cpu_load[i].cpu_ticks[CPU_STATE_SYSTEM] >=
+                prev_cpu_load[i].cpu_ticks[CPU_STATE_SYSTEM])
+              {
+                t_sys = cpu_load[i].cpu_ticks[CPU_STATE_SYSTEM] -
+                  prev_cpu_load[i].cpu_ticks[CPU_STATE_SYSTEM];
+              }
+            else
+              {
+                t_sys = cpu_load[i].cpu_ticks[CPU_STATE_SYSTEM] +
+                  (ULONG_MAX - prev_cpu_load[i].cpu_ticks[CPU_STATE_SYSTEM] +
+                   1);
+              }
+
+            if (cpu_load[i].cpu_ticks[CPU_STATE_USER] >=
+                prev_cpu_load[i].cpu_ticks[CPU_STATE_USER])
+              {
+                t_user = cpu_load[i].cpu_ticks[CPU_STATE_USER] -
+                  prev_cpu_load[i].cpu_ticks[CPU_STATE_USER];
+              }
+            else
+              {
+                t_user = cpu_load[i].cpu_ticks[CPU_STATE_USER] +
+                  (ULONG_MAX - prev_cpu_load[i].cpu_ticks[CPU_STATE_USER] +
+                   1);
+              }
+
+            if (cpu_load[i].cpu_ticks[CPU_STATE_NICE] >=
+                prev_cpu_load[i].cpu_ticks[CPU_STATE_NICE])
+              {
+                t_nice = cpu_load[i].cpu_ticks[CPU_STATE_NICE] -
+                  prev_cpu_load[i].cpu_ticks[CPU_STATE_NICE];
+              }
+            else
+              {
+                t_nice = cpu_load[i].cpu_ticks[CPU_STATE_NICE] +
+                  (ULONG_MAX - prev_cpu_load[i].cpu_ticks[CPU_STATE_NICE] +
+                   1);
+              }
+
+            if (cpu_load[i].cpu_ticks[CPU_STATE_IDLE] >=
+                prev_cpu_load[i].cpu_ticks[CPU_STATE_IDLE])
+              {
+                t_idle = cpu_load[i].cpu_ticks[CPU_STATE_IDLE] -
+                  prev_cpu_load[i].cpu_ticks[CPU_STATE_IDLE];
+              }
+            else
+              {
+                t_idle = cpu_load[i].cpu_ticks[CPU_STATE_IDLE] +
+                  (ULONG_MAX - prev_cpu_load[i].cpu_ticks[CPU_STATE_IDLE] +
+                   1);
+              }
+            t_total = t_sys + t_user + t_nice + t_idle;
+            t_idle_all += t_idle;
+            t_total_all += t_total;
+          }
+        for (i = 0; i < cpu_count; i++)
+          {
+            for (j = 0; j < CPU_STATE_MAX; j++)
+              {
+                prev_cpu_load[i].cpu_ticks[j] = cpu_load[i].cpu_ticks[j];
+              }
+          }
+        if (t_total_all > 0)
+          currentCPULoad = 100 - (100 * t_idle_all) / t_total_all;
+        else
+          currentCPULoad = -1;
+        vm_deallocate (mach_task_self (),
+                       (vm_address_t) cpu_load,
+                       (vm_size_t) (cpu_msg_count * sizeof (*cpu_load)));
+        currentIOLoad = -1;     /* FIXME-OSX! */
+        return GNUNET_OK;
+      }
+    else
+      {
+        GNUNET_log (GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
+                    "host_processor_info failed.");
+        return GNUNET_SYSERR;
+      }
+  }
+#endif
+  /* try kstat (Solaris only) */
+#if SOLARIS && HAVE_KSTAT_H && HAVE_SYS_SYSINFO_H
+  {
+    static long long last_idlecount;
+    static long long last_totalcount;
+    static int kstat_once;      /* if open fails, don't keep
+                                   trying */
+    kstat_ctl_t *kc;
+    kstat_t *khelper;
+    long long idlecount;
+    long long totalcount;
+    long long deltaidle;
+    long long deltatotal;
+
+    if (kstat_once == 1)
+      goto ABORT_KSTAT;
+    kc = kstat_open ();
+    if (kc == NULL)
+      {
+        GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
+                             "kstat_open");
+        goto ABORT_KSTAT;
+      }
+
+    idlecount = 0;
+    totalcount = 0;
+    for (khelper = kc->kc_chain; khelper != NULL; khelper = khelper->ks_next)
+      {
+        cpu_stat_t stats;
+
+        if (0 != strncmp (khelper->ks_name, "cpu_stat", strlen ("cpu_stat")))
+          continue;
+        if (khelper->ks_data_size > sizeof (cpu_stat_t))
+          continue;             /* better save then sorry! */
+        if (-1 != kstat_read (kc, khelper, &stats))
+          {
+            idlecount += stats.cpu_sysinfo.cpu[CPU_IDLE];
+            totalcount
+              += stats.cpu_sysinfo.cpu[CPU_IDLE] +
+              stats.cpu_sysinfo.cpu[CPU_USER] +
+              stats.cpu_sysinfo.cpu[CPU_KERNEL] +
+              stats.cpu_sysinfo.cpu[CPU_WAIT];
+          }
+      }
+    if (0 != kstat_close (kc))
+      GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
+                           "kstat_close");
+    if ((idlecount == 0) && (totalcount == 0))
+      goto ABORT_KSTAT;         /* no stats found => abort */
+    deltaidle = idlecount - last_idlecount;
+    deltatotal = totalcount - last_totalcount;
+    if ((deltatotal > 0) && (last_totalcount > 0))
+      {
+        currentCPULoad = (unsigned int) (100.0 * deltaidle / deltatotal);
+        if (currentCPULoad > 100)
+          currentCPULoad = 100; /* odd */
+        if (currentCPULoad < 0)
+          currentCPULoad = 0;   /* odd */
+        currentCPULoad = 100 - currentCPULoad;  /* computed idle-load before! */
+      }
+    else
+      currentCPULoad = -1;
+    currentIOLoad = -1;         /* FIXME-SOLARIS! */
+    last_idlecount = idlecount;
+    last_totalcount = totalcount;
+    return GNUNET_OK;
+  ABORT_KSTAT:
+    kstat_once = 1;             /* failed, don't try again */
+    return GNUNET_SYSERR;
+  }
+#endif
+
+  /* insert methods better than getloadavg for
+     other platforms HERE! */
+
+  /* ok, maybe we have getloadavg on this platform */
+#if HAVE_GETLOADAVG
+  {
+    static int warnOnce = 0;
+    double loadavg;
+    if (1 != getloadavg (&loadavg, 1))
+      {
+        /* only warn once, if there is a problem with
+           getloadavg, we're going to hit it frequently... */
+        if (warnOnce == 0)
+          {
+            warnOnce = 1;
+            GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "getloadavg");
+          }
+        return GNUNET_SYSERR;
+      }
+    else
+      {
+        /* success with getloadavg */
+        currentCPULoad = (int) (100 * loadavg);
+        currentIOLoad = -1;     /* FIXME */
+        return GNUNET_OK;
+      }
+  }
+#endif
+
+#if MINGW
+  /* Win NT? */
+  if (GNNtQuerySystemInformation)
+    {
+      static double dLastKernel;
+      static double dLastIdle;
+      static double dLastUser;
+      double dKernel;
+      double dIdle;
+      double dUser;
+      double dDiffKernel;
+      double dDiffIdle;
+      double dDiffUser;
+      SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION theInfo;
+
+      if (GNNtQuerySystemInformation (SystemProcessorPerformanceInformation,
+                                      &theInfo,
+                                      sizeof (theInfo), NULL) == NO_ERROR)
+        {
+          /* PORT-ME MINGW: Multi-processor? */
+          dKernel = Li2Double (theInfo.KernelTime);
+          dIdle = Li2Double (theInfo.IdleTime);
+          dUser = Li2Double (theInfo.UserTime);
+          dDiffKernel = dKernel - dLastKernel;
+          dDiffIdle = dIdle - dLastIdle;
+          dDiffUser = dUser - dLastUser;
+
+          if (((dDiffKernel + dDiffUser) > 0) &&
+              (dLastIdle + dLastKernel + dLastUser > 0))
+            currentCPULoad =
+              100.0 - (dDiffIdle / (dDiffKernel + dDiffUser)) * 100.0;
+          else
+            currentCPULoad = -1;        /* don't know (yet) */
+
+          dLastKernel = dKernel;
+          dLastIdle = dIdle;
+          dLastUser = dUser;
+
+          currentIOLoad = -1;   /* FIXME-MINGW */
+          return GNUNET_OK;
+        }
+      else
+        {
+          /* only warn once, if there is a problem with
+             NtQuery..., we're going to hit it frequently... */
+          static int once;
+          if (once == 0)
+            {
+              once = 1;
+              GNUNET_log (GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
+                          _("Cannot query the CPU usage (Windows NT).\n"));
+            }
+          return GNUNET_SYSERR;
+        }
+    }
+  else
+    {                           /* Win 9x */
+      HKEY hKey;
+      DWORD dwDataSize, dwType, dwDummy;
+
+      /* Start query */
+      if (RegOpenKeyEx (HKEY_DYN_DATA,
+                        "PerfStats\\StartSrv",
+                        0, KEY_ALL_ACCESS, &hKey) != ERROR_SUCCESS)
+        {
+          /* only warn once */
+          static int once = 0;
+          if (once == 0)
+            {
+              once = 1;
+              GNUNET_log (GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
+                          _("Cannot query the CPU usage (Win 9x)\n"));
+            }
+        }
+
+      RegOpenKeyEx (HKEY_DYN_DATA,
+                    "PerfStats\\StartStat", 0, KEY_ALL_ACCESS, &hKey);
+      dwDataSize = sizeof (dwDummy);
+      RegQueryValueEx (hKey,
+                       "KERNEL\\CPUUsage",
+                       NULL, &dwType, (LPBYTE) & dwDummy, &dwDataSize);
+      RegCloseKey (hKey);
+
+      /* Get CPU usage */
+      RegOpenKeyEx (HKEY_DYN_DATA,
+                    "PerfStats\\StatData", 0, KEY_ALL_ACCESS, &hKey);
+      dwDataSize = sizeof (currentCPULoad);
+      RegQueryValueEx (hKey,
+                       "KERNEL\\CPUUsage",
+                       NULL, &dwType, (LPBYTE) & currentCPULoad, &dwDataSize);
+      RegCloseKey (hKey);
+      currentIOLoad = -1;       /* FIXME-MINGW! */
+
+      /* Stop query */
+      RegOpenKeyEx (HKEY_DYN_DATA,
+                    "PerfStats\\StopStat", 0, KEY_ALL_ACCESS, &hKey);
+      RegOpenKeyEx (HKEY_DYN_DATA,
+                    "PerfStats\\StopSrv", 0, KEY_ALL_ACCESS, &hKey);
+      dwDataSize = sizeof (dwDummy);
+      RegQueryValueEx (hKey,
+                       "KERNEL\\CPUUsage",
+                       NULL, &dwType, (LPBYTE) & dwDummy, &dwDataSize);
+      RegCloseKey (hKey);
+
+      return GNUNET_OK;
+    }
+#endif
+
+  /* loadaverage not defined and no platform
+     specific alternative defined
+     => default: error
+   */
+  return GNUNET_SYSERR;
+}
+
+/**
+ * Update load values (if enough time has expired),
+ * including computation of averages.  Code assumes
+ * that lock has already been obtained.
+ */
+static void
+updateAgedLoad (struct GNUNET_CONFIGURATION_Handle *cfg)
+{
+  static struct GNUNET_TIME_Absolute lastCall;
+
+  if ((agedCPULoad == -1)
+      || (GNUNET_TIME_absolute_get_duration (lastCall).value > 500))
+    {
+      /* use smoothing, but do NOT update lastRet at frequencies higher
+         than 500ms; this makes the smoothing (mostly) independent from
+         the frequency at which getCPULoad is called (and we don't spend
+         more time measuring CPU than actually computing something). */
+      lastCall = GNUNET_TIME_absolute_get ();
+      updateUsage ();
+      if (currentCPULoad == -1)
+        {
+          agedCPULoad = -1;
+        }
+      else
+        {
+          if (agedCPULoad == -1)
+            {
+              agedCPULoad = currentCPULoad;
+            }
+          else
+            {
+              /* for CPU, we don't do the 'fast increase' since CPU is much
+                 more jitterish to begin with */
+              agedCPULoad = (agedCPULoad * 31 + currentCPULoad) / 32;
+            }
+        }
+      if (currentIOLoad == -1)
+        {
+          agedIOLoad = -1;
+        }
+      else
+        {
+          if (agedIOLoad == -1)
+            {
+              agedIOLoad = currentIOLoad;
+            }
+          else
+            {
+              /* for IO, we don't do the 'fast increase' since IO is much
+                 more jitterish to begin with */
+              agedIOLoad = (agedIOLoad * 31 + currentIOLoad) / 32;
+            }
+        }
+    }
+}
+
+/**
+ * Get the load of the CPU relative to what is allowed.
+ * @return the CPU load as a percentage of allowed
+ *        (100 is equivalent to full load)
+ */
+int
+GNUNET_OS_load_cpu_get (struct GNUNET_CONFIGURATION_Handle *cfg)
+{
+  unsigned long long maxCPULoad;
+  int ret;
+
+  updateAgedLoad (cfg);
+  ret = agedCPULoad;
+  if (ret == -1)
+    return -1;
+  if (GNUNET_OK !=
+      GNUNET_CONFIGURATION_get_value_number (cfg, "LOAD", "MAXCPULOAD",
+                                             &maxCPULoad))
+    return GNUNET_SYSERR;
+  return (100 * ret) / maxCPULoad;
+}
+
+
+/**
+ * Get the load of the CPU relative to what is allowed.
+ * @return the CPU load as a percentage of allowed
+ *        (100 is equivalent to full load)
+ */
+int
+GNUNET_OS_load_disk_get (struct GNUNET_CONFIGURATION_Handle *cfg)
+{
+  unsigned long long maxIOLoad;
+  int ret;
+
+  updateAgedLoad (cfg);
+  ret = agedIOLoad;
+  if (ret == -1)
+    return -1;
+  if (-1 ==
+      GNUNET_CONFIGURATION_get_value_number (cfg, "LOAD", "MAXIOLOAD",
+                                             &maxIOLoad))
+    return GNUNET_SYSERR;
+  return (100 * ret) / maxIOLoad;
+}
+
+/**
+ * The following method is called in order to initialize the status calls
+ * routines.  After that it is safe to call each of the status calls separately
+ * @return GNUNET_OK on success and GNUNET_SYSERR on error (or calls errexit).
+ */
+void __attribute__ ((constructor)) GNUNET_cpustats_ltdl_init ()
+{
+#ifdef LINUX
+  proc_stat = fopen ("/proc/stat", "r");
+  if (NULL == proc_stat)
+    GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_ERROR, "fopen", "/proc/stat");
+#elif OSX
+  initMachCpuStats ();
+#elif MINGW
+  InitWinEnv (NULL);
+#endif
+  updateUsage ();               /* initialize */
+}
+
+/**
+ * Shutdown the status calls module.
+ */
+void __attribute__ ((destructor)) GNUNET_cpustats_ltdl_fini ()
+{
+#ifdef LINUX
+  if (proc_stat != NULL)
+    {
+      fclose (proc_stat);
+      proc_stat = NULL;
+    }
+#elif OSX
+  GNUNET_free_non_null (prev_cpu_load);
+#elif MINGW
+  ShutdownWinEnv ();
+#endif
+}
+
+
+/* end of os_load_cpu.c */
diff --git a/src/util/os_network.c b/src/util/os_network.c
new file mode 100644
index 000000000..cb5ccb12a
--- /dev/null
+++ b/src/util/os_network.c
@@ -0,0 +1,286 @@
+/*
+     This file is part of GNUnet.
+     (C) 2004, 2005, 2006 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 util/os_network.c
+ * @brief function to determine available network interfaces
+ * @author Nils Durner
+ * @author Heikki Lindholm
+ * @author Jake Dust
+ */
+
+#include "platform.h"
+#include "gnunet_common.h"
+#include "gnunet_os_lib.h"
+
+/**
+ * @brief Enumerate all network interfaces
+ * @param callback the callback function
+ */
+void
+GNUNET_OS_network_interfaces_list (GNUNET_OS_NetworkInterfaceProcessor proc,
+                                   void *cls)
+{
+#ifdef MINGW
+  PMIB_IFTABLE pTable;
+  PMIB_IPADDRTABLE pAddrTable;
+  DWORD dwIfIdx, dwExternalNIC;
+  IPAddr theIP;
+
+  /* Determine our external NIC  */
+  theIP = inet_addr ("192.0.34.166");   /* www.example.com */
+  if ((!GNGetBestInterface) ||
+      (GNGetBestInterface (theIP, &dwExternalNIC) != NO_ERROR))
+    {
+      dwExternalNIC = 0;
+    }
+
+  /* Enumerate NICs */
+  EnumNICs (&pTable, &pAddrTable);
+
+  if (pTable)
+    {
+      for (dwIfIdx = 0; dwIfIdx <= pTable->dwNumEntries; dwIfIdx++)
+        {
+          char szEntry[1001];
+          DWORD dwIP = 0;
+          int iItm;
+          PIP_ADAPTER_INFO pAdapterInfo;
+          PIP_ADAPTER_INFO pAdapter = NULL;
+          DWORD dwRetVal = 0;
+
+          /* Get IP-Address */
+          int i;
+          for (i = 0; i < pAddrTable->dwNumEntries; i++)
+            {
+              if (pAddrTable->table[i].dwIndex ==
+                  pTable->table[dwIfIdx].dwIndex)
+                {
+                  dwIP = pAddrTable->table[i].dwAddr;
+                  break;
+                }
+            }
+
+          if (dwIP)
+            {
+              BYTE bPhysAddr[MAXLEN_PHYSADDR];
+              char *pszIfName = NULL;
+              char dst[INET_ADDRSTRLEN];
+
+              /* Get friendly interface name */
+              pAdapterInfo =
+                (IP_ADAPTER_INFO *) malloc (sizeof (IP_ADAPTER_INFO));
+              ULONG ulOutBufLen = sizeof (IP_ADAPTER_INFO);
+
+              /* Make an initial call to GetAdaptersInfo to get
+                 the necessary size into the ulOutBufLen variable */
+              if (GGetAdaptersInfo (pAdapterInfo, &ulOutBufLen) ==
+                  ERROR_BUFFER_OVERFLOW)
+                {
+                  free (pAdapterInfo);
+                  pAdapterInfo = (IP_ADAPTER_INFO *) malloc (ulOutBufLen);
+                }
+
+              if ((dwRetVal =
+                   GGetAdaptersInfo (pAdapterInfo, &ulOutBufLen)) == NO_ERROR)
+                {
+                  pAdapter = pAdapterInfo;
+                  while (pAdapter)
+                    {
+                      if (pTable->table[dwIfIdx].dwIndex == pAdapter->Index)
+                        {
+                          char szKey[251];
+                          long lLen = 250;
+
+                          sprintf (szKey,
+                                   "SYSTEM\\CurrentControlSet\\Control\\Network\\"
+                                   "{4D36E972-E325-11CE-BFC1-08002BE10318}\\%s\\Connection",
+                                   pAdapter->AdapterName);
+                          pszIfName = (char *) malloc (251);
+                          if (QueryRegistry
+                              (HKEY_LOCAL_MACHINE, szKey, "Name", pszIfName,
+                               &lLen) != ERROR_SUCCESS)
+                            {
+                              free (pszIfName);
+                              pszIfName = NULL;
+                            }
+                        }
+                      pAdapter = pAdapter->Next;
+                    }
+                }
+              free (pAdapterInfo);
+
+              /* Set entry */
+              memset (bPhysAddr, 0, MAXLEN_PHYSADDR);
+              memcpy (bPhysAddr,
+                      pTable->table[dwIfIdx].bPhysAddr,
+                      pTable->table[dwIfIdx].dwPhysAddrLen);
+
+              snprintf (szEntry, 1000, "%s (%s - %I64u)",
+                        pszIfName ? pszIfName : (char *) pTable->
+                        table[dwIfIdx].bDescr, inet_ntop (AF_INET, &dwIP, dst,
+                                                          INET_ADDRSTRLEN),
+                        *((unsigned long long *) bPhysAddr));
+              szEntry[1000] = 0;
+
+              if (pszIfName)
+                free (pszIfName);
+
+              if (GNUNET_OK !=
+                  proc (cls,
+                        szEntry,
+                        pAddrTable->table[dwIfIdx].dwIndex == dwExternalNIC,
+                        NULL /* FIXME: pass actual IP address! */ ,
+                        0))
+                break;
+            }
+        }
+      GlobalFree (pAddrTable);
+      GlobalFree (pTable);
+    }
+
+  return GNUNET_YES;
+
+#elif HAVE_GETIFADDRS && HAVE_FREEIFADDRS
+
+  struct ifaddrs *ifa_first;
+  socklen_t alen;
+
+  if (getifaddrs (&ifa_first) == 0)
+    {
+      struct ifaddrs *ifa_ptr;
+
+      ifa_ptr = ifa_first;
+      for (ifa_ptr = ifa_first; ifa_ptr != NULL; ifa_ptr = ifa_ptr->ifa_next)
+        {
+          if (ifa_ptr->ifa_name != NULL &&
+              ifa_ptr->ifa_addr != NULL && (ifa_ptr->ifa_flags & IFF_UP) != 0)
+            {
+              if ((ifa_ptr->ifa_addr->sa_family != AF_INET) &&
+                  (ifa_ptr->ifa_addr->sa_family != AF_INET6))
+                continue;
+              if (ifa_ptr->ifa_addr->sa_family == AF_INET)
+                alen = sizeof (struct sockaddr_in);
+              else
+                alen = sizeof (struct sockaddr_in6);
+              if (GNUNET_OK != proc (cls,
+                                     ifa_ptr->ifa_name,
+                                     0 == strcmp (ifa_ptr->ifa_name,
+                                                  GNUNET_DEFAULT_INTERFACE),
+                                     ifa_ptr->ifa_addr, alen))
+                break;
+            }
+        }
+      freeifaddrs (ifa_first);
+    }
+#else
+  char line[1024];
+  const char *start;
+  char ifc[12];
+  char addrstr[128];
+  FILE *f;
+  int have_ifc;
+  struct sockaddr_in a4;
+  struct sockaddr_in6 a6;
+  struct in_addr v4;
+  struct in6_addr v6;
+
+  if (system ("ifconfig -a > /dev/null 2> /dev/null"))
+    if (system ("/sbin/ifconfig -a > /dev/null 2> /dev/null") == 0)
+      f = popen ("/sbin/ifconfig -a 2> /dev/null", "r");
+    else
+      f = NULL;
+  else
+    f = popen ("ifconfig -a 2> /dev/null", "r");
+  if (!f)
+    {
+      GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING |
+                                GNUNET_ERROR_TYPE_BULK, "popen", "ifconfig");
+      return;
+    }
+
+  have_ifc = GNUNET_NO;
+  ifc[11] = '\0';
+  while (NULL != fgets (line, sizeof (line), f))
+    {
+      if (strlen (line) == 0)
+        {
+          have_ifc = GNUNET_NO;
+          continue;
+        }
+      if (!isspace (line[0]))
+        {
+          have_ifc =
+            (1 == SSCANF (line, "%11s", ifc)) ? GNUNET_YES : GNUNET_NO;
+          /* would end with ':' on OSX, fix it! */
+          if (ifc[strlen (ifc) - 1] == ':')
+            ifc[strlen (ifc) - 1] = '\0';
+          continue;
+        }
+      if (!have_ifc)
+        continue;               /* strange input, hope for the best */
+      start = line;
+      while (('\0' != *start) && (isspace (*start)))
+        start++;
+      if (                      /* Linux */
+           (1 == SSCANF (start, "inet addr:%127s", addrstr)) ||
+           (1 == SSCANF (start, "inet6 addr:%127s", addrstr)) ||
+           /* Solaris, OS X */
+           (1 == SSCANF (start, "inet %127s", addrstr)) ||
+           (1 == SSCANF (start, "inet6 %127s", addrstr)))
+        {
+          /* IPv4 */
+          if (1 == inet_pton (AF_INET, addrstr, &v4))
+            {
+              memset (&a4, 0, sizeof (a4));
+              a4.sin_family = AF_INET;
+              a4.sin_addr = v4;
+              if (GNUNET_OK !=
+                  proc (cls,
+                        ifc,
+                        0 == strcmp (ifc, GNUNET_DEFAULT_INTERFACE),
+                        (const struct sockaddr *) &a4, sizeof (a4)))
+                break;
+              continue;
+            }
+          /* IPv6 */
+          if (1 == inet_pton (AF_INET6, addrstr, &v6))
+            {
+              memset (&a6, 0, sizeof (a6));
+              a6.sin6_family = AF_INET6;
+              a6.sin6_addr = v6;
+              fprintf (stderr, "procing %s\n", addrstr);
+              if (GNUNET_OK !=
+                  proc (cls,
+                        ifc,
+                        0 == strcmp (ifc, GNUNET_DEFAULT_INTERFACE),
+                        (const struct sockaddr *) &a6, sizeof (a6)))
+                break;
+              continue;
+            }
+        }
+    }
+  pclose (f);
+#endif
+}
+
+
+/* end of os_network.c */
diff --git a/src/util/os_priority.c b/src/util/os_priority.c
new file mode 100644
index 000000000..7862d68e9
--- /dev/null
+++ b/src/util/os_priority.c
@@ -0,0 +1,186 @@
+/*
+     This file is part of GNUnet
+     (C) 2002, 2003, 2004, 2005, 2006 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 util/os/priority.c
+ * @brief Methods to set process priority
+ * @author Nils Durner
+ */
+
+#include "platform.h"
+#include "gnunet_common.h"
+#include "gnunet_os_lib.h"
+
+/**
+ * Set our process priority
+ */
+int
+GNUNET_OS_set_process_priority (pid_t proc,
+                                enum GNUNET_SCHEDULER_Priority eprio)
+{
+  int prio = 0;
+
+  GNUNET_assert (eprio < GNUNET_SCHEDULER_PRIORITY_COUNT);
+  if (eprio == GNUNET_SCHEDULER_PRIORITY_KEEP)
+    return GNUNET_OK;
+  /* convert to MINGW/Unix values */
+  switch (eprio)
+    {
+    case GNUNET_SCHEDULER_PRIORITY_DEFAULT:
+#ifdef MINGW
+      prio = NORMAL_PRIORITY_CLASS;
+#else
+      prio = 0;
+#endif
+      break;
+    case GNUNET_SCHEDULER_PRIORITY_HIGH:
+#ifdef MINGW
+      prio = ABOVE_NORMAL_PRIORITY_CLASS;
+#else
+      prio = -5;
+#endif
+      break;
+    case GNUNET_SCHEDULER_PRIORITY_BACKGROUND:
+#ifdef MINGW
+      prio = BELOW_NORMAL_PRIORITY_CLASS;
+#else
+      prio = 10;
+#endif
+      break;
+    case GNUNET_SCHEDULER_PRIORITY_UI:
+    case GNUNET_SCHEDULER_PRIORITY_URGENT:
+#ifdef MINGW
+      prio = HIGH_PRIORITY_CLASS;
+#else
+      prio = -10;
+#endif
+      break;
+    case GNUNET_SCHEDULER_PRIORITY_IDLE:
+#ifdef MINGW
+      prio = IDLE_PRIORITY_CLASS;
+#else
+      prio = 19;
+#endif
+      break;
+    default:
+      GNUNET_assert (0);
+      return GNUNET_SYSERR;
+    }
+  /* Set process priority */
+#ifdef MINGW
+  SetPriorityClass (GetCurrentProcess (), prio);
+#else
+  if (proc == getpid ())
+    {
+      errno = 0;
+      if ((-1 == nice (prio)) && (errno != 0))
+        {
+          GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING |
+                               GNUNET_ERROR_TYPE_BULK, "nice");
+          return GNUNET_SYSERR;
+        }
+    }
+  else
+    {
+      if (0 != setpriority (PRIO_PROCESS, proc, prio))
+
+        {
+          GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING |
+                               GNUNET_ERROR_TYPE_BULK, "setpriority");
+          return GNUNET_SYSERR;
+        }
+    }
+#endif
+  return GNUNET_OK;
+}
+
+
+
+/**
+ * Start a process.
+ *
+ * @param filename name of the binary
+ * @param ... NULL-terminated list of arguments to the process
+ * @return process ID of the new process, -1 on error
+ */
+pid_t
+GNUNET_OS_start_process (const char *filename, ...)
+{
+  pid_t ret;
+  char **argv;
+  va_list ap;
+  int argc;
+
+  ret = fork ();
+  if (ret != 0)
+    {
+      if (ret == -1)
+        GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "fork");
+      return ret;
+    }
+  argc = 0;
+  va_start (ap, filename);
+  while (NULL != va_arg (ap, char *))
+      argc++;
+  va_end (ap);
+  argv = GNUNET_malloc (sizeof (char *) * (argc + 1));
+  argc = 0;
+  va_start (ap, filename);
+  while (NULL != (argv[argc] = va_arg (ap, char *)))
+      argc++;
+  va_end (ap);
+  execvp (filename, argv);
+  GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_ERROR, "execvp", filename);
+  exit (1);
+}
+
+
+
+
+/**
+ * Start a process.
+ *
+ * @param filename name of the binary
+ * @param argv NULL-terminated list of arguments to the process
+ * @return process ID of the new process, -1 on error
+ */
+pid_t
+GNUNET_OS_start_process_v (const char *filename, char *const argv[])
+{
+  pid_t ret;
+
+  ret = fork ();
+  if (ret != 0)
+    {
+      if (ret == -1)
+        GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "fork");
+      return ret;
+    }
+  execvp (filename, argv);
+  GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_ERROR, "execvp", filename);
+  exit (1);
+}
+
+
+
+
+
+
+/* end of os_priority.c */
diff --git a/src/util/perf_crypto_hash.c b/src/util/perf_crypto_hash.c
new file mode 100644
index 000000000..a6f6ba340
--- /dev/null
+++ b/src/util/perf_crypto_hash.c
@@ -0,0 +1,64 @@
+/*
+     This file is part of GNUnet.
+     (C) 2002, 2003, 2004, 2006 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.
+*/
+
+/**
+ * @author Christian Grothoff
+ * @file util/perf_crypto_hash.c
+ * @brief measure performance of hash function
+ */
+#include "platform.h"
+#include "gnunet_common.h"
+#include "gnunet_crypto_lib.h"
+#include "gnunet_time_lib.h"
+
+static void
+perfHash ()
+{
+  GNUNET_HashCode hc1;
+  GNUNET_HashCode hc2;
+  GNUNET_HashCode hc3;
+  int i;
+  char *buf;
+
+  buf = GNUNET_malloc (1024 * 64);
+  memset (buf, 1, 1024 * 64);
+  GNUNET_CRYPTO_hash ("foo", 3, &hc1);
+  for (i = 0; i < 1024; i++)
+    {
+      GNUNET_CRYPTO_hash (&hc1, sizeof (GNUNET_HashCode), &hc2);
+      GNUNET_CRYPTO_hash (&hc2, sizeof (GNUNET_HashCode), &hc1);
+      GNUNET_CRYPTO_hash (buf, 1024 * 64, &hc3);
+    }
+  GNUNET_free (buf);
+}
+
+int
+main (int argc, char *argv[])
+{
+  struct GNUNET_TIME_Absolute start;
+
+  start = GNUNET_TIME_absolute_get ();
+  perfHash ();
+  printf ("Hash perf took %llu ms\n",
+          GNUNET_TIME_absolute_get_duration (start).value);
+  return 0;
+}
+
+/* end of hashperf.c */
diff --git a/src/util/plugin.c b/src/util/plugin.c
new file mode 100644
index 000000000..d26a343c7
--- /dev/null
+++ b/src/util/plugin.c
@@ -0,0 +1,243 @@
+/*
+     This file is part of GNUnet
+     (C) 2002, 2003, 2004, 2005, 2006, 2009 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 util/plugin.c
+ * @brief Methods to access plugins
+ * @author Christian Grothoff
+ */
+
+#include "platform.h"
+#include <libltdl/ltdl.h>
+#include "gnunet_common.h"
+#include "gnunet_os_lib.h"
+#include "gnunet_plugin_lib.h"
+
+/**
+ * Linked list of active plugins.
+ */
+struct PluginList
+{
+  /**
+   * This is a linked list.
+   */
+  struct PluginList *next;
+
+  /**
+   * Name of the library.
+   */
+  char *name;
+
+  /**
+   * System handle.
+   */
+  void *handle;
+};
+
+
+/**
+ * Libtool search path before we started.
+ */
+static char *old_dlsearchpath;
+
+
+/**
+ * List of plugins we have loaded.
+ */
+static struct PluginList *plugins;
+
+
+/**
+ * Setup libtool paths.
+ */
+void __attribute__ ((constructor)) GNUNET_PLUGIN_init ()
+{
+  int err;
+  const char *opath;
+  char *path;
+  char *cpath;
+
+#ifdef MINGW
+  InitWinEnv (NULL);
+#endif
+
+  err = lt_dlinit ();
+  if (err > 0)
+    {
+      fprintf (stderr,
+               _("Initialization of plugin mechanism failed: %s!\n"),
+               lt_dlerror ());
+      return;
+    }
+  opath = lt_dlgetsearchpath ();
+  if (opath != NULL)
+    old_dlsearchpath = GNUNET_strdup (opath);
+  path = GNUNET_OS_installation_get_path (GNUNET_OS_IPK_LIBDIR);
+  if (path != NULL)
+    {
+      if (opath != NULL)
+        {
+          cpath = GNUNET_malloc (strlen (path) + strlen (opath) + 4);
+          strcpy (cpath, opath);
+          strcat (cpath, ":");
+          strcat (cpath, path);
+          lt_dlsetsearchpath (cpath);
+          GNUNET_free (path);
+          GNUNET_free (cpath);
+        }
+      else
+        {
+          lt_dlsetsearchpath (path);
+          GNUNET_free (path);
+        }
+    }
+}
+
+
+/**
+ * Shutdown libtool.
+ */
+void __attribute__ ((destructor)) GNUNET_PLUGIN_fini ()
+{
+  lt_dlsetsearchpath (old_dlsearchpath);
+  if (old_dlsearchpath != NULL)
+    {
+      GNUNET_free (old_dlsearchpath);
+      old_dlsearchpath = NULL;
+    }
+
+#ifdef MINGW
+  ShutdownWinEnv ();
+#endif
+
+  lt_dlexit ();
+}
+
+
+/**
+ * Lookup a function in the plugin.
+ */
+static GNUNET_PLUGIN_Callback
+resolve_function (struct PluginList *plug, const char *name)
+{
+  char *initName;
+  void *mptr;
+
+  GNUNET_asprintf (&initName, "_%s_%s", plug->name, name);
+  mptr = lt_dlsym (plug->handle, &initName[1]);
+  if (mptr == NULL)
+    mptr = lt_dlsym (plug->handle, initName);
+  if (mptr == NULL)
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                _("`%s' failed to resolve method '%s' with error: %s\n"),
+                "lt_dlsym", &initName[1], lt_dlerror ());
+  GNUNET_free (initName);
+  return mptr;
+}
+
+
+/**
+ * Setup plugin (runs the "init" callback and returns whatever "init"
+ * returned).  If "init" returns NULL, the plugin is unloaded.
+ *
+ * Note that the library must export symbols called
+ * "library_name_init" and "library_name_done".  These will be called
+ * when the library is loaded and unloaded respectively.
+ *
+ * @param library_name name of the plugin to load
+ * @param arg argument to the plugin initialization function
+ * @return whatever the initialization function returned
+ */
+void *
+GNUNET_PLUGIN_load (const char *library_name, void *arg)
+{
+  void *libhandle;
+  struct PluginList *plug;
+  GNUNET_PLUGIN_Callback init;
+  void *ret;
+
+  libhandle = lt_dlopenext (library_name);
+  if (libhandle == NULL)
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                  _("`%s' failed for library `%s' with error: %s\n"),
+                  "lt_dlopenext", library_name, lt_dlerror ());
+      return NULL;
+    }
+  plug = GNUNET_malloc (sizeof (struct PluginList));
+  plug->handle = libhandle;
+  plug->name = GNUNET_strdup (library_name);
+  plug->next = plugins;
+  plugins = plug;
+  init = resolve_function (plug, "init");
+  if ((init == NULL) || (NULL == (ret = init (arg))))
+    {
+      GNUNET_free (plug->name);
+      plugins = plug->next;
+      GNUNET_free (plug);
+      return NULL;
+    }
+  return ret;
+}
+
+
+/**
+ * Unload plugin (runs the "done" callback and returns whatever "done"
+ * returned).  The plugin is then unloaded.
+ *
+ * @param library_name name of the plugin to unload
+ * @param arg argument to the plugin shutdown function
+ * @return whatever the shutdown function returned
+ */
+void *
+GNUNET_PLUGIN_unload (const char *library_name, void *arg)
+{
+  struct PluginList *pos;
+  struct PluginList *prev;
+  GNUNET_PLUGIN_Callback done;
+  void *ret;
+
+  prev = NULL;
+  pos = plugins;
+  while ((pos != NULL) && (0 != strcmp (pos->name, library_name)))
+    {
+      prev = pos;
+      pos = pos->next;
+    }
+  if (pos == NULL)
+    return NULL;
+
+  done = resolve_function (pos, "done");
+  ret = NULL;
+  if (done != NULL)
+    ret = done (arg);
+  if (prev == NULL)
+    plugins = pos->next;
+  else
+    prev->next = pos->next;
+  // lt_dlclose (pos->handle);
+  GNUNET_free (pos->name);
+  GNUNET_free (pos);
+  return ret;
+}
+
+
+
+/* end of plugin.c */
diff --git a/src/util/program.c b/src/util/program.c
new file mode 100644
index 000000000..c8ebfc4eb
--- /dev/null
+++ b/src/util/program.c
@@ -0,0 +1,202 @@
+/*
+     This file is part of GNUnet.
+     (C) 2009 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 util/program.c
+ * @brief standard code for GNUnet startup and shutdown
+ * @author Christian Grothoff
+ */
+
+#include "platform.h"
+#include "gnunet_common.h"
+#include "gnunet_configuration_lib.h"
+#include "gnunet_crypto_lib.h"
+#include "gnunet_directories.h"
+#include "gnunet_getopt_lib.h"
+#include "gnunet_os_lib.h"
+#include "gnunet_program_lib.h"
+#include "gnunet_scheduler_lib.h"
+#include <gcrypt.h>
+
+/**
+ * Context for the command.
+ */
+struct CommandContext
+{
+  /**
+   * Argv argument.
+   */
+  char *const *args;
+
+  /**
+   * Name of the configuration file used, can be NULL!
+   */
+  char *cfgfile;
+
+  /**
+   * Main function to run.
+   */
+  GNUNET_PROGRAM_Main task;
+
+  /**
+   * Closure for task.
+   */
+  void *task_cls;
+
+  /**
+   * Configuration to use.
+   */
+  struct GNUNET_CONFIGURATION_Handle *cfg;
+
+};
+
+
+/**
+ * Initial task called by the scheduler for each
+ * program.  Runs the program-specific main task.
+ */
+static void
+program_main (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+{
+  struct CommandContext *cc = cls;
+
+  cc->task (cc->task_cls, tc->sched, cc->args, cc->cfgfile, cc->cfg);
+}
+
+
+/**
+ * Compare function for 'qsort' to sort command-line arguments by the
+ * short option.
+ */
+static int
+cmd_sorter (const void *a1, const void *a2)
+{
+  const struct GNUNET_GETOPT_CommandLineOption *c1 = a1;
+  const struct GNUNET_GETOPT_CommandLineOption *c2 = a2;
+  if (toupper (c1->shortName) > toupper (c2->shortName))
+    return 1;
+  if (toupper (c1->shortName) < toupper (c2->shortName))
+    return -1;
+  if (c1->shortName > c2->shortName)
+    return 1;
+  if (c1->shortName < c2->shortName)
+    return -1;
+  return 0;
+}
+
+
+/**
+ * Run a standard GNUnet command startup sequence (initialize loggers
+ * and configuration, parse options).
+ *
+ * @param argc number of command line arguments
+ * @param argv command line arguments
+ * @param binaryName our expected name
+ * @param options command line options
+ * @param task main function to run
+ * @param task_cls closure for task
+ * @return GNUNET_SYSERR on error, GNUNET_OK on success
+ */
+int
+GNUNET_PROGRAM_run (int argc,
+                    char *const *argv,
+                    const char *binaryName,
+                    const char *binaryHelp,
+                    const struct GNUNET_GETOPT_CommandLineOption *options,
+                    GNUNET_PROGRAM_Main task, void *task_cls)
+{
+  struct CommandContext cc;
+  char *path;
+  char *loglev;
+  int ret;
+  unsigned int cnt;
+  struct GNUNET_GETOPT_CommandLineOption defoptions[] = {
+    GNUNET_GETOPT_OPTION_CFG_FILE (&cc.cfgfile),
+    GNUNET_GETOPT_OPTION_HELP (binaryHelp),
+    GNUNET_GETOPT_OPTION_LOGLEVEL (&loglev),
+    GNUNET_GETOPT_OPTION_VERSION (PACKAGE_VERSION)
+  };
+  struct GNUNET_GETOPT_CommandLineOption *allopts;
+
+  memset (&cc, 0, sizeof (cc));
+  loglev = NULL;
+  cc.task = task;
+  cc.task_cls = task_cls;
+  cc.cfg = GNUNET_CONFIGURATION_create ();
+
+  /* prepare */
+#if ENABLE_NLS
+  setlocale (LC_ALL, "");
+  path = GNUNET_OS_installation_get_path (GNUNET_OS_IPK_LOCALEDIR);
+  if (path != NULL)
+    {
+      BINDTEXTDOMAIN ("GNUnet", path);
+      GNUNET_free (path);
+    }
+  textdomain ("GNUnet");
+#endif
+  cnt = 0;
+  while (options[cnt].name != NULL)
+    cnt++;
+  allopts =
+    GNUNET_malloc ((cnt +
+                    1) * sizeof (struct GNUNET_GETOPT_CommandLineOption) +
+                   sizeof (defoptions));
+  memcpy (allopts, defoptions, sizeof (defoptions));
+  memcpy (&allopts
+          [sizeof (defoptions) /
+           sizeof (struct GNUNET_GETOPT_CommandLineOption)], options,
+          (cnt + 1) * sizeof (struct GNUNET_GETOPT_CommandLineOption));
+  cnt +=
+    sizeof (defoptions) / sizeof (struct GNUNET_GETOPT_CommandLineOption);
+  qsort (allopts, cnt, sizeof (struct GNUNET_GETOPT_CommandLineOption),
+         &cmd_sorter);
+  loglev = GNUNET_strdup ("WARNING");
+  if ((-1 == (ret = GNUNET_GETOPT_run (binaryName,
+                                       cc.cfg,
+                                       allopts,
+                                       (unsigned int) argc, argv))) ||
+      ((GNUNET_OK !=
+        GNUNET_log_setup (binaryName,
+                          loglev,
+                          NULL)) ||
+       (GNUNET_OK != GNUNET_CONFIGURATION_load (cc.cfg, cc.cfgfile))))
+
+    {
+      GNUNET_free_non_null (cc.cfgfile);
+      GNUNET_free (loglev);
+      GNUNET_free (allopts);
+      return GNUNET_SYSERR;
+    }
+  GNUNET_free (allopts);
+
+  /* run */
+  cc.args = &argv[ret];
+  GNUNET_SCHEDULER_run (&program_main, &cc);
+
+  /* clean up */
+  GNUNET_CONFIGURATION_destroy (cc.cfg);
+  GNUNET_free_non_null (cc.cfgfile);
+  GNUNET_free (loglev);
+  return GNUNET_OK;
+}
+
+
+/* end of program.c */
diff --git a/src/util/pseudonym.c b/src/util/pseudonym.c
new file mode 100644
index 000000000..6d9146613
--- /dev/null
+++ b/src/util/pseudonym.c
@@ -0,0 +1,545 @@
+/*
+     This file is part of GNUnet
+     (C) 2003, 2004, 2005, 2006, 2007, 2008 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 util/pseudonym.c
+ * @brief helper functions
+ * @author Christian Grothoff
+ */
+
+#include "platform.h"
+#include "gnunet_common.h"
+#include "gnunet_container_lib.h"
+#include "gnunet_disk_lib.h"
+#include "gnunet_pseudonym_lib.h"
+
+#define PS_METADATA_DIR DIR_SEPARATOR_STR "data" DIR_SEPARATOR_STR "pseudonyms/metadata" DIR_SEPARATOR_STR
+#define PS_NAMES_DIR    DIR_SEPARATOR_STR "data" DIR_SEPARATOR_STR "pseudonyms/names"    DIR_SEPARATOR_STR
+
+struct DiscoveryCallback
+{
+  struct DiscoveryCallback *next;
+  GNUNET_PSEUDONYM_Iterator callback;
+  void *closure;
+};
+
+static struct DiscoveryCallback *head;
+
+/**
+ * Internal notification about new tracked URI.
+ */
+static void
+internal_notify (const GNUNET_HashCode * id,
+                 const struct GNUNET_CONTAINER_MetaData *md, int rating)
+{
+  struct DiscoveryCallback *pos;
+
+  pos = head;
+  while (pos != NULL)
+    {
+      pos->callback (pos->closure, id, md, rating);
+      pos = pos->next;
+    }
+}
+
+/**
+ * Register callback to be invoked whenever we discover
+ * a new pseudonym.
+ */
+int
+GNUNET_PSEUDONYM_discovery_callback_register (struct
+                                              GNUNET_CONFIGURATION_Handle
+                                              *cfg,
+                                              GNUNET_PSEUDONYM_Iterator
+                                              iterator, void *closure)
+{
+  struct DiscoveryCallback *list;
+
+  list = GNUNET_malloc (sizeof (struct DiscoveryCallback));
+  list->callback = iterator;
+  list->closure = closure;
+  list->next = head;
+  head = list;
+  GNUNET_PSEUDONYM_list_all (cfg, iterator, closure);
+  return GNUNET_OK;
+}
+
+/**
+ * Unregister pseudonym discovery callback.
+ */
+int
+GNUNET_PSEUDONYM_discovery_callback_unregister (GNUNET_PSEUDONYM_Iterator
+                                                iterator, void *closure)
+{
+  struct DiscoveryCallback *prev;
+  struct DiscoveryCallback *pos;
+
+  prev = NULL;
+  pos = head;
+  while ((pos != NULL) &&
+         ((pos->callback != iterator) || (pos->closure != closure)))
+    {
+      prev = pos;
+      pos = pos->next;
+    }
+  if (pos == NULL)
+    return GNUNET_SYSERR;
+  if (prev == NULL)
+    head = pos->next;
+  else
+    prev->next = pos->next;
+  GNUNET_free (pos);
+  return GNUNET_OK;
+}
+
+
+/**
+ * Get the filename (or directory name) for the given
+ * pseudonym identifier and directory prefix.
+ */
+static char *
+get_data_filename (struct GNUNET_CONFIGURATION_Handle
+                   *cfg, const char *prefix, const GNUNET_HashCode * psid)
+{
+  struct GNUNET_CRYPTO_HashAsciiEncoded enc;
+
+  if (psid != NULL)
+    GNUNET_CRYPTO_hash_to_enc (psid, &enc);
+  return GNUNET_DISK_get_home_filename (cfg,
+                                        GNUNET_CLIENT_SERVICE_NAME,
+                                        prefix,
+                                        (psid ==
+                                         NULL) ? NULL : (const char *) &enc,
+                                        NULL);
+}
+
+static void
+write_pseudonym_info (struct GNUNET_CONFIGURATION_Handle *cfg,
+                      const GNUNET_HashCode * nsid,
+                      const struct GNUNET_CONTAINER_MetaData *meta,
+                      int32_t ranking, const char *ns_name)
+{
+  unsigned int size;
+  unsigned int tag;
+  unsigned int off;
+  char *buf;
+  char *fn;
+
+  fn = get_data_filename (cfg, PS_METADATA_DIR, nsid);
+  GNUNET_assert (fn != NULL);
+  size = GNUNET_CONTAINER_meta_data_get_serialized_size (meta,
+                                                         GNUNET_CONTAINER_META_DATA_SERIALIZE_FULL);
+  tag = size + sizeof (int) + 1;
+  off = 0;
+  if (ns_name != NULL)
+    {
+      off = strlen (ns_name);
+      tag += off;
+    }
+  buf = GNUNET_malloc (tag);
+  ((int *) buf)[0] = htonl (ranking);   /* ranking */
+  if (ns_name != NULL)
+    {
+      memcpy (&buf[sizeof (int)], ns_name, off + 1);
+    }
+  else
+    {
+      buf[sizeof (int)] = '\0';
+    }
+  GNUNET_assert
+    (size == GNUNET_CONTAINER_meta_data_serialize (meta,
+                                                   &buf[sizeof
+                                                        (int) +
+                                                        off + 1],
+                                                   size,
+                                                   GNUNET_CONTAINER_META_DATA_SERIALIZE_FULL));
+  GNUNET_DISK_file_write (fn, buf, tag, "660");
+  GNUNET_free (fn);
+  GNUNET_free (buf);
+  /* create entry for pseudonym name in names */
+  GNUNET_free_non_null (GNUNET_PSEUDONYM_id_to_name (cfg, nsid));
+}
+
+static int
+read_info (struct GNUNET_CONFIGURATION_Handle *cfg,
+           const GNUNET_HashCode * nsid,
+           struct GNUNET_CONTAINER_MetaData **meta,
+           int32_t * ranking, char **ns_name)
+{
+  unsigned long long len;
+  unsigned int size;
+  unsigned int zend;
+  struct stat sbuf;
+  char *buf;
+  char *fn;
+
+  if (meta != NULL)
+    *meta = NULL;
+  if (ns_name != NULL)
+    *ns_name = NULL;
+  fn = get_data_filename (cfg, PS_METADATA_DIR, nsid);
+  GNUNET_assert (fn != NULL);
+
+  if ((0 != STAT (fn, &sbuf))
+      || (GNUNET_OK != GNUNET_DISK_file_size (fn, &len, GNUNET_YES)))
+    {
+      GNUNET_free (fn);
+      return GNUNET_SYSERR;
+    }
+  if (len <= sizeof (int) + 1)
+    {
+      GNUNET_free (fn);
+      return GNUNET_SYSERR;
+    }
+  if (len > 16 * 1024 * 1024)
+    {
+      /* too big, must be invalid! remove! */
+      GNUNET_break (0);
+      if (0 != UNLINK (fn))
+        GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING, "unlink", fn);
+      GNUNET_free (fn);
+      return GNUNET_SYSERR;
+    }
+  buf = GNUNET_malloc (len);
+  if (len != GNUNET_DISK_file_read (fn, len, buf))
+    {
+      GNUNET_free (buf);
+      GNUNET_free (fn);
+      return GNUNET_SYSERR;
+    }
+  if (ranking != NULL)
+    *ranking = ntohl (((int *) buf)[0]);
+  zend = sizeof (int);
+  while ((zend < len) && (buf[zend] != '\0'))
+    zend++;
+  if (zend == len)
+    {
+      GNUNET_free (buf);
+      GNUNET_free (fn);
+      return GNUNET_SYSERR;
+    }
+  if (ns_name != NULL)
+    {
+      if (zend != sizeof (int))
+        *ns_name = GNUNET_strdup (&buf[sizeof (int)]);
+      else
+        *ns_name = NULL;
+    }
+  zend++;
+  size = len - zend;
+  if (meta != NULL)
+    {
+      *meta = GNUNET_CONTAINER_meta_data_deserialize (&buf[zend], size);
+      if ((*meta) == NULL)
+        {
+          /* invalid data! remove! */
+          GNUNET_break (0);
+          if (0 != UNLINK (fn))
+            GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING,
+                                      "unlink", fn);
+          GNUNET_free (buf);
+          GNUNET_free (fn);
+          return GNUNET_SYSERR;
+        }
+    }
+  GNUNET_free (fn);
+  GNUNET_free (buf);
+  return GNUNET_OK;
+}
+
+
+
+/**
+ * Return the unique, human readable name for the given namespace.
+ *
+ * @return NULL on failure (should never happen)
+ */
+char *
+GNUNET_PSEUDONYM_id_to_name (struct GNUNET_CONFIGURATION_Handle *cfg,
+                             const GNUNET_HashCode * nsid)
+{
+  struct GNUNET_CONTAINER_MetaData *meta;
+  char *name;
+  GNUNET_HashCode nh;
+  char *fn;
+  unsigned long long len;
+  int fd;
+  unsigned int i;
+  unsigned int idx;
+  char *ret;
+  struct stat sbuf;
+
+  meta = NULL;
+  name = NULL;
+  if (GNUNET_OK == read_info (cfg, nsid, &meta, NULL, &name))
+    {
+      if ((meta != NULL) && (name == NULL))
+        name = GNUNET_CONTAINER_meta_data_get_first_by_types (meta,
+                                                              EXTRACTOR_TITLE,
+                                                              EXTRACTOR_FILENAME,
+                                                              EXTRACTOR_DESCRIPTION,
+                                                              EXTRACTOR_SUBJECT,
+                                                              EXTRACTOR_PUBLISHER,
+                                                              EXTRACTOR_AUTHOR,
+                                                              EXTRACTOR_COMMENT,
+                                                              EXTRACTOR_SUMMARY,
+                                                              EXTRACTOR_OWNER,
+                                                              -1);
+      if (meta != NULL)
+        {
+          GNUNET_CONTAINER_meta_data_destroy (meta);
+          meta = NULL;
+        }
+    }
+  if (name == NULL)
+    name = GNUNET_strdup (_("no-name"));
+  GNUNET_CRYPTO_hash (name, strlen (name), &nh);
+  fn = get_data_filename (cfg, PS_NAMES_DIR, &nh);
+  GNUNET_assert (fn != NULL);
+
+  len = 0;
+  if (0 == STAT (fn, &sbuf))
+    GNUNET_DISK_file_size (fn, &len, GNUNET_YES);
+  fd = GNUNET_DISK_file_open (fn, O_CREAT | O_RDWR, S_IRUSR | S_IWUSR);
+  i = 0;
+  idx = -1;
+  while ((len >= sizeof (GNUNET_HashCode)) &&
+         (sizeof (GNUNET_HashCode)
+          == READ (fd, &nh, sizeof (GNUNET_HashCode))))
+    {
+      if (0 == memcmp (&nh, nsid, sizeof (GNUNET_HashCode)))
+        {
+          idx = i;
+          break;
+        }
+      i++;
+      len -= sizeof (GNUNET_HashCode);
+    }
+  if (idx == -1)
+    {
+      idx = i;
+      if (sizeof (GNUNET_HashCode) !=
+          WRITE (fd, nsid, sizeof (GNUNET_HashCode)))
+        GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING, "write", fn);
+    }
+  CLOSE (fd);
+  ret = GNUNET_malloc (strlen (name) + 32);
+  GNUNET_snprintf (ret, strlen (name) + 32, "%s-%u", name, idx);
+  GNUNET_free (name);
+  GNUNET_free (fn);
+  return ret;
+}
+
+/**
+ * Get the namespace ID belonging to the given namespace name.
+ *
+ * @return GNUNET_OK on success
+ */
+int
+GNUNET_PSEUDONYM_name_to_id (struct GNUNET_CONFIGURATION_Handle *cfg,
+                             const char *ns_uname, GNUNET_HashCode * nsid)
+{
+  size_t slen;
+  unsigned long long len;
+  unsigned int idx;
+  char *name;
+  GNUNET_HashCode nh;
+  char *fn;
+  int fd;
+
+  idx = -1;
+  slen = strlen (ns_uname);
+  while ((slen > 0) && (1 != sscanf (&ns_uname[slen - 1], "-%u", &idx)))
+    slen--;
+  if (slen == 0)
+    return GNUNET_SYSERR;
+  name = GNUNET_strdup (ns_uname);
+  name[slen - 1] = '\0';
+  GNUNET_CRYPTO_hash (name, strlen (name), &nh);
+  GNUNET_free (name);
+  fn = get_data_filename (cfg, PS_NAMES_DIR, &nh);
+  GNUNET_assert (fn != NULL);
+
+  if ((GNUNET_OK != GNUNET_DISK_file_test (fn) ||
+       (GNUNET_OK != GNUNET_DISK_file_size (fn, &len, GNUNET_YES))) ||
+      ((idx + 1) * sizeof (GNUNET_HashCode) > len))
+    {
+      GNUNET_free (fn);
+      return GNUNET_SYSERR;
+    }
+  fd = GNUNET_DISK_file_open (fn, O_CREAT | O_RDWR, S_IRUSR | S_IWUSR);
+  GNUNET_free (fn);
+  LSEEK (fd, idx * sizeof (GNUNET_HashCode), SEEK_SET);
+  if (sizeof (GNUNET_HashCode) != READ (fd, nsid, sizeof (GNUNET_HashCode)))
+    {
+      CLOSE (fd);
+      return GNUNET_SYSERR;
+    }
+  CLOSE (fd);
+  return GNUNET_OK;
+}
+
+
+
+
+struct ListPseudonymClosure
+{
+  GNUNET_PSEUDONYM_Iterator iterator;
+  void *closure;
+  struct GNUNET_CONFIGURATION_Handle *cfg;
+};
+
+static int
+list_pseudonym_helper (void *cls, const char *fullname)
+{
+  struct ListPseudonymClosure *c = cls;
+  int ret;
+  GNUNET_HashCode id;
+  int rating;
+  struct GNUNET_CONTAINER_MetaData *meta;
+  const char *fn;
+
+  if (strlen (fullname) < sizeof (struct GNUNET_CRYPTO_HashAsciiEncoded))
+    return GNUNET_OK;
+  fn =
+    &fullname[strlen (fullname) + 1 -
+              sizeof (struct GNUNET_CRYPTO_HashAsciiEncoded)];
+  if (fn[-1] != DIR_SEPARATOR)
+    return GNUNET_OK;
+  ret = GNUNET_OK;
+  if (GNUNET_OK != GNUNET_CRYPTO_hash_from_string (fn, &id))
+    return GNUNET_OK;           /* invalid name */
+  if (GNUNET_OK != read_info (c->cfg, &id, &meta, &rating, NULL))
+    return GNUNET_OK;           /* ignore entry */
+  if (c->iterator != NULL)
+    ret = c->iterator (c->closure, &id, meta, rating);
+  GNUNET_CONTAINER_meta_data_destroy (meta);
+  return ret;
+}
+
+/**
+ * List all available pseudonyms.
+ */
+int
+GNUNET_PSEUDONYM_list_all (struct GNUNET_CONFIGURATION_Handle *cfg,
+                           GNUNET_PSEUDONYM_Iterator iterator, void *closure)
+{
+  struct ListPseudonymClosure cls;
+  char *fn;
+  int ret;
+
+  cls.iterator = iterator;
+  cls.closure = closure;
+  cls.cfg = cfg;
+  fn = get_data_filename (cfg, PS_METADATA_DIR, NULL);
+  GNUNET_assert (fn != NULL);
+  GNUNET_DISK_directory_create (fn);
+  ret = GNUNET_DISK_directory_scan (fn, &list_pseudonym_helper, &cls);
+  GNUNET_free (fn);
+  return ret;
+}
+
+/**
+ * Change the ranking of a pseudonym.
+ *
+ * @param nsid id of the pseudonym
+ * @param delta by how much should the rating be
+ *  changed?
+ * @return new rating of the pseudonym
+ */
+int
+GNUNET_PSEUDONYM_rank (struct GNUNET_CONFIGURATION_Handle *cfg,
+                       const GNUNET_HashCode * nsid, int delta)
+{
+  struct GNUNET_CONTAINER_MetaData *meta;
+  int ret;
+  int32_t ranking;
+  char *name;
+
+  name = NULL;
+  ret = read_info (cfg, nsid, &meta, &ranking, &name);
+  if (ret == GNUNET_SYSERR)
+    {
+      ranking = 0;
+      meta = GNUNET_CONTAINER_meta_data_create ();
+    }
+  ranking += delta;
+  write_pseudonym_info (cfg, nsid, meta, ranking, name);
+  GNUNET_CONTAINER_meta_data_destroy (meta);
+  GNUNET_free_non_null (name);
+  return ranking;
+}
+
+/**
+ * Insert metadata into existing MD record (passed as cls).
+ */
+static int
+merge_meta_helper (EXTRACTOR_KeywordType type, const char *data, void *cls)
+{
+  struct GNUNET_CONTAINER_MetaData *meta = cls;
+  GNUNET_CONTAINER_meta_data_insert (meta, type, data);
+  return GNUNET_OK;
+}
+
+
+
+/**
+ * Add a pseudonym to the set of known pseudonyms.
+ * For all pseudonym advertisements that we discover
+ * FSUI should automatically call this function.
+ *
+ * @param id the pseudonym identifier
+ */
+void
+GNUNET_PSEUDONYM_add (struct GNUNET_CONFIGURATION_Handle *cfg,
+                      const GNUNET_HashCode * id,
+                      const struct GNUNET_CONTAINER_MetaData *meta)
+{
+  char *name;
+  int32_t ranking;
+  struct GNUNET_CONTAINER_MetaData *old;
+  char *fn;
+  struct stat sbuf;
+
+  ranking = 0;
+  fn = get_data_filename (cfg, PS_METADATA_DIR, id);
+  GNUNET_assert (fn != NULL);
+
+  if ((0 == STAT (fn, &sbuf)) &&
+      (GNUNET_OK == read_info (cfg, id, &old, &ranking, &name)))
+    {
+      GNUNET_CONTAINER_meta_data_get_contents (meta, &merge_meta_helper, old);
+      write_pseudonym_info (cfg, id, old, ranking, name);
+      GNUNET_CONTAINER_meta_data_destroy (old);
+      GNUNET_free_non_null (name);
+    }
+  else
+    {
+      write_pseudonym_info (cfg, id, meta, ranking, NULL);
+    }
+  GNUNET_free (fn);
+  internal_notify (id, meta, ranking);
+}
+
+
+
+
+
+/* end of pseudonym.c */
diff --git a/src/util/scheduler.c b/src/util/scheduler.c
new file mode 100644
index 000000000..0d30910e0
--- /dev/null
+++ b/src/util/scheduler.c
@@ -0,0 +1,886 @@
+/*
+      This file is part of GNUnet
+      (C) 2009 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 util/scheduler/scheduler.c
+ * @brief schedule computations using continuation passing style
+ * @author Christian Grothoff
+ */
+#include "platform.h"
+#include "gnunet_common.h"
+#include "gnunet_scheduler_lib.h"
+#include "gnunet_signal_lib.h"
+#include "gnunet_time_lib.h"
+
+/**
+ * Linked list of pending tasks.
+ */
+struct Task
+{
+  /**
+   * This is a linked list.
+   */
+  struct Task *next;
+
+  /**
+   * Function to run when ready.
+   */
+  GNUNET_SCHEDULER_Task callback;
+
+  /**
+   * Closure for the callback.
+   */
+  void *callback_cls;
+
+  /**
+   * Set of file descriptors this task is waiting
+   * for for reading.  Once ready, this is updated
+   * to reflect the set of file descriptors ready
+   * for operation.
+   */
+  fd_set read_set;
+
+  /**
+   * Set of file descriptors this task is waiting
+   * for for writing.  Once ready, this is updated
+   * to reflect the set of file descriptors ready
+   * for operation.
+   */
+  fd_set write_set;
+
+  /**
+   * Unique task identifier.
+   */
+  GNUNET_SCHEDULER_TaskIdentifier id;
+
+  /**
+   * Identifier of a prerequisite task.
+   */
+  GNUNET_SCHEDULER_TaskIdentifier prereq_id;
+
+  /**
+   * Absolute timeout value for the task, or
+   * GNUNET_TIME_UNIT_FOREVER_ABS for "no timeout".
+   */
+  struct GNUNET_TIME_Absolute timeout;
+
+  /**
+   * Why is the task ready?  Set after task is added to ready queue.
+   * Initially set to zero.  All reasons that have already been
+   * satisfied (i.e.  read or write ready) will be set over time.
+   */
+  enum GNUNET_SCHEDULER_Reason reason;
+
+  /**
+   * Task priority.
+   */
+  enum GNUNET_SCHEDULER_Priority priority;
+
+  /**
+   * highest-numbered file descriptor in read_set or write_set plus one
+   */
+  int nfds;
+
+  /**
+   * Should this task be run on shutdown?
+   */
+  int run_on_shutdown;
+
+};
+
+
+/**
+ * Handle for the scheduling service.
+ */
+struct GNUNET_SCHEDULER_Handle
+{
+
+  /**
+   * List of tasks waiting for an event.
+   */
+  struct Task *pending;
+
+  /**
+   * List of tasks ready to run right now,
+   * grouped by importance.
+   */
+  struct Task *ready[GNUNET_SCHEDULER_PRIORITY_COUNT];
+
+  /**
+   * Identity of the last task queued.  Incremented for each task to
+   * generate a unique task ID (it is virtually impossible to start
+   * more than 2^64 tasks during the lifetime of a process).
+   */
+  GNUNET_SCHEDULER_TaskIdentifier last_id;
+
+  /**
+   * Highest number so that all tasks with smaller identifiers
+   * have already completed.  Also the lowest number of a task
+   * still waiting to be executed.
+   */
+  GNUNET_SCHEDULER_TaskIdentifier lowest_pending_id;
+
+  /**
+   * GNUNET_NO if we are running normally,
+   * GNUNET_YES if we are in shutdown mode.
+   */
+  int shutdown;
+
+  /**
+   * Number of tasks on the ready list.
+   */
+  unsigned int ready_count;
+
+  /**
+   * Priority of the task running right now.  Only
+   * valid while a task is running.
+   */
+  enum GNUNET_SCHEDULER_Priority current_priority;
+
+};
+
+
+/**
+ * Check that the given priority is legal (and return it).
+ */
+static enum GNUNET_SCHEDULER_Priority
+check_priority (enum GNUNET_SCHEDULER_Priority p)
+{
+  if ((p >= 0) && (p < GNUNET_SCHEDULER_PRIORITY_COUNT))
+    return p;
+  GNUNET_assert (0);
+  return 0;                     /* make compiler happy */
+}
+
+
+/**
+ * Update the timeout value so that it is smaller than min.
+ */
+static void
+update_timeout (struct timeval *tv, struct GNUNET_TIME_Relative min)
+{
+  if (((tv->tv_sec * 1000) + (tv->tv_usec / 1000)) > min.value)
+    {
+      tv->tv_sec = min.value / 1000;
+      tv->tv_usec = (min.value - tv->tv_sec * 1000) * 1000;
+    }
+}
+
+
+/**
+ * Set the given file descriptor bit in the given set and update max
+ * to the maximum of the existing max and fd+1.
+ */
+static void
+set_fd (int fd, int *max, fd_set * set)
+{
+  if (*max <= fd)
+    *max = fd + 1;
+  FD_SET (fd, set);
+}
+
+
+/**
+ * Is a task with this identifier still pending?  Also updates
+ * "lowest_pending_id" as a side-effect (for faster checks in the
+ * future), but only if the return value is "GNUNET_NO" (and
+ * the "lowest_pending_id" check failed).
+ *
+ * @return GNUNET_YES if so, GNUNET_NO if not
+ */
+static int
+is_pending (struct GNUNET_SCHEDULER_Handle *sched,
+            GNUNET_SCHEDULER_TaskIdentifier id)
+{
+  struct Task *pos;
+  enum GNUNET_SCHEDULER_Priority p;
+  GNUNET_SCHEDULER_TaskIdentifier min;
+
+  if (id < sched->lowest_pending_id)
+    return GNUNET_NO;
+  min = -1;                     /* maximum value */
+  pos = sched->pending;
+  while (pos != NULL)
+    {
+      if (pos->id == id)
+        return GNUNET_YES;
+      if (pos->id < min)
+        min = pos->id;
+      pos = pos->next;
+    }
+  for (p = 0; p < GNUNET_SCHEDULER_PRIORITY_COUNT; p++)
+    {
+      pos = sched->ready[p];
+      while (pos != NULL)
+        {
+          if (pos->id == id)
+            return GNUNET_YES;
+          if (pos->id < min)
+            min = pos->id;
+          pos = pos->next;
+        }
+    }
+  sched->lowest_pending_id = min;
+  return GNUNET_NO;
+}
+
+
+/**
+ * Update all sets and timeout for select.
+ */
+static void
+update_sets (struct GNUNET_SCHEDULER_Handle *sched,
+             int *max, fd_set * rs, fd_set * ws, struct timeval *tv)
+{
+  int i;
+  struct Task *pos;
+
+  pos = sched->pending;
+  while (pos != NULL)
+    {
+      if ((pos->prereq_id != GNUNET_SCHEDULER_NO_PREREQUISITE_TASK) &&
+          (GNUNET_YES == is_pending (sched, pos->prereq_id)))
+        {
+          pos = pos->next;
+          continue;
+        }
+
+      if (pos->timeout.value != GNUNET_TIME_UNIT_FOREVER_ABS.value)
+        update_timeout (tv,
+                        GNUNET_TIME_absolute_get_remaining (pos->timeout));
+      for (i = 0; i < pos->nfds; i++)
+        {
+          if (FD_ISSET (i, &pos->read_set))
+            set_fd (i, max, rs);
+          if (FD_ISSET (i, &pos->write_set))
+            set_fd (i, max, ws);
+        }
+      pos = pos->next;
+    }
+}
+
+
+/**
+ * Check if the ready set overlaps with the set we want to have ready.
+ * If so, update the want set (set all FDs that are ready).  If not,
+ * return GNUNET_NO.
+ *
+ * @param maxfd highest FD that needs to be checked.
+ * @return GNUNET_YES if there was some overlap
+ */
+static int
+set_overlaps (const fd_set * ready, fd_set * want, int maxfd)
+{
+  int i;
+
+  for (i = 0; i < maxfd; i++)
+    if (FD_ISSET (i, want) && FD_ISSET (i, ready))
+      {
+        /* copy all over (yes, there maybe unrelated bits,
+           but this should not hurt well-written clients) */
+        memcpy (want, ready, sizeof (fd_set));
+        return GNUNET_YES;
+      }
+  return GNUNET_NO;
+}
+
+
+/**
+ * Check if the given task is eligible to run now.
+ * Also set the reason why it is eligible.
+ *
+ * @return GNUNET_YES if we can run it, GNUNET_NO if not.
+ */
+static int
+is_ready (struct GNUNET_SCHEDULER_Handle *sched,
+          struct Task *task,
+          struct GNUNET_TIME_Absolute now,
+          const fd_set * rs, const fd_set * ws)
+{
+  if ((GNUNET_NO == task->run_on_shutdown) && (GNUNET_YES == sched->shutdown))
+    return GNUNET_NO;
+  if ((GNUNET_YES == task->run_on_shutdown) &&
+      (GNUNET_YES == sched->shutdown))
+    task->reason |= GNUNET_SCHEDULER_REASON_SHUTDOWN;
+  if (now.value >= task->timeout.value)
+    task->reason |= GNUNET_SCHEDULER_REASON_TIMEOUT;
+  if ((0 == (task->reason & GNUNET_SCHEDULER_REASON_READ_READY)) &&
+      (rs != NULL) && (set_overlaps (rs, &task->read_set, task->nfds)))
+    task->reason |= GNUNET_SCHEDULER_REASON_READ_READY;
+  if ((0 == (task->reason & GNUNET_SCHEDULER_REASON_WRITE_READY)) &&
+      (ws != NULL) && (set_overlaps (ws, &task->write_set, task->nfds)))
+    task->reason |= GNUNET_SCHEDULER_REASON_WRITE_READY;
+  if (task->reason == 0)
+    return GNUNET_NO;           /* not ready */
+  if (task->prereq_id != GNUNET_SCHEDULER_NO_PREREQUISITE_TASK)
+    {
+      if (GNUNET_YES == is_pending (sched, task->prereq_id))
+        return GNUNET_NO;       /* prereq waiting */
+      task->reason |= GNUNET_SCHEDULER_REASON_PREREQ_DONE;
+    }
+  return GNUNET_YES;
+}
+
+
+/**
+ * Put a task that is ready for execution into the ready queue.
+ */
+static void
+queue_ready_task (struct GNUNET_SCHEDULER_Handle *handle, struct Task *task)
+{
+  task->next = handle->ready[check_priority (task->priority)];
+  handle->ready[check_priority (task->priority)] = task;
+  handle->ready_count++;
+}
+
+
+/**
+ * Check which tasks are ready and move them
+ * to the respective ready queue.
+ */
+static void
+check_ready (struct GNUNET_SCHEDULER_Handle *handle,
+             const fd_set * rs, const fd_set * ws)
+{
+  struct Task *pos;
+  struct Task *prev;
+  struct Task *next;
+  struct GNUNET_TIME_Absolute now;
+
+  now = GNUNET_TIME_absolute_get ();
+  prev = NULL;
+  pos = handle->pending;
+  while (pos != NULL)
+    {
+      next = pos->next;
+      if (GNUNET_YES == is_ready (handle, pos, now, rs, ws))
+        {
+          if (prev == NULL)
+            handle->pending = next;
+          else
+            prev->next = next;
+          queue_ready_task (handle, pos);
+          pos = next;
+          continue;
+        }
+      prev = pos;
+      pos = next;
+    }
+}
+
+
+/**
+ * Run at least one task in the highest-priority queue that is not
+ * empty.  Keep running tasks until we are either no longer running
+ * "URGENT" tasks or until we have at least one "pending" task (which
+ * may become ready, hence we should select on it).  Naturally, if
+ * there are no more ready tasks, we also return.
+ */
+static void
+run_ready (struct GNUNET_SCHEDULER_Handle *sched)
+{
+  enum GNUNET_SCHEDULER_Priority p;
+  struct Task *pos;
+  struct GNUNET_SCHEDULER_TaskContext tc;
+
+  do
+    {
+      if (sched->ready_count == 0)
+        return;
+      GNUNET_assert (sched->ready[GNUNET_SCHEDULER_PRIORITY_KEEP] == NULL);
+      /* yes, p>0 is correct, 0 is "KEEP" which should
+         always be an empty queue (see assertion)! */
+      for (p = GNUNET_SCHEDULER_PRIORITY_COUNT - 1; p > 0; p--)
+        {
+          pos = sched->ready[p];
+          if (pos != NULL)
+            break;
+        }
+      GNUNET_assert (pos != NULL);      /* ready_count wrong? */
+      sched->ready[p] = pos->next;
+      sched->ready_count--;
+      sched->current_priority = p;
+      GNUNET_assert (pos->priority == p);
+      tc.sched = sched;
+      tc.reason = pos->reason;
+      tc.read_ready = &pos->read_set;
+      tc.write_ready = &pos->write_set;
+      pos->callback (pos->callback_cls, &tc);
+      GNUNET_free (pos);
+    }
+  while ((sched->pending == NULL) || (p == GNUNET_SCHEDULER_PRIORITY_URGENT));
+}
+
+
+/**
+ * Have we (ever) received a SIGINT/TERM/QUIT/HUP?
+ */
+static volatile int sig_shutdown;
+
+
+/**
+ * Signal handler called for signals that should cause us to shutdown.
+ */
+static void
+sighandler_shutdown ()
+{
+  sig_shutdown = 1;
+}
+
+
+/**
+ * Initialize a scheduler using this thread.  This function will
+ * return when either a shutdown was initiated (via signal) and all
+ * tasks marked to "run_on_shutdown" have been completed or when all
+ * tasks in general have been completed.
+ *
+ * @param task task to run immediately
+ * @param cls closure of task
+ */
+void
+GNUNET_SCHEDULER_run (GNUNET_SCHEDULER_Task task, void *cls)
+{
+  struct GNUNET_SCHEDULER_Handle sched;
+  fd_set rs;
+  fd_set ws;
+  int max;
+  struct timeval tv;
+  int ret;
+  struct GNUNET_SIGNAL_Context *shc_int;
+  struct GNUNET_SIGNAL_Context *shc_term;
+  struct GNUNET_SIGNAL_Context *shc_quit;
+  struct GNUNET_SIGNAL_Context *shc_hup;
+  struct Task *tpos;
+
+  sig_shutdown = 0;
+  shc_int = GNUNET_SIGNAL_handler_install (SIGINT, &sighandler_shutdown);
+  shc_term = GNUNET_SIGNAL_handler_install (SIGTERM, &sighandler_shutdown);
+  shc_quit = GNUNET_SIGNAL_handler_install (SIGQUIT, &sighandler_shutdown);
+  shc_hup = GNUNET_SIGNAL_handler_install (SIGHUP, &sighandler_shutdown);
+  memset (&sched, 0, sizeof (sched));
+  sched.current_priority = GNUNET_SCHEDULER_PRIORITY_DEFAULT;
+  GNUNET_SCHEDULER_add_continuation (&sched,
+                                     GNUNET_YES,
+                                     task,
+                                     cls, GNUNET_SCHEDULER_REASON_STARTUP);
+  while ((GNUNET_NO == sched.shutdown) &&
+         (!sig_shutdown) &&
+         ((sched.pending != NULL) || (sched.ready_count > 0)))
+    {
+      FD_ZERO (&rs);
+      FD_ZERO (&ws);
+      max = 0;
+      tv.tv_sec = 0x7FFFFFFF;
+      tv.tv_usec = 0;
+      if (sched.ready_count > 0)
+        {
+          /* no blocking, more work already ready! */
+          tv.tv_sec = 0;
+          tv.tv_usec = 0;
+        }
+      update_sets (&sched, &max, &rs, &ws, &tv);
+      ret = SELECT (max, &rs, &ws, NULL, &tv);
+      if (ret == -1)
+        {
+          if (errno == EINTR)
+            continue;
+          GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "select");
+          break;
+        }
+      check_ready (&sched, &rs, &ws);
+      run_ready (&sched);
+    }
+  if (sig_shutdown)
+    sched.shutdown = GNUNET_YES;
+  GNUNET_SIGNAL_handler_uninstall (shc_int);
+  GNUNET_SIGNAL_handler_uninstall (shc_term);
+  GNUNET_SIGNAL_handler_uninstall (shc_quit);
+  GNUNET_SIGNAL_handler_uninstall (shc_hup);
+  do
+    {
+      run_ready (&sched);
+      check_ready (&sched, NULL, NULL);
+    }
+  while (sched.ready_count > 0);
+  while (NULL != (tpos = sched.pending))
+    {
+      sched.pending = tpos->next;
+      GNUNET_free (tpos);
+    }
+}
+
+
+/**
+ * Request the shutdown of a scheduler.  This function can be used to
+ * stop a scheduling thread when created with the
+ * "GNUNET_SCHEDULER_init_thread" function or from within the signal
+ * handler for signals causing shutdowns.
+ */
+void
+GNUNET_SCHEDULER_shutdown (struct GNUNET_SCHEDULER_Handle *sched)
+{
+  sched->shutdown = GNUNET_YES;
+}
+
+
+/**
+ * Get information about the current load of this scheduler.  Use this
+ * function to determine if an elective task should be added or simply
+ * dropped (if the decision should be made based on the number of
+ * tasks ready to run).
+ *
+ * @param sched scheduler to query
+ * @return number of tasks pending right now
+ */
+unsigned int
+GNUNET_SCHEDULER_get_load (struct GNUNET_SCHEDULER_Handle *sched,
+                           enum GNUNET_SCHEDULER_Priority p)
+{
+  struct Task *pos;
+  unsigned int ret;
+
+  if (p == GNUNET_SCHEDULER_PRIORITY_COUNT)
+    return sched->ready_count;
+  if (p == GNUNET_SCHEDULER_PRIORITY_KEEP)
+    p = sched->current_priority;
+  ret = 0;
+  pos = sched->ready[p];
+  while (pos != NULL)
+    {
+      pos = pos->next;
+      ret++;
+    }
+  return ret;
+}
+
+
+/**
+ * Cancel the task with the specified identifier.
+ * The task must not yet have run.
+ *
+ * @param sched scheduler to use
+ * @param task id of the task to cancel
+ */
+void *
+GNUNET_SCHEDULER_cancel (struct GNUNET_SCHEDULER_Handle *sched,
+                         GNUNET_SCHEDULER_TaskIdentifier task)
+{
+  struct Task *t;
+  struct Task *prev;
+  enum GNUNET_SCHEDULER_Priority p;
+  void *ret;
+
+  prev = NULL;
+  t = sched->pending;
+  while (t != NULL)
+    {
+      if (t->id == task)
+        break;
+      prev = t;
+      t = t->next;
+    }
+  p = 0;
+  while (t == NULL)
+    {
+      p++;
+      GNUNET_assert (p < GNUNET_SCHEDULER_PRIORITY_COUNT);
+      prev = NULL;
+      t = sched->ready[p];
+      while (t != NULL)
+        {
+          if (t->id == task)
+            {
+              sched->ready_count--;
+              break;
+            }
+          prev = t;
+          t = t->next;
+        }
+    }
+  if (prev == NULL)
+    {
+      if (p == 0)
+        sched->pending = t->next;
+      else
+        sched->ready[p] = t->next;
+    }
+  else
+    prev->next = t->next;
+  ret = t->callback_cls;
+  GNUNET_free (t);
+  return ret;
+}
+
+
+/**
+ * Continue the current execution with the given function.  This is
+ * similar to the other "add" functions except that there is no delay
+ * and the reason code can be specified.
+ *
+ * @param sched scheduler to use
+ * @param main main function of the task
+ * @param cls closure of task
+ * @param reason reason for task invocation
+ */
+void
+GNUNET_SCHEDULER_add_continuation (struct GNUNET_SCHEDULER_Handle *sched,
+                                   int run_on_shutdown,
+                                   GNUNET_SCHEDULER_Task main,
+                                   void *cls,
+                                   enum GNUNET_SCHEDULER_Reason reason)
+{
+  struct Task *task;
+
+  task = GNUNET_malloc (sizeof (struct Task));
+  task->callback = main;
+  task->callback_cls = cls;
+  task->id = ++sched->last_id;
+  task->reason = reason;
+  task->priority = sched->current_priority;
+  task->run_on_shutdown = run_on_shutdown;
+  queue_ready_task (sched, task);
+}
+
+
+/**
+ * Schedule a new task to be run after the specified
+ * prerequisite task has completed.
+ *
+ * @param sched scheduler to use
+ * @param run_on_shutdown run on shutdown?
+ * @param prio how important is this task?
+ * @param prerequisite_task run this task after the task with the given
+ *        task identifier completes (and any of our other
+ *        conditions, such as delay, read or write-readyness
+ *        are satisfied).  Use  GNUNET_SCHEDULER_NO_PREREQUISITE_TASK to not have any dependency
+ *        on completion of other tasks.
+ * @param main main function of the task
+ * @param cls closure of task
+ * @return unique task identifier for the job
+ *         only valid until "main" is started!
+ */
+GNUNET_SCHEDULER_TaskIdentifier
+GNUNET_SCHEDULER_add_after (struct GNUNET_SCHEDULER_Handle *sched,
+                            int run_on_shutdown,
+                            enum GNUNET_SCHEDULER_Priority prio,
+                            GNUNET_SCHEDULER_TaskIdentifier prerequisite_task,
+                            GNUNET_SCHEDULER_Task main, void *cls)
+{
+  return GNUNET_SCHEDULER_add_select (sched, run_on_shutdown, prio,
+                                      prerequisite_task,
+                                      GNUNET_TIME_UNIT_ZERO,
+                                      0, NULL, NULL, main, cls);
+}
+
+
+/**
+ * Schedule a new task to be run with a specified delay.  The task
+ * will be scheduled for execution once the delay has expired and the
+ * prerequisite task has completed.
+ *
+ * @param sched scheduler to use
+ * @param run_on_shutdown run on shutdown? You can use this
+ *        argument to run a function only during shutdown
+ *        by setting delay to -1.  Set this
+ *        argument to GNUNET_NO to skip this task if
+ *        the user requested process termination.
+ * @param prio how important is this task?
+ * @param prerequisite_task run this task after the task with the given
+ *        task identifier completes (and any of our other
+ *        conditions, such as delay, read or write-readyness
+ *        are satisfied).  Use  GNUNET_SCHEDULER_NO_PREREQUISITE_TASK to not have any dependency
+ *        on completion of other tasks.
+ * @param delay how long should we wait? Use  GNUNET_TIME_UNIT_FOREVER_REL for "forever"
+ * @param main main function of the task
+ * @param cls closure of task
+ * @return unique task identifier for the job
+ *         only valid until "main" is started!
+ */
+GNUNET_SCHEDULER_TaskIdentifier
+GNUNET_SCHEDULER_add_delayed (struct GNUNET_SCHEDULER_Handle * sched,
+                              int run_on_shutdown,
+                              enum GNUNET_SCHEDULER_Priority prio,
+                              GNUNET_SCHEDULER_TaskIdentifier
+                              prerequisite_task,
+                              struct GNUNET_TIME_Relative delay,
+                              GNUNET_SCHEDULER_Task main, void *cls)
+{
+  return GNUNET_SCHEDULER_add_select (sched, run_on_shutdown, prio,
+                                      prerequisite_task, delay,
+                                      0, NULL, NULL, main, cls);
+}
+
+
+/**
+ * Schedule a new task to be run with a specified delay or when the
+ * specified file descriptor is ready for reading.  The delay can be
+ * used as a timeout on the socket being ready.  The task will be
+ * scheduled for execution once either the delay has expired or the
+ * socket operation is ready.
+ *
+ * @param sched scheduler to use
+ * @param run_on_shutdown run on shutdown? Set this
+ *        argument to GNUNET_NO to skip this task if
+ *        the user requested process termination.
+ * @param prio how important is this task?
+ * @param prerequisite_task run this task after the task with the given
+ *        task identifier completes (and any of our other
+ *        conditions, such as delay, read or write-readyness
+ *        are satisfied).  Use  GNUNET_SCHEDULER_NO_PREREQUISITE_TASK to not have any dependency
+ *        on completion of other tasks.
+ * @param delay how long should we wait? Use  GNUNET_TIME_UNIT_FOREVER_REL for "forever"
+ * @param rfd read file-descriptor
+ * @param main main function of the task
+ * @param cls closure of task
+ * @return unique task identifier for the job
+ *         only valid until "main" is started!
+ */
+GNUNET_SCHEDULER_TaskIdentifier
+GNUNET_SCHEDULER_add_read (struct GNUNET_SCHEDULER_Handle * sched,
+                           int run_on_shutdown,
+                           enum GNUNET_SCHEDULER_Priority prio,
+                           GNUNET_SCHEDULER_TaskIdentifier prerequisite_task,
+                           struct GNUNET_TIME_Relative delay,
+                           int rfd, GNUNET_SCHEDULER_Task main, void *cls)
+{
+  fd_set rs;
+
+  GNUNET_assert (rfd >= 0);
+  FD_ZERO (&rs);
+  FD_SET (rfd, &rs);
+  return GNUNET_SCHEDULER_add_select (sched, run_on_shutdown, prio,
+                                      prerequisite_task, delay,
+                                      rfd + 1, &rs, NULL, main, cls);
+}
+
+
+/**
+ * Schedule a new task to be run with a specified delay or when the
+ * specified file descriptor is ready for writing.  The delay can be
+ * used as a timeout on the socket being ready.  The task will be
+ * scheduled for execution once either the delay has expired or the
+ * socket operation is ready.
+ *
+ * @param sched scheduler to use
+ * @param run_on_shutdown run on shutdown? Set this
+ *        argument to GNUNET_NO to skip this task if
+ *        the user requested process termination.
+ * @param prio how important is this task?
+ * @param prerequisite_task run this task after the task with the given
+ *        task identifier completes (and any of our other
+ *        conditions, such as delay, read or write-readyness
+ *        are satisfied).  Use  GNUNET_SCHEDULER_NO_PREREQUISITE_TASK to not have any dependency
+ *        on completion of other tasks.
+ * @param delay how long should we wait? Use  GNUNET_TIME_UNIT_FOREVER_REL for "forever"
+ * @param wfd write file-descriptor
+ * @param main main function of the task
+ * @param cls closure of task
+ * @return unique task identifier for the job
+ *         only valid until "main" is started!
+ */
+GNUNET_SCHEDULER_TaskIdentifier
+GNUNET_SCHEDULER_add_write (struct GNUNET_SCHEDULER_Handle * sched,
+                            int run_on_shutdown,
+                            enum GNUNET_SCHEDULER_Priority prio,
+                            GNUNET_SCHEDULER_TaskIdentifier prerequisite_task,
+                            struct GNUNET_TIME_Relative delay,
+                            int wfd, GNUNET_SCHEDULER_Task main, void *cls)
+{
+  fd_set ws;
+
+  GNUNET_assert (wfd >= 0);
+  FD_ZERO (&ws);
+  FD_SET (wfd, &ws);
+  return GNUNET_SCHEDULER_add_select (sched, run_on_shutdown, prio,
+                                      prerequisite_task, delay,
+                                      wfd + 1, NULL, &ws, main, cls);
+}
+
+
+/**
+ * Schedule a new task to be run with a specified delay or when any of
+ * the specified file descriptor sets is ready.  The delay can be used
+ * as a timeout on the socket(s) being ready.  The task will be
+ * scheduled for execution once either the delay has expired or any of
+ * the socket operations is ready.  This is the most general
+ * function of the "add" family.  Note that the "prerequisite_task"
+ * must be satisfied in addition to any of the other conditions.  In
+ * other words, the task will be started when
+ * <code>
+ * (prerequisite-run)
+ * && (delay-ready
+ *     || any-rs-ready
+ *     || any-ws-ready
+ *     || (shutdown-active && run-on-shutdown) )
+ * </code>
+ *
+ * @param sched scheduler to use
+ * @param run_on_shutdown run on shutdown?  Set this
+ *        argument to GNUNET_NO to skip this task if
+ *        the user requested process termination.
+ * @param prio how important is this task?
+ * @param prerequisite_task run this task after the task with the given
+ *        task identifier completes (and any of our other
+ *        conditions, such as delay, read or write-readyness
+ *        are satisfied).  Use GNUNET_SCHEDULER_NO_PREREQUISITE_TASK to not have any dependency
+ *        on completion of other tasks.
+ * @param delay how long should we wait? Use GNUNET_TIME_UNIT_FOREVER_REL for "forever"
+ * @param nfds highest-numbered file descriptor in any of the two sets plus one
+ * @param rs set of file descriptors we want to read (can be NULL)
+ * @param ws set of file descriptors we want to write (can be NULL)
+ * @param main main function of the task
+ * @param cls closure of task
+ * @return unique task identifier for the job
+ *         only valid until "main" is started!
+ */
+GNUNET_SCHEDULER_TaskIdentifier
+GNUNET_SCHEDULER_add_select (struct GNUNET_SCHEDULER_Handle * sched,
+                             int run_on_shutdown,
+                             enum GNUNET_SCHEDULER_Priority prio,
+                             GNUNET_SCHEDULER_TaskIdentifier
+                             prerequisite_task,
+                             struct GNUNET_TIME_Relative delay,
+                             int nfds, const fd_set * rs, const fd_set * ws,
+                             GNUNET_SCHEDULER_Task main, void *cls)
+{
+  struct Task *task;
+
+  task = GNUNET_malloc (sizeof (struct Task));
+  task->callback = main;
+  task->callback_cls = cls;
+  if ((rs != NULL) && (nfds > 0))
+    memcpy (&task->read_set, rs, sizeof (fd_set));
+  if ((ws != NULL) && (nfds > 0))
+    memcpy (&task->write_set, ws, sizeof (fd_set));
+  task->id = ++sched->last_id;
+  task->prereq_id = prerequisite_task;
+  task->timeout = GNUNET_TIME_relative_to_absolute (delay);
+  task->priority =
+    check_priority ((prio ==
+                     GNUNET_SCHEDULER_PRIORITY_KEEP) ? sched->
+                    current_priority : prio);
+  task->nfds = nfds;
+  task->run_on_shutdown = run_on_shutdown;
+  task->next = sched->pending;
+  sched->pending = task;
+  return task->id;
+}
+
+/* end of scheduler.c */
diff --git a/src/util/server.c b/src/util/server.c
new file mode 100644
index 000000000..91bc8cc7a
--- /dev/null
+++ b/src/util/server.c
@@ -0,0 +1,1091 @@
+/*
+     This file is part of GNUnet.
+     (C) 2009 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 util/server.c
+ * @brief library for building GNUnet network servers
+ * @author Christian Grothoff
+ *
+ * TODO:
+ * - fix inefficient memmove in message processing
+ */
+
+#include "platform.h"
+#include "gnunet_common.h"
+#include "gnunet_network_lib.h"
+#include "gnunet_scheduler_lib.h"
+#include "gnunet_server_lib.h"
+#include "gnunet_time_lib.h"
+
+/**
+ * List of arrays of message handlers.
+ */
+struct HandlerList
+{
+  /**
+   * This is a linked list.
+   */
+  struct HandlerList *next;
+
+  /**
+   * NULL-terminated array of handlers.
+   */
+  const struct GNUNET_SERVER_MessageHandler *handlers;
+};
+
+
+/**
+ * List of arrays of message handlers.
+ */
+struct NotifyList
+{
+  /**
+   * This is a linked list.
+   */
+  struct NotifyList *next;
+
+  /**
+   * Function to call.
+   */
+  GNUNET_SERVER_DisconnectCallback callback;
+
+  /**
+   * Closure for callback.
+   */
+  void *callback_cls;
+};
+
+
+/**
+ * @brief handle for a server
+ */
+struct GNUNET_SERVER_Handle
+{
+  /**
+   * My scheduler.
+   */
+  struct GNUNET_SCHEDULER_Handle *sched;
+
+  /**
+   * List of handlers for incoming messages.
+   */
+  struct HandlerList *handlers;
+
+  /**
+   * List of our current clients.
+   */
+  struct GNUNET_SERVER_Client *clients;
+
+  /**
+   * Linked list of functions to call on disconnects by clients.
+   */
+  struct NotifyList *disconnect_notify_list;
+
+  /**
+   * Function to call for access control.
+   */
+  GNUNET_NETWORK_AccessCheck access;
+
+  /**
+   * Closure for access.
+   */
+  void *access_cls;
+
+  /**
+   * After how long should an idle connection time
+   * out (on write).
+   */
+  struct GNUNET_TIME_Relative idle_timeout;
+
+  /**
+   * maximum write buffer size for accepted sockets
+   */
+  size_t maxbuf;
+
+  /**
+   * Pipe used to signal shutdown of the server.
+   */
+  int shutpipe[2];
+
+  /**
+   * Socket used to listen for new connections.  Set to
+   * "-1" by GNUNET_SERVER_destroy to initiate shutdown.
+   */
+  int listen_socket;
+
+  /**
+   * Set to GNUNET_YES if we are shutting down.
+   */
+  int do_shutdown;
+
+  /**
+   * Do we ignore messages of types that we do not
+   * understand or do we require that a handler
+   * is found (and if not kill the connection)?
+   */
+  int require_found;
+
+};
+
+
+/**
+ * @brief handle for a client of the server
+ */
+struct GNUNET_SERVER_Client
+{
+
+  /**
+   * Size of the buffer for incoming data.  Should be
+   * first so we get nice alignment.
+   */
+  char incoming_buffer[GNUNET_SERVER_MAX_MESSAGE_SIZE];
+
+  /**
+   * This is a linked list.
+   */
+  struct GNUNET_SERVER_Client *next;
+
+  /**
+   * Server that this client belongs to.
+   */
+  struct GNUNET_SERVER_Handle *server;
+
+  /**
+   * Client closure for callbacks.
+   */
+  void *client_closure;
+
+  /**
+   * Callback to receive from client.
+   */
+  GNUNET_SERVER_ReceiveCallback receive;
+
+  /**
+   * Callback to cancel receive from client.
+   */
+  GNUNET_SERVER_ReceiveCancelCallback receive_cancel;
+
+  /**
+   * Callback to ask about transmit-ready notification.
+   */
+  GNUNET_SERVER_TransmitReadyCallback notify_transmit_ready;
+
+   /**
+   * Callback to ask about transmit-ready notification.
+   */
+  GNUNET_SERVER_TransmitReadyCancelCallback notify_transmit_ready_cancel;
+
+  /**
+   * Callback to check if client is still valid.
+   */
+  GNUNET_SERVER_CheckCallback check;
+
+  /**
+   * Callback to destroy client.
+   */
+  GNUNET_SERVER_DestroyCallback destroy;
+
+  /**
+   * Side-buffer for incoming data used when processing
+   * is suspended.
+   */
+  char *side_buf;
+
+  /**
+   * Number of bytes in the side buffer.
+   */
+  size_t side_buf_size;
+
+  /**
+   * Last activity on this socket (used to time it out
+   * if reference_count == 0).
+   */
+  struct GNUNET_TIME_Absolute last_activity;
+
+  /**
+   * Current task identifier for the receive call
+   * (or GNUNET_SCHEDULER_NO_PREREQUISITE_TASK for none).
+   */
+  GNUNET_SCHEDULER_TaskIdentifier my_receive;
+
+  /**
+   * How many bytes in the "incoming_buffer" are currently
+   * valid? (starting at offset 0).
+   */
+  size_t receive_pos;
+
+  /**
+   * Number of external entities with a reference to
+   * this client object.
+   */
+  unsigned int reference_count;
+
+  /**
+   * Was processing if incoming messages suspended while
+   * we were still processing data already received?
+   * This is a counter saying how often processing was
+   * suspended (once per handler invoked).
+   */
+  unsigned int suspended;
+
+  /**
+   * Are we currently in the "process_client_buffer" function (and
+   * will hence restart the receive job on exit if suspended == 0 once
+   * we are done?).  If this is set, then "receive_done" will
+   * essentially only decrement suspended; if this is not set, then
+   * "receive_done" may need to restart the receive process (either
+   * from the side-buffer or via select/recv).
+   */
+  int in_process_client_buffer;
+
+  /**
+   * We're about to close down this client due to some serious
+   * error.
+   */
+  int shutdown_now;
+
+};
+
+
+/**
+ * Server has been asked to shutdown, free resources.
+ */
+static void
+destroy_server (struct GNUNET_SERVER_Handle *server)
+{
+  struct GNUNET_SERVER_Client *pos;
+  struct HandlerList *hpos;
+  struct NotifyList *npos;
+
+  GNUNET_assert (server->listen_socket == -1);
+  GNUNET_break (0 == CLOSE (server->shutpipe[0]));
+  GNUNET_break (0 == CLOSE (server->shutpipe[1]));
+  while (server->clients != NULL)
+    {
+      pos = server->clients;
+      server->clients = pos->next;
+      pos->server = NULL;
+    }
+  while (NULL != (hpos = server->handlers))
+    {
+      server->handlers = hpos->next;
+      GNUNET_free (hpos);
+    }
+  while (NULL != (npos = server->disconnect_notify_list))
+    {
+      server->disconnect_notify_list = npos->next;
+      GNUNET_free (npos);
+    }
+  GNUNET_free (server);
+}
+
+
+/**
+ * Scheduler says our listen socket is ready.
+ * Process it!
+ */
+static void
+process_listen_socket (void *cls,
+                       const struct GNUNET_SCHEDULER_TaskContext *tc)
+{
+  struct GNUNET_SERVER_Handle *server = cls;
+  struct GNUNET_NETWORK_SocketHandle *sock;
+  struct GNUNET_SERVER_Client *client;
+  fd_set r;
+
+  if ((server->do_shutdown) ||
+      ((tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN) != 0))
+    {
+      /* shutdown was initiated */
+      GNUNET_assert (server->listen_socket != -1);
+      GNUNET_break (0 == CLOSE (server->listen_socket));
+      server->listen_socket = -1;
+      if (server->do_shutdown)
+        destroy_server (server);
+      return;
+    }
+  GNUNET_assert (FD_ISSET (server->listen_socket, tc->read_ready));
+  GNUNET_assert (!FD_ISSET (server->shutpipe[0], tc->read_ready));
+  sock = GNUNET_NETWORK_socket_create_from_accept (tc->sched,
+                                                   server->access,
+                                                   server->access_cls,
+                                                   server->listen_socket,
+                                                   server->maxbuf);
+  if (sock != NULL)
+    {
+      client = GNUNET_SERVER_connect_socket (server, sock);
+      /* decrement reference count, we don't keep "client" alive */
+      GNUNET_SERVER_client_drop (client);
+    }
+  /* listen for more! */
+  FD_ZERO (&r);
+  FD_SET (server->listen_socket, &r);
+  FD_SET (server->shutpipe[0], &r);
+  GNUNET_SCHEDULER_add_select (server->sched,
+                               GNUNET_YES,
+                               GNUNET_SCHEDULER_PRIORITY_HIGH,
+                               GNUNET_SCHEDULER_NO_PREREQUISITE_TASK,
+                               GNUNET_TIME_UNIT_FOREVER_REL,
+                               GNUNET_MAX (server->listen_socket,
+                                           server->shutpipe[0]) + 1, &r, NULL,
+                               &process_listen_socket, server);
+}
+
+
+/**
+ * Create and initialize a listen socket for the server.
+ *
+ * @return -1 on error, otherwise the listen socket
+ */
+static int
+open_listen_socket (const struct sockaddr *serverAddr, socklen_t socklen)
+{
+  const static int on = 1;
+  int fd;
+  uint16_t port;
+
+  switch (serverAddr->sa_family)
+    {
+    case AF_INET:
+      port = ntohs (((const struct sockaddr_in *) serverAddr)->sin_port);
+      break;
+    case AF_INET6:
+      port = ntohs (((const struct sockaddr_in6 *) serverAddr)->sin6_port);
+      break;
+    default:
+      GNUNET_break (0);
+      return -1;
+    }
+  fd = SOCKET (serverAddr->sa_family, SOCK_STREAM, 0);
+  if (fd < 0)
+    {
+      GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "socket");
+      return -1;
+    }
+  if (0 != fcntl (fd, F_SETFD, fcntl (fd, F_GETFD) | FD_CLOEXEC))
+    GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
+                         "fcntl");
+  if (SETSOCKOPT (fd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof (on)) < 0)
+    GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
+                         "setsockopt");
+  /* bind the socket */
+  if (BIND (fd, serverAddr, socklen) < 0)
+    {
+      GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "bind");
+      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                  _
+                  ("`%s' failed for port %d. Is the service already running?\n"),
+                  "bind", port);
+      GNUNET_break (0 == CLOSE (fd));
+      return -1;
+    }
+  if (0 != LISTEN (fd, 5))
+    {
+      GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "listen");
+      GNUNET_break (0 == CLOSE (fd));
+      return -1;
+    }
+  return fd;
+}
+
+
+/**
+ * Create a new server.
+ *
+ * @param sched scheduler to use
+ * @param access function for access control
+ * @param access_cls closure for access
+ * @param serverAddr address to listen on (including port), use NULL
+ *        for internal server (no listening)
+ * @param socklen length of serverAddr
+ * @param maxbuf maximum write buffer size for accepted sockets
+ * @param idle_timeout after how long should we timeout idle connections?
+ * @param require_found if YES, connections sending messages of unknown type
+ *        will be closed
+ * @return handle for the new server, NULL on error
+ *         (typically, "port" already in use)
+ */
+struct GNUNET_SERVER_Handle *
+GNUNET_SERVER_create (struct GNUNET_SCHEDULER_Handle *sched,
+                      GNUNET_NETWORK_AccessCheck access,
+                      void *access_cls,
+                      const struct sockaddr *serverAddr,
+                      socklen_t socklen,
+                      size_t maxbuf,
+                      struct GNUNET_TIME_Relative
+                      idle_timeout, int require_found)
+{
+  struct GNUNET_SERVER_Handle *ret;
+  int lsock;
+  fd_set r;
+
+  lsock = -2;
+  if (serverAddr != NULL)
+    {
+      lsock = open_listen_socket (serverAddr, socklen);
+      if (lsock == -1)
+        return NULL;
+    }
+  ret = GNUNET_malloc (sizeof (struct GNUNET_SERVER_Handle));
+  if (0 != PIPE (ret->shutpipe))
+    {
+      GNUNET_break (0 == CLOSE (lsock));
+      GNUNET_free (ret);
+      return NULL;
+    }
+  ret->sched = sched;
+  ret->maxbuf = maxbuf;
+  ret->idle_timeout = idle_timeout;
+  ret->listen_socket = lsock;
+  ret->access = access;
+  ret->access_cls = access_cls;
+  ret->require_found = require_found;
+  if (lsock >= 0)
+    {
+      FD_ZERO (&r);
+      FD_SET (ret->listen_socket, &r);
+      FD_SET (ret->shutpipe[0], &r);
+      GNUNET_SCHEDULER_add_select (sched,
+                                   GNUNET_YES,
+                                   GNUNET_SCHEDULER_PRIORITY_HIGH,
+                                   GNUNET_SCHEDULER_NO_PREREQUISITE_TASK,
+                                   GNUNET_TIME_UNIT_FOREVER_REL,
+                                   GNUNET_MAX (ret->listen_socket,
+                                               ret->shutpipe[0]) + 1, &r,
+                                   NULL, &process_listen_socket, ret);
+    }
+  return ret;
+}
+
+
+/**
+ * Free resources held by this server.
+ */
+void
+GNUNET_SERVER_destroy (struct GNUNET_SERVER_Handle *s)
+{
+  static char c;
+
+  GNUNET_assert (s->do_shutdown == GNUNET_NO);
+  s->do_shutdown = GNUNET_YES;
+  if (s->listen_socket == -1)
+    destroy_server (s);
+  else
+    GNUNET_break (1 == WRITE (s->shutpipe[1], &c, 1));
+}
+
+
+/**
+ * Add additional handlers to an existing server.
+ *
+ * @param server the server to add handlers to
+ * @param handlers array of message handlers for
+ *        incoming messages; the last entry must
+ *        have "NULL" for the "callback"; multiple
+ *        entries for the same type are allowed,
+ *        they will be called in order of occurence.
+ *        These handlers can be removed later;
+ *        the handlers array must exist until removed
+ *        (or server is destroyed).
+ */
+void
+GNUNET_SERVER_add_handlers (struct GNUNET_SERVER_Handle *server,
+                            const struct GNUNET_SERVER_MessageHandler
+                            *handlers)
+{
+  struct HandlerList *p;
+
+  p = GNUNET_malloc (sizeof (struct HandlerList));
+  p->handlers = handlers;
+  p->next = server->handlers;
+  server->handlers = p;
+}
+
+
+/**
+ * Inject a message into the server, pretend it came
+ * from the specified client.  Delivery of the message
+ * will happen instantly (if a handler is installed;
+ * otherwise the call does nothing).
+ *
+ * @param server the server receiving the message
+ * @param sender the "pretended" sender of the message
+ *        can be NULL!
+ * @param message message to transmit
+ * @return GNUNET_OK if the message was OK and the
+ *                   connection can stay open
+ *         GNUNET_SYSERR if the connection to the
+ *         client should be shut down
+ */
+int
+GNUNET_SERVER_inject (struct GNUNET_SERVER_Handle *server,
+                      struct GNUNET_SERVER_Client *sender,
+                      const struct GNUNET_MessageHeader *message)
+{
+  struct HandlerList *pos;
+  const struct GNUNET_SERVER_MessageHandler *mh;
+  unsigned int i;
+  uint16_t type;
+  uint16_t size;
+  int found;
+
+  type = ntohs (message->type);
+  size = ntohs (message->size);
+  pos = server->handlers;
+  found = GNUNET_NO;
+  while (pos != NULL)
+    {
+      i = 0;
+      while (pos->handlers[i].callback != NULL)
+        {
+          mh = &pos->handlers[i];
+          if (mh->type == type)
+            {
+              if ((mh->expected_size != 0) && (mh->expected_size != size))
+                {
+                  GNUNET_break_op (0);
+                  return GNUNET_SYSERR;
+                }
+              if (sender != NULL)
+                sender->suspended++;
+              mh->callback (mh->callback_cls, server, sender, message);
+              found = GNUNET_YES;
+            }
+          i++;
+        }
+      pos = pos->next;
+    }
+  if (found == GNUNET_NO)
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG | GNUNET_ERROR_TYPE_BULK,
+                  _("Received message of unknown type %d\n"), type);
+      if (server->require_found == GNUNET_YES)
+        return GNUNET_SYSERR;
+    }
+  return GNUNET_OK;
+}
+
+
+/**
+ * We're finished with this client and especially its input
+ * processing.  If the RC is zero, free all resources otherwise wait
+ * until RC hits zero to do so.
+ */
+static void
+shutdown_incoming_processing (struct GNUNET_SERVER_Client *client)
+{
+  struct GNUNET_SERVER_Client *prev;
+  struct GNUNET_SERVER_Client *pos;
+  struct GNUNET_SERVER_Handle *server;
+  struct NotifyList *n;
+  unsigned int rc;
+
+  GNUNET_assert (client->my_receive == GNUNET_SCHEDULER_NO_PREREQUISITE_TASK);
+  rc = client->reference_count;
+  if (client->server != NULL)
+    {
+      server = client->server;
+      client->server = NULL;
+      prev = NULL;
+      pos = server->clients;
+      while ((pos != NULL) && (pos != client))
+        {
+          prev = pos;
+          pos = pos->next;
+        }
+      GNUNET_assert (pos != NULL);
+      if (prev == NULL)
+        server->clients = pos->next;
+      else
+        prev->next = pos->next;
+      n = server->disconnect_notify_list;
+      while (n != NULL)
+        {
+          n->callback (n->callback_cls, client);
+          n = n->next;
+        }
+    }
+  /* wait for RC to hit zero, then free */
+  if (rc > 0)
+    return;
+  client->destroy (client->client_closure);
+  GNUNET_free (client);
+}
+
+
+static void
+process_client_buffer (struct GNUNET_SERVER_Client *client)
+{
+  struct GNUNET_SERVER_Handle *server;
+  const struct GNUNET_MessageHeader *hdr;
+  size_t msize;
+
+  client->in_process_client_buffer = GNUNET_YES;
+  server = client->server;
+  while ((client->receive_pos >= sizeof (struct GNUNET_MessageHeader)) &&
+         (0 == client->suspended) && (GNUNET_YES != client->shutdown_now))
+    {
+      hdr = (const struct GNUNET_MessageHeader *) &client->incoming_buffer;
+      msize = ntohs (hdr->size);
+      if (msize > client->receive_pos)
+        break;
+      if ((msize < sizeof (struct GNUNET_MessageHeader)) ||
+          (GNUNET_OK != GNUNET_SERVER_inject (server, client, hdr)))
+        {
+          client->in_process_client_buffer = GNUNET_NO;
+          shutdown_incoming_processing (client);
+          return;
+        }
+      /* FIXME: this is highly inefficient; we should
+         try to avoid this if the new base address is
+         already nicely aligned.  See old handler code... */
+      memmove (client->incoming_buffer,
+               &client->incoming_buffer[msize], client->receive_pos - msize);
+      client->receive_pos -= msize;
+    }
+  client->in_process_client_buffer = GNUNET_NO;
+  if (GNUNET_YES == client->shutdown_now)
+    shutdown_incoming_processing (client);
+}
+
+
+/**
+ * We are receiving an incoming message.  Process it.
+ */
+static void
+process_incoming (void *cls,
+                  const void *buf,
+                  size_t available,
+                  const struct sockaddr *addr, socklen_t addrlen, int errCode)
+{
+  struct GNUNET_SERVER_Client *client = cls;
+  struct GNUNET_SERVER_Handle *server = client->server;
+  const char *cbuf = buf;
+  size_t maxcpy;
+
+  client->my_receive = GNUNET_SCHEDULER_NO_PREREQUISITE_TASK;
+  if ((buf == NULL) ||
+      (available == 0) ||
+      (errCode != 0) ||
+      (server == NULL) ||
+      (client->shutdown_now == GNUNET_YES) ||
+      (GNUNET_YES != client->check (client->client_closure)))
+    {
+      /* other side closed connection, error connecting, etc. */
+      shutdown_incoming_processing (client);
+      return;
+    }
+  GNUNET_SERVER_client_keep (client);
+  client->last_activity = GNUNET_TIME_absolute_get ();
+  /* process data (if available) */
+  while (available > 0)
+    {
+      maxcpy = available;
+      if (maxcpy > sizeof (client->incoming_buffer) - client->receive_pos)
+        maxcpy = sizeof (client->incoming_buffer) - client->receive_pos;
+      memcpy (&client->incoming_buffer[client->receive_pos], cbuf, maxcpy);
+      client->receive_pos += maxcpy;
+      cbuf += maxcpy;
+      available -= maxcpy;
+      if (0 < client->suspended)
+        {
+          if (available > 0)
+            {
+              client->side_buf_size = available;
+              client->side_buf = GNUNET_malloc (available);
+              memcpy (client->side_buf, cbuf, available);
+              available = 0;
+            }
+          break;                /* do not run next client iteration! */
+        }
+      process_client_buffer (client);
+    }
+  GNUNET_assert (available == 0);
+  if ((client->suspended == 0) &&
+      (GNUNET_YES != client->shutdown_now) && (client->server != NULL))
+    {
+      /* Finally, keep receiving! */
+      client->my_receive = client->receive (client->client_closure,
+                                            GNUNET_SERVER_MAX_MESSAGE_SIZE,
+                                            server->idle_timeout,
+                                            &process_incoming, client);
+    }
+  if (GNUNET_YES == client->shutdown_now)
+    shutdown_incoming_processing (client);
+  GNUNET_SERVER_client_drop (client);
+}
+
+
+static void
+restart_processing (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+{
+  struct GNUNET_SERVER_Client *client = cls;
+
+  process_client_buffer (client);
+  if (0 == client->suspended)
+    client->my_receive = client->receive (client->client_closure,
+                                          GNUNET_SERVER_MAX_MESSAGE_SIZE,
+                                          client->server->idle_timeout,
+                                          &process_incoming, client);
+}
+
+
+/**
+ * Add a client to the set of our clients and
+ * start receiving.
+ */
+static void
+add_client (struct GNUNET_SERVER_Handle *server,
+            struct GNUNET_SERVER_Client *client)
+{
+  client->server = server;
+  client->last_activity = GNUNET_TIME_absolute_get ();
+  client->next = server->clients;
+  server->clients = client;
+  client->my_receive = client->receive (client->client_closure,
+                                        GNUNET_SERVER_MAX_MESSAGE_SIZE,
+                                        server->idle_timeout,
+                                        &process_incoming, client);
+}
+
+static GNUNET_SCHEDULER_TaskIdentifier
+sock_receive (void *cls,
+              size_t max,
+              struct GNUNET_TIME_Relative timeout,
+              GNUNET_NETWORK_Receiver receiver, void *receiver_cls)
+{
+  return GNUNET_NETWORK_receive (cls, max, timeout, receiver, receiver_cls);
+}
+
+static void
+sock_receive_cancel (void *cls, GNUNET_SCHEDULER_TaskIdentifier ti)
+{
+  GNUNET_NETWORK_receive_cancel (cls, ti);
+}
+
+
+static void *
+sock_notify_transmit_ready (void *cls,
+                            size_t size,
+                            struct GNUNET_TIME_Relative timeout,
+                            GNUNET_NETWORK_TransmitReadyNotify notify,
+                            void *notify_cls)
+{
+  return GNUNET_NETWORK_notify_transmit_ready (cls, size, timeout, notify,
+                                               notify_cls);
+}
+
+
+static void
+sock_notify_transmit_ready_cancel (void *cls, void *h)
+{
+  GNUNET_NETWORK_notify_transmit_ready_cancel (h);
+}
+
+
+/**
+ * Check if socket is still valid (no fatal errors have happened so far).
+ *
+ * @param cls the socket
+ * @return GNUNET_YES if valid, GNUNET_NO otherwise
+ */
+static int
+sock_check (void *cls)
+{
+  return GNUNET_NETWORK_socket_check (cls);
+}
+
+
+/**
+ * Destroy this socket (free resources).
+ *
+ * @param cls the socket
+ */
+static void
+sock_destroy (void *cls)
+{
+  GNUNET_NETWORK_socket_destroy (cls);
+}
+
+
+/**
+ * Add a TCP socket-based connection to the set of handles managed by
+ * this server.  Use this function for outgoing (P2P) connections that
+ * we initiated (and where this server should process incoming
+ * messages).
+ *
+ * @param server the server to use
+ * @param connection the connection to manage (client must
+ *        stop using this connection from now on)
+ * @return the client handle (client should call
+ *         "client_drop" on the return value eventually)
+ */
+struct GNUNET_SERVER_Client *
+GNUNET_SERVER_connect_socket (struct
+                              GNUNET_SERVER_Handle
+                              *server,
+                              struct GNUNET_NETWORK_SocketHandle *connection)
+{
+  struct GNUNET_SERVER_Client *client;
+
+  client = GNUNET_malloc (sizeof (struct GNUNET_SERVER_Client));
+  client->client_closure = connection;
+  client->receive = &sock_receive;
+  client->receive_cancel = &sock_receive_cancel;
+  client->notify_transmit_ready = &sock_notify_transmit_ready;
+  client->notify_transmit_ready_cancel = &sock_notify_transmit_ready_cancel;
+  client->check = &sock_check;
+  client->destroy = &sock_destroy;
+  client->reference_count = 1;
+  add_client (server, client);
+  return client;
+}
+
+
+/**
+ * Add an arbitrary connection to the set of handles managed by this
+ * server.  This can be used if a sending and receiving does not
+ * really go over the network (internal transmission) or for servers
+ * using UDP.
+ *
+ * @param server the server to use
+ * @param chandle opaque handle for the connection
+ * @param creceive receive function for the connection
+ * @param ccancel cancel receive function for the connection
+ * @param cnotify transmit notification function for the connection
+ * @param cnotify_cancel transmit notification cancellation function for the connection
+ * @param ccheck function to test if the connection is still up
+ * @param cdestroy function to close and free the connection
+ * @return the client handle (client should call
+ *         "client_drop" on the return value eventually)
+ */
+struct GNUNET_SERVER_Client *
+GNUNET_SERVER_connect_callback (struct
+                                GNUNET_SERVER_Handle
+                                *server,
+                                void *chandle,
+                                GNUNET_SERVER_ReceiveCallback
+                                creceive,
+                                GNUNET_SERVER_ReceiveCancelCallback
+                                ccancel,
+                                GNUNET_SERVER_TransmitReadyCallback
+                                cnotify,
+                                GNUNET_SERVER_TransmitReadyCancelCallback
+                                cnotify_cancel,
+                                GNUNET_SERVER_CheckCallback
+                                ccheck,
+                                GNUNET_SERVER_DestroyCallback cdestroy)
+{
+  struct GNUNET_SERVER_Client *client;
+
+  client = GNUNET_malloc (sizeof (struct GNUNET_SERVER_Client));
+  client->client_closure = chandle;
+  client->receive = creceive;
+  client->receive_cancel = ccancel;
+  client->notify_transmit_ready = cnotify;
+  client->notify_transmit_ready_cancel = cnotify_cancel;
+  client->check = ccheck;
+  client->destroy = cdestroy;
+  client->reference_count = 1;
+  add_client (server, client);
+  return client;
+}
+
+
+/**
+ * Notify the server that the given client handle should
+ * be kept (keeps the connection up if possible, increments
+ * the internal reference counter).
+ *
+ * @param client the client to keep
+ */
+void
+GNUNET_SERVER_client_keep (struct GNUNET_SERVER_Client *client)
+{
+  client->reference_count++;
+}
+
+
+/**
+ * Notify the server that the given client handle is no
+ * longer required.  Decrements the reference counter.  If
+ * that counter reaches zero an inactive connection maybe
+ * closed.
+ *
+ * @param client the client to drop
+ */
+void
+GNUNET_SERVER_client_drop (struct GNUNET_SERVER_Client *client)
+{
+  GNUNET_assert (client->reference_count > 0);
+  client->reference_count--;
+  if ((client->server == NULL) && (client->reference_count == 0))
+    shutdown_incoming_processing (client);
+}
+
+
+/**
+ * Obtain the network address of the other party.
+ *
+ * @param client the client to get the address for
+ * @param addr where to store the address
+ * @param addrlen where to store the length of the address
+ * @return GNUNET_OK on success
+ */
+int
+GNUNET_SERVER_client_get_address (struct GNUNET_SERVER_Client *client,
+                                  void **addr, size_t * addrlen)
+{
+  if (client->receive != &sock_receive)
+    return GNUNET_SYSERR;       /* not a network client */
+  return GNUNET_NETWORK_socket_get_address (client->client_closure,
+                                            addr, addrlen);
+}
+
+
+/**
+ * Ask the server to notify us whenever a client disconnects.
+ * This function is called whenever the actual network connection
+ * is closed; the reference count may be zero or larger than zero
+ * at this point.
+ *
+ * @param server the server manageing the clients
+ * @param callback function to call on disconnect
+ * @param callback_cls closure for callback
+ */
+void
+GNUNET_SERVER_disconnect_notify (struct GNUNET_SERVER_Handle *server,
+                                 GNUNET_SERVER_DisconnectCallback callback,
+                                 void *callback_cls)
+{
+  struct NotifyList *n;
+
+  n = GNUNET_malloc (sizeof (struct NotifyList));
+  n->callback = callback;
+  n->callback_cls = callback_cls;
+  n->next = server->disconnect_notify_list;
+  server->disconnect_notify_list = n;
+}
+
+
+/**
+ * Ask the server to disconnect from the given client.
+ * This is the same as returning GNUNET_SYSERR from a message
+ * handler, except that it allows dropping of a client even
+ * when not handling a message from that client.
+ *
+ * @param client the client to disconnect from
+ */
+void
+GNUNET_SERVER_client_disconnect (struct GNUNET_SERVER_Client *client)
+{
+  if (client->server == NULL)
+    return;                     /* already disconnected */
+  GNUNET_assert (client->my_receive != GNUNET_SCHEDULER_NO_PREREQUISITE_TASK);
+  client->receive_cancel (client->client_closure, client->my_receive);
+  client->my_receive = GNUNET_SCHEDULER_NO_PREREQUISITE_TASK;
+  shutdown_incoming_processing (client);
+}
+
+
+/**
+ * Notify us when the server has enough space to transmit
+ * a message of the given size to the given client.
+ *
+ * @param server the server to use
+ * @param client client to transmit message to
+ * @param size requested amount of buffer space
+ * @param timeout after how long should we give up (and call
+ *        notify with buf NULL and size 0)?
+ * @param callback function to call when space is available
+ * @param callback_cls closure for callback
+ * @return non-NULL if the notify callback was queued; can be used
+ *           to cancel the request using
+ *           GNUNET_NETWORK_notify_transmit_ready_cancel.
+ *         NULL if we are already going to notify someone else (busy)
+ */
+struct GNUNET_NETWORK_TransmitHandle *
+GNUNET_SERVER_notify_transmit_ready (struct GNUNET_SERVER_Client *client,
+                                     size_t size,
+                                     struct GNUNET_TIME_Relative timeout,
+                                     GNUNET_NETWORK_TransmitReadyNotify
+                                     callback, void *callback_cls)
+{
+  return client->notify_transmit_ready (client->client_closure,
+                                        size,
+                                        timeout, callback, callback_cls);
+}
+
+
+/**
+ * Resume receiving from this client, we are done processing the
+ * current request.  This function must be called from within each
+ * GNUNET_SERVER_MessageCallback (or its respective continuations).
+ *
+ * @param client client we were processing a message of
+ * @param success GNUNET_OK to keep the connection open and
+ *                          continue to receive
+ *                GNUNET_SYSERR to close the connection (signal
+ *                          serious error)
+ */
+void
+GNUNET_SERVER_receive_done (struct GNUNET_SERVER_Client *client, int success)
+{
+  char *sb;
+
+  if (client == NULL)
+    return;
+  GNUNET_assert (client->suspended > 0);
+  client->suspended--;
+  if (success != GNUNET_OK)
+    client->shutdown_now = GNUNET_YES;
+  if (client->suspended > 0)
+    return;
+  if (client->in_process_client_buffer == GNUNET_YES)
+    return;
+  if (client->side_buf_size > 0)
+    {
+      /* resume processing from side-buf */
+      sb = client->side_buf;
+      client->side_buf = NULL;
+      /* this will also resume the receive job */
+      if (GNUNET_YES != client->shutdown_now)
+        process_incoming (client, sb, client->side_buf_size, NULL, 0, 0);
+      else
+        shutdown_incoming_processing (client);
+      /* finally, free the side-buf */
+      GNUNET_free (sb);
+      return;
+    }
+  /* resume receive job */
+  if (GNUNET_YES != client->shutdown_now)
+    {
+      GNUNET_SCHEDULER_add_continuation (client->server->sched,
+                                         GNUNET_NO,
+                                         &restart_processing,
+                                         client,
+                                         GNUNET_SCHEDULER_REASON_PREREQ_DONE);
+      return;
+    }
+  shutdown_incoming_processing (client);
+}
+
+
+/* end of server.c */
diff --git a/src/util/server_tc.c b/src/util/server_tc.c
new file mode 100644
index 000000000..dc51e1433
--- /dev/null
+++ b/src/util/server_tc.c
@@ -0,0 +1,198 @@
+/*
+     This file is part of GNUnet.
+     (C) 2009 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 util/server_tc.c
+ * @brief convenience functions for transmission of
+ *        complex responses as a server
+ * @author Christian Grothoff
+ */
+
+#include "platform.h"
+#include "gnunet_common.h"
+#include "gnunet_network_lib.h"
+#include "gnunet_scheduler_lib.h"
+#include "gnunet_server_lib.h"
+#include "gnunet_time_lib.h"
+
+
+
+/**
+ * How much buffer space do we want to have at least
+ * before transmitting another increment?
+ */
+#define MIN_BLOCK_SIZE 128
+
+
+
+struct GNUNET_SERVER_TransmitContext
+{
+  /**
+   * Which client are we transmitting to?
+   */
+  struct GNUNET_SERVER_Client *client;
+
+  /**
+   * Transmission buffer. (current offset for writing).
+   */
+  char *buf;
+
+  /**
+   * Number of bytes in buf.
+   */
+  size_t total;
+
+  /**
+   * Offset for writing in buf.
+   */
+  size_t off;
+
+  /**
+   * Timeout for this request.
+   */
+  struct GNUNET_TIME_Absolute timeout;
+};
+
+
+/**
+ * Helper function for incremental transmission of the response.
+ */
+static size_t
+transmit_response (void *cls, size_t size, void *buf)
+{
+  struct GNUNET_SERVER_TransmitContext *tc = cls;
+  size_t msize;
+  if (buf == NULL)
+    {
+      GNUNET_SERVER_receive_done (tc->client, GNUNET_SYSERR);
+      GNUNET_free_non_null (tc->buf);
+      GNUNET_free (tc);
+      return 0;
+    }
+  if (tc->total - tc->off > size)
+    msize = size;
+  else
+    msize = tc->total - tc->off;
+  memcpy (buf, &tc->buf[tc->off], msize);
+  tc->off += msize;
+  if (tc->total == tc->off)
+    {
+      GNUNET_SERVER_receive_done (tc->client, GNUNET_OK);
+      GNUNET_free_non_null (tc->buf);
+      GNUNET_free (tc);
+    }
+  else
+    {
+      if (NULL == GNUNET_SERVER_notify_transmit_ready (tc->client,
+                                                       GNUNET_MIN
+                                                       (MIN_BLOCK_SIZE,
+                                                        tc->total - tc->off),
+                                                       GNUNET_TIME_absolute_get_remaining
+                                                       (tc->timeout),
+                                                       &transmit_response,
+                                                       tc))
+        {
+          GNUNET_break (0);
+          GNUNET_SERVER_receive_done (tc->client, GNUNET_SYSERR);
+          GNUNET_free_non_null (tc->buf);
+          GNUNET_free (tc);
+        }
+    }
+  return msize;
+}
+
+
+/**
+ * Create a new transmission context for the
+ * given client.
+ *
+ * @param client client to create the context for.
+ * @return NULL on error
+ */
+struct GNUNET_SERVER_TransmitContext *
+GNUNET_SERVER_transmit_context_create (struct GNUNET_SERVER_Client *client)
+{
+  struct GNUNET_SERVER_TransmitContext *tc;
+
+  GNUNET_assert (client != NULL);
+  tc = GNUNET_malloc (sizeof (struct GNUNET_SERVER_TransmitContext));
+  tc->client = client;
+  return tc;
+}
+
+
+/**
+ * Append a message to the transmission context.
+ * All messages in the context will be sent by
+ * the transmit_context_run method.
+ *
+ * @param tc context to use
+ * @param data what to append to the result message
+ * @param length length of data
+ * @param type type of the message
+ */
+void
+GNUNET_SERVER_transmit_context_append (struct GNUNET_SERVER_TransmitContext
+                                       *tc, const void *data, size_t length,
+                                       uint16_t type)
+{
+  struct GNUNET_MessageHeader *msg;
+  size_t size;
+
+  GNUNET_assert (length < GNUNET_SERVER_MAX_MESSAGE_SIZE);
+  size = length + sizeof (struct GNUNET_MessageHeader);
+  GNUNET_assert (size > length);
+  tc->buf = GNUNET_realloc (tc->buf, tc->total + size);
+  msg = (struct GNUNET_MessageHeader *) &tc->buf[tc->total];
+  tc->total += size;
+  msg->size = htons (size);
+  msg->type = htons (type);
+  memcpy (&msg[1], data, length);
+}
+
+
+/**
+ * Execute a transmission context.  If there is
+ * an error in the transmission, the receive_done
+ * method will be called with an error code (GNUNET_SYSERR),
+ * otherwise with GNUNET_OK.
+ *
+ * @param tc transmission context to use
+ * @param timeout when to time out and abort the transmission
+ */
+void
+GNUNET_SERVER_transmit_context_run (struct GNUNET_SERVER_TransmitContext *tc,
+                                    struct GNUNET_TIME_Relative timeout)
+{
+  tc->timeout = GNUNET_TIME_relative_to_absolute (timeout);
+  if (NULL ==
+      GNUNET_SERVER_notify_transmit_ready (tc->client,
+                                           GNUNET_MIN (MIN_BLOCK_SIZE,
+                                                       tc->total), timeout,
+                                           &transmit_response, tc))
+    {
+      GNUNET_break (0);
+      GNUNET_SERVER_receive_done (tc->client, GNUNET_SYSERR);
+      GNUNET_free_non_null (tc->buf);
+      GNUNET_free (tc);
+    }
+}
+
+/* end of server_tc.c */
diff --git a/src/util/service.c b/src/util/service.c
new file mode 100644
index 000000000..af71db692
--- /dev/null
+++ b/src/util/service.c
@@ -0,0 +1,1451 @@
+/*
+     This file is part of GNUnet.
+     (C) 2009 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 util/service.c
+ * @brief functions related to starting services
+ * @author Christian Grothoff
+ */
+#include "platform.h"
+#include "gnunet_common.h"
+#include "gnunet_configuration_lib.h"
+#include "gnunet_crypto_lib.h"
+#include "gnunet_directories.h"
+#include "gnunet_disk_lib.h"
+#include "gnunet_getopt_lib.h"
+#include "gnunet_os_lib.h"
+#include "gnunet_protocols.h"
+#include "gnunet_server_lib.h"
+#include "gnunet_service_lib.h"
+
+/* ******************* access control ******************** */
+
+/**
+ * @brief IPV4 network in CIDR notation.
+ */
+struct IPv4NetworkSet
+{
+  struct in_addr network;
+  struct in_addr netmask;
+};
+
+/**
+ * @brief network in CIDR notation for IPV6.
+ */
+struct IPv6NetworkSet
+{
+  struct in6_addr network;
+  struct in6_addr netmask;
+};
+
+
+/**
+ * Parse a network specification. The argument specifies
+ * a list of networks. The format is
+ * <tt>[network/netmask;]*</tt> (no whitespace, must be terminated
+ * with a semicolon). The network must be given in dotted-decimal
+ * notation. The netmask can be given in CIDR notation (/16) or
+ * in dotted-decimal (/255.255.0.0).
+ * <p>
+ * @param routeList a string specifying the forbidden networks
+ * @return the converted list, NULL if the synatx is flawed
+ */
+static struct IPv4NetworkSet *
+parse_ipv4_specification (const char *routeList)
+{
+  unsigned int count;
+  unsigned int i;
+  unsigned int j;
+  unsigned int len;
+  int cnt;
+  unsigned int pos;
+  unsigned int temps[8];
+  int slash;
+  struct IPv4NetworkSet *result;
+
+  if (routeList == NULL)
+    return NULL;
+  len = strlen (routeList);
+  if (len == 0)
+    return NULL;
+  count = 0;
+  for (i = 0; i < len; i++)
+    if (routeList[i] == ';')
+      count++;
+  result = GNUNET_malloc (sizeof (struct IPv4NetworkSet) * (count + 1));
+  /* add termination */
+  memset (result, 0, sizeof (struct IPv4NetworkSet) * (count + 1));
+  i = 0;
+  pos = 0;
+  while (i < count)
+    {
+      cnt = sscanf (&routeList[pos],
+                    "%u.%u.%u.%u/%u.%u.%u.%u;",
+                    &temps[0],
+                    &temps[1],
+                    &temps[2],
+                    &temps[3], &temps[4], &temps[5], &temps[6], &temps[7]);
+      if (cnt == 8)
+        {
+          for (j = 0; j < 8; j++)
+            if (temps[j] > 0xFF)
+              {
+                GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                            _("Invalid format for IP: `%s'\n"),
+                            &routeList[pos]);
+                GNUNET_free (result);
+                return NULL;
+              }
+          result[i].network.s_addr
+            =
+            htonl ((temps[0] << 24) + (temps[1] << 16) + (temps[2] << 8) +
+                   temps[3]);
+          result[i].netmask.s_addr =
+            htonl ((temps[4] << 24) + (temps[5] << 16) + (temps[6] << 8) +
+                   temps[7]);
+          while (routeList[pos] != ';')
+            pos++;
+          pos++;
+          i++;
+          continue;
+        }
+      /* try second notation */
+      cnt = sscanf (&routeList[pos],
+                    "%u.%u.%u.%u/%u;",
+                    &temps[0], &temps[1], &temps[2], &temps[3], &slash);
+      if (cnt == 5)
+        {
+          for (j = 0; j < 4; j++)
+            if (temps[j] > 0xFF)
+              {
+                GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                            _("Invalid format for IP: `%s'\n"),
+                            &routeList[pos]);
+                GNUNET_free (result);
+                return NULL;
+              }
+          result[i].network.s_addr
+            =
+            htonl ((temps[0] << 24) + (temps[1] << 16) + (temps[2] << 8) +
+                   temps[3]);
+          if ((slash <= 32) && (slash >= 0))
+            {
+              result[i].netmask.s_addr = 0;
+              while (slash > 0)
+                {
+                  result[i].netmask.s_addr
+                    = (result[i].netmask.s_addr >> 1) + 0x80000000;
+                  slash--;
+                }
+              result[i].netmask.s_addr = htonl (result[i].netmask.s_addr);
+              while (routeList[pos] != ';')
+                pos++;
+              pos++;
+              i++;
+              continue;
+            }
+          else
+            {
+              GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                          _
+                          ("Invalid network notation ('/%d' is not legal in IPv4 CIDR)."),
+                          slash);
+              GNUNET_free (result);
+              return NULL;      /* error */
+            }
+        }
+      /* try third notation */
+      slash = 32;
+      cnt = sscanf (&routeList[pos],
+                    "%u.%u.%u.%u;",
+                    &temps[0], &temps[1], &temps[2], &temps[3]);
+      if (cnt == 4)
+        {
+          for (j = 0; j < 4; j++)
+            if (temps[j] > 0xFF)
+              {
+                GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                            _("Invalid format for IP: `%s'\n"),
+                            &routeList[pos]);
+                GNUNET_free (result);
+                return NULL;
+              }
+          result[i].network.s_addr
+            =
+            htonl ((temps[0] << 24) + (temps[1] << 16) + (temps[2] << 8) +
+                   temps[3]);
+          result[i].netmask.s_addr = 0;
+          while (slash > 0)
+            {
+              result[i].netmask.s_addr
+                = (result[i].netmask.s_addr >> 1) + 0x80000000;
+              slash--;
+            }
+          result[i].netmask.s_addr = htonl (result[i].netmask.s_addr);
+          while (routeList[pos] != ';')
+            pos++;
+          pos++;
+          i++;
+          continue;
+        }
+      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                  _("Invalid format for IP: `%s'\n"), &routeList[pos]);
+      GNUNET_free (result);
+      return NULL;              /* error */
+    }
+  if (pos < strlen (routeList))
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                  _("Invalid format for IP: `%s'\n"), &routeList[pos]);
+      GNUNET_free (result);
+      return NULL;              /* oops */
+    }
+  return result;                /* ok */
+}
+
+
+/**
+ * Parse a network specification. The argument specifies
+ * a list of networks. The format is
+ * <tt>[network/netmask;]*</tt> (no whitespace, must be terminated
+ * with a semicolon). The network must be given in colon-hex
+ * notation.  The netmask must be given in CIDR notation (/16) or
+ * can be omitted to specify a single host.
+ * <p>
+ * @param routeList a string specifying the forbidden networks
+ * @return the converted list, NULL if the synatx is flawed
+ */
+static struct IPv6NetworkSet *
+parse_ipv6_specification (const char *routeListX)
+{
+  unsigned int count;
+  unsigned int i;
+  unsigned int len;
+  unsigned int pos;
+  int start;
+  int slash;
+  int ret;
+  char *routeList;
+  struct IPv6NetworkSet *result;
+  unsigned int bits;
+  unsigned int off;
+  int save;
+
+  if (routeListX == NULL)
+    return NULL;
+  len = strlen (routeListX);
+  if (len == 0)
+    return NULL;
+  routeList = GNUNET_strdup (routeListX);
+  count = 0;
+  for (i = 0; i < len; i++)
+    if (routeList[i] == ';')
+      count++;
+  if (routeList[len - 1] != ';')
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                  _
+                  ("Invalid network notation (does not end with ';': `%s')\n"),
+                  routeList);
+      GNUNET_free (routeList);
+      return NULL;
+    }
+
+  result = GNUNET_malloc (sizeof (struct IPv6NetworkSet) * (count + 1));
+  memset (result, 0, sizeof (struct IPv6NetworkSet) * (count + 1));
+  i = 0;
+  pos = 0;
+  while (i < count)
+    {
+      start = pos;
+      while (routeList[pos] != ';')
+        pos++;
+      slash = pos;
+      while ((slash >= start) && (routeList[slash] != '/'))
+        slash--;
+      if (slash < start)
+        {
+          memset (&result[i].netmask, 0xFF, sizeof (struct in6_addr));
+          slash = pos;
+        }
+      else
+        {
+          routeList[pos] = '\0';
+          ret = inet_pton (AF_INET6,
+                           &routeList[slash + 1], &result[i].netmask);
+          if (ret <= 0)
+            {
+              save = errno;
+              if ((1 != SSCANF (&routeList[slash + 1],
+                                "%u", &bits)) || (bits >= 128))
+                {
+                  if (ret == 0)
+                    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                                _("Wrong format `%s' for netmask\n"),
+                                &routeList[slash + 1]);
+                  else
+                    {
+                      errno = save;
+                      GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR,
+                                           "inet_pton");
+                    }
+                  GNUNET_free (result);
+                  GNUNET_free (routeList);
+                  return NULL;
+                }
+              off = 0;
+              while (bits > 8)
+                {
+                  result[i].netmask.s6_addr[off++] = 0xFF;
+                  bits -= 8;
+                }
+              while (bits > 0)
+                {
+                  result[i].netmask.s6_addr[off]
+                    = (result[i].netmask.s6_addr[off] >> 1) + 0x80;
+                  bits--;
+                }
+            }
+        }
+      routeList[slash] = '\0';
+      ret = inet_pton (AF_INET6, &routeList[start], &result[i].network);
+      if (ret <= 0)
+        {
+          if (ret == 0)
+            GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                        _("Wrong format `%s' for network\n"),
+                        &routeList[slash + 1]);
+          else
+            GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "inet_pton");
+          GNUNET_free (result);
+          GNUNET_free (routeList);
+          return NULL;
+        }
+      pos++;
+      i++;
+    }
+  GNUNET_free (routeList);
+  return result;
+}
+
+
+/**
+ * Check if the given IP address is in the list of IP addresses.
+ *
+ * @param list a list of networks
+ * @param ip the IP to check (in network byte order)
+ * @return GNUNET_NO if the IP is not in the list, GNUNET_YES if it it is
+ */
+static int
+check_ipv4_listed (const struct IPv4NetworkSet *list,
+                   const struct in_addr *add)
+{
+  int i;
+
+  i = 0;
+  if (list == NULL)
+    return GNUNET_NO;
+
+  while ((list[i].network.s_addr != 0) || (list[i].netmask.s_addr != 0))
+    {
+      if ((add->s_addr & list[i].netmask.s_addr) ==
+          (list[i].network.s_addr & list[i].netmask.s_addr))
+        return GNUNET_YES;
+      i++;
+    }
+  return GNUNET_NO;
+}
+
+/**
+ * Check if the given IP address is in the list of IP addresses.
+ *
+ * @param list a list of networks
+ * @param ip the IP to check (in network byte order)
+ * @return GNUNET_NO if the IP is not in the list, GNUNET_YES if it it is
+ */
+static int
+check_ipv6_listed (const struct IPv6NetworkSet *list,
+                   const struct in6_addr *ip)
+{
+  unsigned int i;
+  unsigned int j;
+  struct in6_addr zero;
+
+  if (list == NULL)
+    return GNUNET_NO;
+
+  memset (&zero, 0, sizeof (struct in6_addr));
+  i = 0;
+NEXT:
+  while (memcmp (&zero, &list[i].network, sizeof (struct in6_addr)) != 0)
+    {
+      for (j = 0; j < sizeof (struct in6_addr) / sizeof (int); j++)
+        if (((((int *) ip)[j] & ((int *) &list[i].netmask)[j])) !=
+            (((int *) &list[i].network)[j] & ((int *) &list[i].netmask)[j]))
+          {
+            i++;
+            goto NEXT;
+          }
+      return GNUNET_YES;
+    }
+  return GNUNET_NO;
+}
+
+
+/* ****************** service struct ****************** */
+
+
+/**
+ * Context for "service_task".
+ */
+struct GNUNET_SERVICE_Context
+{
+  /**
+   * Our configuration.
+   */
+  struct GNUNET_CONFIGURATION_Handle *cfg;
+
+  /**
+   * Handle for the server.
+   */
+  struct GNUNET_SERVER_Handle *server;
+
+  /**
+   * Scheduler for the server.
+   */
+  struct GNUNET_SCHEDULER_Handle *sched;
+
+  /**
+   * Address to bind to.
+   */
+  struct sockaddr *addr;
+
+  /**
+   * Name of our service.
+   */
+  const char *serviceName;
+
+  /**
+   * Main service-specific task to run.
+   */
+  GNUNET_SERVICE_Main task;
+
+  /**
+   * Closure for task.
+   */
+  void *task_cls;
+
+  /**
+   * IPv4 addresses that are not allowed to connect.
+   */
+  struct IPv4NetworkSet *v4_denied;
+
+  /**
+   * IPv6 addresses that are not allowed to connect.
+   */
+  struct IPv6NetworkSet *v6_denied;
+
+  /**
+   * IPv4 addresses that are allowed to connect (if not
+   * set, all are allowed).
+   */
+  struct IPv4NetworkSet *v4_allowed;
+
+  /**
+   * IPv6 addresses that are allowed to connect (if not
+   * set, all are allowed).
+   */
+  struct IPv6NetworkSet *v6_allowed;
+
+  /**
+   * My (default) message handlers.  Adjusted copy
+   * of "defhandlers".
+   */
+  struct GNUNET_SERVER_MessageHandler *my_handlers;
+
+  /**
+   * Idle timeout for server.
+   */
+  struct GNUNET_TIME_Relative timeout;
+
+  /**
+   * Maximum buffer size for the server.
+   */
+  size_t maxbuf;
+
+  /**
+   * Overall success/failure of the service start.
+   */
+  int ret;
+
+  /**
+   * If we are daemonizing, this FD is set to the
+   * pipe to the parent.  Send '.' if we started
+   * ok, '!' if not.  -1 if we are not daemonizing.
+   */
+  int ready_confirm_fd;
+
+  /**
+   * Do we close connections if we receive messages
+   * for which we have no handler?
+   */
+  int require_found;
+
+  /**
+   * Can clients ask us to initiate a shutdown?
+   */
+  int allow_shutdown;
+
+  /**
+   * Length of addr.
+   */
+  socklen_t addrlen;
+
+};
+
+
+/* ****************** message handlers ****************** */
+
+static size_t
+write_test (void *cls, size_t size, void *buf)
+{
+  struct GNUNET_SERVER_Client *client = cls;
+  struct GNUNET_MessageHeader *msg;
+
+  if (size < sizeof (struct GNUNET_MessageHeader))
+    {
+      GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
+      return 0;                 /* client disconnected */
+    }
+  msg = (struct GNUNET_MessageHeader *) buf;
+  msg->type = htons (GNUNET_MESSAGE_TYPE_TEST);
+  msg->size = htons (sizeof (struct GNUNET_MessageHeader));
+  GNUNET_SERVER_receive_done (client, GNUNET_OK);
+  return sizeof (struct GNUNET_MessageHeader);
+}
+
+/**
+ * Handler for TEST message.
+ *
+ * @param cls closure (refers to service)
+ * @param server the server handling the message
+ * @param client identification of the client
+ * @param message the actual message
+ */
+static void
+handle_test (void *cls,
+             struct GNUNET_SERVER_Handle *server,
+             struct GNUNET_SERVER_Client *client,
+             const struct GNUNET_MessageHeader *message)
+{
+  /* simply bounce message back to acknowledge */
+  if (NULL == GNUNET_SERVER_notify_transmit_ready (client,
+                                                   sizeof (struct
+                                                           GNUNET_MessageHeader),
+                                                   GNUNET_TIME_UNIT_FOREVER_REL,
+                                                   &write_test, client))
+    GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
+}
+
+
+/**
+ * Handler for SHUTDOWN message.
+ *
+ * @param cls closure (refers to service)
+ * @param server the server handling the message
+ * @param client identification of the client
+ * @param message the actual message
+ */
+static void
+handle_shutdown (void *cls,
+                 struct GNUNET_SERVER_Handle *server,
+                 struct GNUNET_SERVER_Client *client,
+                 const struct GNUNET_MessageHeader *message)
+{
+  struct GNUNET_SERVICE_Context *service = cls;
+  if (!service->allow_shutdown)
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                  _
+                  ("Received shutdown request, but configured to ignore!\n"));
+      GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
+      return;
+    }
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+              _("Initiating shutdown as requested by client.\n"));
+  GNUNET_assert (service->sched != NULL);
+  GNUNET_SCHEDULER_shutdown (service->sched);
+  GNUNET_SERVER_receive_done (client, GNUNET_OK);
+}
+
+
+/**
+ * Default handlers for all services.  Will be copied and the
+ * "callback_cls" fields will be replaced with the specific service
+ * struct.
+ */
+static const struct GNUNET_SERVER_MessageHandler defhandlers[] = {
+  {&handle_test, NULL, GNUNET_MESSAGE_TYPE_TEST,
+   sizeof (struct GNUNET_MessageHeader)},
+  {&handle_shutdown, NULL, GNUNET_MESSAGE_TYPE_SHUTDOWN,
+   sizeof (struct GNUNET_MessageHeader)},
+  {NULL, NULL, 0, 0}
+};
+
+
+
+/* ****************** service core routines ************** */
+
+
+/**
+ * Check if access to the service is allowed from the given address.
+ */
+static int
+check_access (void *cls, const struct sockaddr *addr, socklen_t addrlen)
+{
+  struct GNUNET_SERVICE_Context *sctx = cls;
+  const struct sockaddr_in *i4;
+  const struct sockaddr_in6 *i6;
+  int ret;
+  char buf[INET6_ADDRSTRLEN];
+  uint16_t port;
+
+  switch (addr->sa_family)
+    {
+    case AF_INET:
+      GNUNET_assert (addrlen == sizeof (struct sockaddr_in));
+      i4 = (const struct sockaddr_in *) addr;
+      port = ntohs (i4->sin_port);
+      ret = ((sctx->v4_allowed == NULL) ||
+             (check_ipv4_listed (sctx->v4_allowed,
+                                 &i4->sin_addr)))
+        && ((sctx->v4_denied == NULL) ||
+            (!check_ipv4_listed (sctx->v4_denied, &i4->sin_addr)));
+      if (ret != GNUNET_OK)
+        inet_ntop (AF_INET, &i4->sin_addr, buf, sizeof (buf));
+      break;
+    case AF_INET6:
+      GNUNET_assert (addrlen == sizeof (struct sockaddr_in6));
+      i6 = (const struct sockaddr_in6 *) addr;
+      port = ntohs (i6->sin6_port);
+      ret = ((sctx->v6_allowed == NULL) ||
+             (check_ipv6_listed (sctx->v6_allowed,
+                                 &i6->sin6_addr)))
+        && ((sctx->v6_denied == NULL) ||
+            (!check_ipv6_listed (sctx->v6_denied, &i6->sin6_addr)));
+      if (ret != GNUNET_OK)
+        inet_ntop (AF_INET6, &i6->sin6_addr, buf, sizeof (buf));
+      break;
+    default:
+      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                  _("Unknown address family %d\n"), addr->sa_family);
+      return GNUNET_SYSERR;
+    }
+  if (ret != GNUNET_OK)
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                  _("Access from `%s:%u' denied to service `%s'\n"),
+                  buf, port, sctx->serviceName);
+    }
+  return ret;
+}
+
+
+/**
+ * Get the name of the file where we will
+ * write the PID of the service.
+ */
+static char *
+get_pid_file_name (struct GNUNET_SERVICE_Context *sctx)
+{
+
+  char *pif;
+
+  if (GNUNET_OK !=
+      GNUNET_CONFIGURATION_get_value_filename (sctx->cfg,
+                                               sctx->serviceName,
+                                               "PIDFILE", &pif))
+    return NULL;
+  return pif;
+}
+
+
+/**
+ * Parse an IPv4 access control list.
+ */
+static int
+process_acl4 (struct IPv4NetworkSet **ret,
+              struct GNUNET_SERVICE_Context *sctx, const char *option)
+{
+  char *opt;
+
+  if (!GNUNET_CONFIGURATION_have_value (sctx->cfg, sctx->serviceName, option))
+    return GNUNET_OK;
+  GNUNET_break (GNUNET_OK ==
+                GNUNET_CONFIGURATION_get_value_string (sctx->cfg,
+                                                       sctx->serviceName,
+                                                       option, &opt));
+  if (NULL == (*ret = parse_ipv4_specification (opt)))
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                  _
+                  ("Could not parse IPv4 network specification `%s' for `%s:%s'\n"),
+                  opt, sctx->serviceName, option);
+      GNUNET_free (opt);
+      return GNUNET_SYSERR;
+    }
+  GNUNET_free (opt);
+  return GNUNET_OK;
+}
+
+
+/**
+ * Parse an IPv4 access control list.
+ */
+static int
+process_acl6 (struct IPv6NetworkSet **ret,
+              struct GNUNET_SERVICE_Context *sctx, const char *option)
+{
+  char *opt;
+  if (!GNUNET_CONFIGURATION_have_value (sctx->cfg, sctx->serviceName, option))
+    return GNUNET_OK;
+  GNUNET_break (GNUNET_OK ==
+                GNUNET_CONFIGURATION_get_value_string (sctx->cfg,
+                                                       sctx->serviceName,
+                                                       option, &opt));
+  if (NULL == (*ret = parse_ipv6_specification (opt)))
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                  _
+                  ("Could not parse IPv6 network specification `%s' for `%s:%s'\n"),
+                  opt, sctx->serviceName, option);
+      GNUNET_free (opt);
+      return GNUNET_SYSERR;
+    }
+  GNUNET_free (opt);
+  return GNUNET_OK;
+}
+
+
+/**
+ * Setup addr, addrlen, maxbuf, idle_timeout
+ * based on configuration!
+ *
+ * Configuration must specify a "PORT".  It may
+ * specify:
+ * - TIMEOUT (after how many ms does an inactive service timeout);
+ * - MAXBUF (maximum incoming message size supported)
+ * - DISABLEV6 (disable support for IPv6, otherwise we use dual-stack)
+ * - ALLOW_SHUTDOWN (allow clients to shutdown this service)
+ * - BINDTO (hostname or IP address to bind to, otherwise we take everything)
+ * - ACCEPT_FROM  (only allow connections from specified IPv4 subnets)
+ * - ACCEPT_FROM6 (only allow connections from specified IPv6 subnets)
+ * - REJECT_FROM  (disallow allow connections from specified IPv4 subnets)
+ * - REJECT_FROM6 (disallow allow connections from specified IPv6 subnets)
+ *
+ * @return GNUNET_OK if configuration succeeded
+ */
+static int
+setup_service (struct GNUNET_SERVICE_Context *sctx)
+{
+  unsigned long long maxbuf;
+  unsigned long long idleout;
+  char *hostname;
+  unsigned long long port;
+  int disablev6;
+  struct addrinfo hints;
+  struct addrinfo *res;
+  struct addrinfo *pos;
+  int ret;
+  int tolerant;
+
+  if (GNUNET_CONFIGURATION_have_value (sctx->cfg,
+                                       sctx->serviceName, "TIMEOUT"))
+    {
+      if (GNUNET_OK !=
+          GNUNET_CONFIGURATION_get_value_number (sctx->cfg,
+                                                 sctx->serviceName,
+                                                 "TIMEOUT", &idleout))
+        return GNUNET_SYSERR;
+
+      sctx->timeout.value = idleout;
+    }
+  else
+    sctx->timeout = GNUNET_TIME_UNIT_FOREVER_REL;
+  if (GNUNET_CONFIGURATION_have_value (sctx->cfg,
+                                       sctx->serviceName, "MAXBUF"))
+    {
+      if (GNUNET_OK !=
+          GNUNET_CONFIGURATION_get_value_number (sctx->cfg,
+                                                 sctx->serviceName,
+                                                 "MAXBUF", &maxbuf))
+        return GNUNET_SYSERR;
+    }
+  else
+    maxbuf = GNUNET_SERVER_MAX_MESSAGE_SIZE;
+  if (GNUNET_CONFIGURATION_have_value (sctx->cfg,
+                                       sctx->serviceName, "DISABLEV6"))
+    {
+      if (GNUNET_SYSERR ==
+          (disablev6 = GNUNET_CONFIGURATION_get_value_yesno (sctx->cfg,
+                                                             sctx->
+                                                             serviceName,
+                                                             "DISABLEV6")))
+        return GNUNET_SYSERR;
+    }
+  else
+    disablev6 = GNUNET_NO;
+  if (GNUNET_CONFIGURATION_have_value (sctx->cfg,
+                                       sctx->serviceName, "ALLOW_SHUTDOWN"))
+    {
+      if (GNUNET_SYSERR ==
+          (sctx->allow_shutdown =
+           GNUNET_CONFIGURATION_get_value_yesno (sctx->cfg, sctx->serviceName,
+                                                 "ALLOW_SHUTDOWN")))
+        return GNUNET_SYSERR;
+    }
+  else
+    sctx->allow_shutdown = GNUNET_NO;
+
+  if (!disablev6)
+    {
+      /* probe IPv6 support */
+      ret = SOCKET (PF_INET6, SOCK_STREAM, 0);
+      if (ret == -1)
+        {
+          if ((errno == ENOBUFS) ||
+              (errno == ENOMEM) || (errno == ENFILE) || (errno == EACCES))
+            {
+              GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "socket");
+              return GNUNET_SYSERR;
+            }
+          ret = SOCKET (PF_INET, SOCK_STREAM, 0);
+          if (ret != -1)
+            {
+              GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                          _
+                          ("Disabling IPv6 support for service `%s', failed to create IPv6 socket: %s\n"),
+                          sctx->serviceName, strerror (errno));
+              disablev6 = GNUNET_YES;
+            }
+        }
+      if (ret != -1)
+        GNUNET_break (0 == CLOSE (ret));
+    }
+
+
+
+  if (GNUNET_CONFIGURATION_have_value (sctx->cfg,
+                                       sctx->serviceName, "TOLERANT"))
+    {
+      if (GNUNET_SYSERR ==
+          (tolerant = GNUNET_CONFIGURATION_get_value_yesno (sctx->cfg,
+                                                            sctx->serviceName,
+                                                            "TOLERANT")))
+        return GNUNET_SYSERR;
+    }
+  else
+    tolerant = GNUNET_NO;
+  sctx->require_found = tolerant ? GNUNET_NO : GNUNET_YES;
+
+
+  if ((GNUNET_OK !=
+       GNUNET_CONFIGURATION_get_value_number (sctx->cfg,
+                                              sctx->serviceName,
+                                              "PORT",
+                                              &port)) || (port > 65535))
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                  _
+                  ("Require valid port number for service `%s' in configuration!\n"),
+                  sctx->serviceName);
+      return GNUNET_SYSERR;
+    }
+  if (GNUNET_CONFIGURATION_have_value (sctx->cfg,
+                                       sctx->serviceName, "BINDTO"))
+    {
+      GNUNET_break (GNUNET_OK ==
+                    GNUNET_CONFIGURATION_get_value_string (sctx->cfg,
+                                                           sctx->serviceName,
+                                                           "BINDTO",
+                                                           &hostname));
+    }
+  else
+    hostname = NULL;
+
+  if (hostname != NULL)
+    {
+      memset (&hints, 0, sizeof (struct addrinfo));
+      if (disablev6)
+        hints.ai_family = AF_INET;
+      if ((0 != (ret = getaddrinfo (hostname,
+                                    NULL, &hints, &res))) || (res == NULL))
+        {
+          GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                      _("Failed to resolve `%s': %s\n"),
+                      hostname, gai_strerror (ret));
+          GNUNET_free (hostname);
+          return GNUNET_SYSERR;
+        }
+      pos = res;
+      while ((NULL != pos) &&
+             (((disablev6) &&
+               (pos->ai_family != AF_INET)) ||
+              ((pos->ai_family != AF_INET) && (pos->ai_family != AF_INET6))))
+        pos = pos->ai_next;
+      if (pos == NULL)
+        {
+          GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                      _("Failed to find IPv4 address for `%s'.\n"), hostname);
+          freeaddrinfo (res);
+          GNUNET_free (hostname);
+          return GNUNET_SYSERR;
+        }
+      GNUNET_free (hostname);
+      if (pos->ai_family == AF_INET)
+        {
+          GNUNET_assert (pos->ai_addrlen == sizeof (struct sockaddr_in));
+          sctx->addrlen = pos->ai_addrlen;
+          sctx->addr = GNUNET_malloc (sctx->addrlen);
+          memcpy (sctx->addr, res->ai_addr, sctx->addrlen);
+          ((struct sockaddr_in *) sctx->addr)->sin_port = htons (port);
+          GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                      _
+                      ("Configured to bind to %s address; %s connections to this service will fail!\n"),
+                      "IPv4", "IPv6");
+        }
+      else
+        {
+          GNUNET_assert (pos->ai_family == AF_INET6);
+          GNUNET_assert (pos->ai_addrlen == sizeof (struct sockaddr_in6));
+          sctx->addrlen = pos->ai_addrlen;
+          sctx->addr = GNUNET_malloc (sctx->addrlen);
+          GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                      _
+                      ("Configured to bind to %s address; %s connections to this service will fail!\n"),
+                      "IPv6", "IPv4");
+          ((struct sockaddr_in6 *) sctx->addr)->sin6_port = htons (port);
+        }
+      freeaddrinfo (res);
+    }
+  else
+    {
+      /* will bind against everything, just set port */
+      if (disablev6)
+        {
+          /* V4-only */
+          sctx->addrlen = sizeof (struct sockaddr_in6);
+          sctx->addr = GNUNET_malloc (sctx->addrlen);
+          ((struct sockaddr_in *) sctx->addr)->sin_family = AF_INET;
+          ((struct sockaddr_in *) sctx->addr)->sin_port = htons (port);
+          GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                      _
+                      ("Configured to bind to %s address; %s connections to this service will fail!\n"),
+                      "IPv4", "IPv6");
+        }
+      else
+        {
+          /* dual stack */
+          sctx->addrlen = sizeof (struct sockaddr_in6);
+          sctx->addr = GNUNET_malloc (sctx->addrlen);
+          ((struct sockaddr_in6 *) sctx->addr)->sin6_family = AF_INET6;
+          ((struct sockaddr_in6 *) sctx->addr)->sin6_port = htons (port);
+        }
+    }
+  sctx->maxbuf = (size_t) maxbuf;
+  if (sctx->maxbuf != maxbuf)
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                  _
+                  ("Value in configuration for `%s' and service `%s' too large!\n"),
+                  "MAXBUF", sctx->serviceName);
+      return GNUNET_SYSERR;
+    }
+
+
+  if ((GNUNET_OK !=
+       process_acl4 (&sctx->v4_denied,
+                     sctx,
+                     "REJECT_FROM")) ||
+      (GNUNET_OK !=
+       process_acl4 (&sctx->v4_allowed,
+                     sctx,
+                     "ACCEPT_FROM")) ||
+      (GNUNET_OK !=
+       process_acl6 (&sctx->v6_denied,
+                     sctx,
+                     "REJECT_FROM6")) ||
+      (GNUNET_OK != process_acl6 (&sctx->v6_allowed, sctx, "ACCEPT_FROM6")))
+    return GNUNET_SYSERR;
+  return GNUNET_OK;
+}
+
+
+/**
+ * Get the name of the user that'll be used
+ * to provide the service.
+ */
+static char *
+get_user_name (struct GNUNET_SERVICE_Context *sctx)
+{
+
+  char *un;
+
+  if (GNUNET_OK !=
+      GNUNET_CONFIGURATION_get_value_filename (sctx->cfg,
+                                               sctx->serviceName,
+                                               "USERNAME", &un))
+    return NULL;
+  return un;
+}
+
+/**
+ * Write PID file.
+ */
+static int
+write_pid_file (struct GNUNET_SERVICE_Context *sctx, pid_t pid)
+{
+  FILE *pidfd;
+  char *pif;
+  char *user;
+  char *rdir;
+  int len;
+
+  if (NULL == (pif = get_pid_file_name (sctx)))
+    return GNUNET_OK;           /* no file desired */
+  user = get_user_name (sctx);
+  rdir = GNUNET_strdup (pif);
+  len = strlen (rdir);
+  while ((len > 0) && (rdir[len] != DIR_SEPARATOR))
+    len--;
+  rdir[len] = '\0';
+  if (0 != ACCESS (rdir, F_OK))
+    {
+      /* we get to create a directory -- and claim it
+         as ours! */
+      GNUNET_DISK_directory_create (rdir);
+      if ((user != NULL) && (0 < strlen (user)))
+        GNUNET_DISK_file_change_owner (rdir, user);
+    }
+  if (0 != ACCESS (rdir, W_OK | X_OK))
+    {
+      GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_ERROR, "access", rdir);
+      GNUNET_free (rdir);
+      GNUNET_free_non_null (user);
+      GNUNET_free (pif);
+      return GNUNET_SYSERR;
+    }
+  GNUNET_free (rdir);
+  pidfd = FOPEN (pif, "w");
+  if (pidfd == NULL)
+    {
+      GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_ERROR, "fopen", pif);
+      GNUNET_free (pif);
+      GNUNET_free_non_null (user);
+      return GNUNET_SYSERR;
+    }
+  if (0 > FPRINTF (pidfd, "%u", pid))
+    GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING, "fprintf", pif);
+  GNUNET_break (0 == fclose (pidfd));
+  if ((user != NULL) && (0 < strlen (user)))
+    GNUNET_DISK_file_change_owner (pif, user);
+  GNUNET_free_non_null (user);
+  GNUNET_free (pif);
+  return GNUNET_OK;
+}
+
+
+/**
+ * Initial task for the service.
+ */
+static void
+service_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+{
+  struct GNUNET_SERVICE_Context *sctx = cls;
+  unsigned int i;
+
+  sctx->sched = tc->sched;
+  sctx->server = GNUNET_SERVER_create (tc->sched,
+                                       &check_access,
+                                       sctx,
+                                       sctx->addr,
+                                       sctx->addrlen,
+                                       sctx->maxbuf,
+                                       sctx->timeout, sctx->require_found);
+  if (sctx->server == NULL)
+    {
+      sctx->ret = GNUNET_SYSERR;
+      return;
+    }
+  sctx->my_handlers = GNUNET_malloc (sizeof (defhandlers));
+  memcpy (sctx->my_handlers, defhandlers, sizeof (defhandlers));
+  i = 0;
+  while ((sctx->my_handlers[i].callback != NULL))
+    sctx->my_handlers[i++].callback_cls = sctx;
+  GNUNET_SERVER_add_handlers (sctx->server, sctx->my_handlers);
+  if (sctx->ready_confirm_fd != -1)
+    {
+      GNUNET_break (1 == WRITE (sctx->ready_confirm_fd, ".", 1));
+      GNUNET_break (0 == CLOSE (sctx->ready_confirm_fd));
+      sctx->ready_confirm_fd = -1;
+      write_pid_file (sctx, getpid ());
+    }
+
+  sctx->task (sctx->task_cls, tc->sched, sctx->server, sctx->cfg);
+}
+
+
+/**
+ * Detach from terminal.
+ */
+static int
+detach_terminal (struct GNUNET_SERVICE_Context *sctx)
+{
+  pid_t pid;
+  int nullfd;
+  int filedes[2];
+
+#ifndef MINGW
+  if (0 != PIPE (filedes))
+    {
+      GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "pipe");
+      return GNUNET_SYSERR;
+    }
+  pid = fork ();
+  if (pid < 0)
+    {
+      GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "fork");
+      return GNUNET_SYSERR;
+    }
+  if (pid != 0)
+    {
+      /* Parent */
+      char c;
+
+      GNUNET_break (0 == CLOSE (filedes[1]));
+      c = 'X';
+      if (1 != READ (filedes[0], &c, sizeof (char)))
+        GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "read");
+      fflush (stdout);
+      switch (c)
+        {
+        case '.':
+          exit (0);
+        case 'I':
+          GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                      _("Service process failed to initialize\n"));
+          break;
+        case 'S':
+          GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                      _
+                      ("Service process could not initialize server function\n"));
+          break;
+        case 'X':
+          GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                      _("Service process failed to report status\n"));
+          break;
+        }
+      exit (1);                 /* child reported error */
+    }
+  GNUNET_break (0 == CLOSE (0));
+  GNUNET_break (0 == CLOSE (1));
+  GNUNET_break (0 == CLOSE (filedes[0]));
+  nullfd = GNUNET_DISK_file_open ("/dev/null", O_RDWR | O_APPEND);
+  if (nullfd < 0)
+    return GNUNET_SYSERR;
+  /* set stdin/stdout to /dev/null */
+  if ((dup2 (nullfd, 0) < 0) || (dup2 (nullfd, 1) < 0))
+    {
+      GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "dup2");
+      return GNUNET_SYSERR;
+    }
+  /* Detach from controlling terminal */
+  pid = setsid ();
+  if (pid == -1)
+    GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "setsid");
+  sctx->ready_confirm_fd = filedes[1];
+#else
+  /* FIXME: we probably need to do something else
+     elsewhere in order to fork the process itself... */
+  FreeConsole ();
+#endif
+  return GNUNET_OK;
+}
+
+
+/**
+ * Set user ID.
+ */
+static int
+set_user_id (struct GNUNET_SERVICE_Context *sctx)
+{
+  char *user;
+
+  if (NULL == (user = get_user_name (sctx)))
+    return GNUNET_OK;           /* keep */
+#ifndef MINGW
+  struct passwd *pws;
+
+  errno = 0;
+  pws = getpwnam (user);
+  if (pws == NULL)
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                  _("Cannot obtain information about user `%s': %s\n"),
+                  user, errno == 0 ? _("No such user") : STRERROR (errno));
+      GNUNET_free (user);
+      return GNUNET_SYSERR;
+    }
+  if ((0 != setgid (pws->pw_gid)) || (0 != setegid (pws->pw_gid)) ||
+#if HAVE_INITGROUPS
+      (0 != initgroups (user, pws->pw_gid)) ||
+#endif
+      (0 != setuid (pws->pw_uid)) || (0 != seteuid (pws->pw_uid)))
+    {
+      if ((0 != setregid (pws->pw_gid, pws->pw_gid)) ||
+          (0 != setreuid (pws->pw_uid, pws->pw_uid)))
+        {
+          GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                      _("Cannot change user/group to `%s': %s\n"), user,
+                      STRERROR (errno));
+          GNUNET_free (user);
+          return GNUNET_SYSERR;
+        }
+    }
+#endif
+  GNUNET_free (user);
+  return GNUNET_OK;
+}
+
+
+/**
+ * Delete the PID file that was created by our parent.
+ */
+static void
+pid_file_delete (struct GNUNET_SERVICE_Context *sctx)
+{
+  char *pif = get_pid_file_name (sctx);
+  if (pif == NULL)
+    return;                     /* no PID file */
+  if (0 != UNLINK (pif))
+    GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING, "unlink", pif);
+  GNUNET_free (pif);
+}
+
+/**
+ * Run a standard GNUnet service startup sequence (initialize loggers
+ * and configuration, parse options).
+ *
+ * @param argc number of command line arguments
+ * @param argv command line arguments
+ * @param serviceName our service name
+ * @param task main task of the service
+ * @param task_cls closure for task
+ * @param term termination task of the service
+ * @param term_cls closure for term
+ * @return GNUNET_SYSERR on error, GNUNET_OK
+ *         if we shutdown nicely
+ */
+int
+GNUNET_SERVICE_run (int argc,
+                    char *const *argv,
+                    const char *serviceName,
+                    GNUNET_SERVICE_Main task,
+                    void *task_cls, GNUNET_SERVICE_Term term, void *term_cls)
+{
+  char *cfg_fn;
+  char *loglev;
+  char *logfile;
+  int do_daemonize;
+  struct GNUNET_SERVICE_Context sctx;
+  struct GNUNET_GETOPT_CommandLineOption service_options[] = {
+    GNUNET_GETOPT_OPTION_CFG_FILE (&cfg_fn),
+    {'d', "daemonize", NULL,
+     gettext_noop ("do daemonize (detach from terminal)"), 0,
+     GNUNET_GETOPT_set_one, &do_daemonize},
+    GNUNET_GETOPT_OPTION_HELP (serviceName),
+    GNUNET_GETOPT_OPTION_LOGLEVEL (&loglev),
+    GNUNET_GETOPT_OPTION_LOGFILE (&logfile),
+    GNUNET_GETOPT_OPTION_VERSION (PACKAGE_VERSION),
+    GNUNET_GETOPT_OPTION_END
+  };
+  do_daemonize = 0;
+  logfile = NULL;
+  loglev = GNUNET_strdup ("WARNING");
+  cfg_fn = GNUNET_strdup (GNUNET_DEFAULT_DAEMON_CONFIG_FILE);
+  memset (&sctx, 0, sizeof (sctx));
+  sctx.ready_confirm_fd = -1;
+  sctx.ret = GNUNET_OK;
+  sctx.timeout = GNUNET_TIME_UNIT_FOREVER_REL;
+  sctx.maxbuf = GNUNET_SERVER_MAX_MESSAGE_SIZE;
+  sctx.task = task;
+  sctx.serviceName = serviceName;
+  sctx.cfg = GNUNET_CONFIGURATION_create ();
+  /* setup subsystems */
+  if ((GNUNET_SYSERR ==
+       GNUNET_GETOPT_run (serviceName,
+                          sctx.cfg,
+                          service_options,
+                          argc,
+                          argv)) ||
+      (GNUNET_OK !=
+       GNUNET_log_setup (serviceName, loglev, logfile)) ||
+      (GNUNET_OK !=
+       GNUNET_CONFIGURATION_load (sctx.cfg, cfg_fn)) ||
+      (GNUNET_OK !=
+       setup_service (&sctx)) ||
+      ((do_daemonize == 1) &&
+       (GNUNET_OK != detach_terminal (&sctx))) ||
+      (GNUNET_OK != set_user_id (&sctx)))
+    {
+      if (sctx.ready_confirm_fd != -1)
+        {
+          if (1 != WRITE (sctx.ready_confirm_fd, "I", 1))
+            GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "write");
+          GNUNET_break (0 == CLOSE (sctx.ready_confirm_fd));
+        }
+      GNUNET_CONFIGURATION_destroy (sctx.cfg);
+      GNUNET_free_non_null (sctx.addr);
+      GNUNET_free_non_null (logfile);
+      GNUNET_free (loglev);
+      GNUNET_free (cfg_fn);
+      GNUNET_free_non_null (sctx.v4_denied);
+      GNUNET_free_non_null (sctx.v6_denied);
+      GNUNET_free_non_null (sctx.v4_allowed);
+      GNUNET_free_non_null (sctx.v6_allowed);
+      return GNUNET_SYSERR;
+    }
+
+  /* actually run service */
+  GNUNET_SCHEDULER_run (&service_task, &sctx);
+  if (sctx.ready_confirm_fd != -1)
+    {
+      if (1 != WRITE (sctx.ready_confirm_fd, "S", 1))
+        GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "write");
+      GNUNET_break (0 == CLOSE (sctx.ready_confirm_fd));
+    }
+
+  /* shutdown */
+  if (term != NULL)
+    term (term_cls, sctx.cfg);
+  if ((do_daemonize == 1) && (sctx.server != NULL))
+    pid_file_delete (&sctx);
+  if (sctx.server != NULL)
+    GNUNET_SERVER_destroy (sctx.server);
+  GNUNET_free_non_null (sctx.my_handlers);
+  GNUNET_CONFIGURATION_destroy (sctx.cfg);
+  GNUNET_free_non_null (sctx.addr);
+  GNUNET_free_non_null (logfile);
+  GNUNET_free (loglev);
+  GNUNET_free (cfg_fn);
+  GNUNET_free_non_null (sctx.v4_denied);
+  GNUNET_free_non_null (sctx.v6_denied);
+  GNUNET_free_non_null (sctx.v4_allowed);
+  GNUNET_free_non_null (sctx.v6_allowed);
+  return sctx.ret;
+}
+
+
+/**
+ * Run a service startup sequence within an existing
+ * initialized system.
+ *
+ * @param serviceName our service name
+ * @param sched scheduler to use
+ * @param cfg configuration to use
+ * @return NULL on error, service handle
+ */
+struct GNUNET_SERVICE_Context *
+GNUNET_SERVICE_start (const char *serviceName,
+                      struct GNUNET_SCHEDULER_Handle *sched,
+                      struct GNUNET_CONFIGURATION_Handle *cfg)
+{
+  int i;
+  struct GNUNET_SERVICE_Context *sctx;
+
+  sctx = GNUNET_malloc (sizeof (struct GNUNET_SERVICE_Context));
+  sctx->ready_confirm_fd = -1;  /* no daemonizing */
+  sctx->ret = GNUNET_OK;
+  sctx->timeout = GNUNET_TIME_UNIT_FOREVER_REL;
+  sctx->maxbuf = GNUNET_SERVER_MAX_MESSAGE_SIZE;
+  sctx->serviceName = serviceName;
+  sctx->cfg = cfg;
+  sctx->sched = sched;
+
+  /* setup subsystems */
+  if ((GNUNET_OK != setup_service (sctx)) ||
+      (NULL == (sctx->server = GNUNET_SERVER_create (sched,
+                                                     &check_access,
+                                                     sctx,
+                                                     sctx->addr,
+                                                     sctx->addrlen,
+                                                     sctx->maxbuf,
+                                                     sctx->timeout,
+                                                     sctx->require_found))))
+    {
+      GNUNET_SERVICE_stop (sctx);
+      return NULL;
+    }
+  sctx->my_handlers = GNUNET_malloc (sizeof (defhandlers));
+  memcpy (sctx->my_handlers, defhandlers, sizeof (defhandlers));
+  i = 0;
+  while ((sctx->my_handlers[i].callback != NULL))
+    sctx->my_handlers[i++].callback_cls = sctx;
+  GNUNET_SERVER_add_handlers (sctx->server, sctx->my_handlers);
+
+
+  return sctx;
+}
+
+/**
+ * Obtain the server used by a service.  Note that the server must NOT
+ * be destroyed by the caller.
+ *
+ * @param ctx the service context returned from the start function
+ * @return handle to the server for this service, NULL if there is none
+ */
+struct GNUNET_SERVER_Handle *
+GNUNET_SERVICE_get_server (struct GNUNET_SERVICE_Context *ctx)
+{
+  return ctx->server;
+}
+
+
+/**
+ * Stop a service that was started with "GNUNET_SERVICE_start".
+ *
+ * @param ctx the service context returned from the start function
+ */
+void
+GNUNET_SERVICE_stop (struct GNUNET_SERVICE_Context *sctx)
+{
+  if (NULL != sctx->server)
+    GNUNET_SERVER_destroy (sctx->server);
+  GNUNET_free_non_null (sctx->my_handlers);
+  GNUNET_free_non_null (sctx->addr);
+  GNUNET_free_non_null (sctx->v4_denied);
+  GNUNET_free_non_null (sctx->v6_denied);
+  GNUNET_free_non_null (sctx->v4_allowed);
+  GNUNET_free_non_null (sctx->v6_allowed);
+  GNUNET_free (sctx);
+}
+
+
+/* end of service.c */
diff --git a/src/util/signal.c b/src/util/signal.c
new file mode 100644
index 000000000..478551ca2
--- /dev/null
+++ b/src/util/signal.c
@@ -0,0 +1,76 @@
+/*
+     This file is part of GNUnet.
+     (C) 2001, 2002, 2006 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 util/signal.c
+ * @brief code for installing and uninstalling signal handlers
+ * @author Christian Grothoff
+ */
+
+#include "platform.h"
+#include "gnunet_common.h"
+#include "gnunet_signal_lib.h"
+
+struct GNUNET_SIGNAL_Context
+{
+  int sig;
+
+  GNUNET_SIGNAL_Handler method;
+
+#ifndef MINGW
+  struct sigaction oldsig;
+#endif
+};
+
+struct GNUNET_SIGNAL_Context *
+GNUNET_SIGNAL_handler_install (int signal, GNUNET_SIGNAL_Handler handler)
+{
+  struct GNUNET_SIGNAL_Context *ret;
+#ifndef MINGW
+  struct sigaction sig;
+#endif
+
+  ret = GNUNET_malloc (sizeof (struct GNUNET_SIGNAL_Context));
+  ret->sig = signal;
+  ret->method = handler;
+#ifndef MINGW
+  sig.sa_handler = (void *) handler;
+  sigemptyset (&sig.sa_mask);
+#ifdef SA_INTERRUPT
+  sig.sa_flags = SA_INTERRUPT;  /* SunOS */
+#else
+  sig.sa_flags = SA_RESTART;
+#endif
+  sigaction (signal, &sig, &ret->oldsig);
+#endif
+  return ret;
+}
+
+void
+GNUNET_SIGNAL_handler_uninstall (struct GNUNET_SIGNAL_Context *ctx)
+{
+#ifndef MINGW
+  struct sigaction sig;
+
+  sigemptyset (&sig.sa_mask);
+  sigaction (ctx->sig, &ctx->oldsig, &sig);
+#endif
+  GNUNET_free (ctx);
+}
diff --git a/src/util/strings.c b/src/util/strings.c
new file mode 100644
index 000000000..18f6582e8
--- /dev/null
+++ b/src/util/strings.c
@@ -0,0 +1,396 @@
+/*
+     This file is part of GNUnet.
+     (C) 2005, 2006 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 util/strings.c
+ * @brief string functions
+ * @author Nils Durner
+ * @author Christian Grothoff
+ */
+
+#include "platform.h"
+#if HAVE_ICONV_H
+#include <iconv.h>
+#endif
+#include "gnunet_common.h"
+#include "gnunet_strings_lib.h"
+
+
+/**
+ * Fill a buffer of the given size with
+ * count 0-terminated strings (given as varargs).
+ * If "buffer" is NULL, only compute the amount of
+ * space required (sum of "strlen(arg)+1").
+ *
+ * Unlike using "snprintf" with "%s", this function
+ * will add 0-terminators after each string.  The
+ * "GNUNET_string_buffer_tokenize" function can be
+ * used to parse the buffer back into individual
+ * strings.
+ *
+ * @return number of bytes written to the buffer
+ *         (or number of bytes that would have been written)
+ */
+unsigned int
+GNUNET_STRINGS_buffer_fill (char *buffer,
+                            unsigned int size, unsigned int count, ...)
+{
+  unsigned int needed;
+  unsigned int slen;
+  const char *s;
+  va_list ap;
+
+  needed = 0;
+  va_start (ap, count);
+  while (count > 0)
+    {
+      s = va_arg (ap, const char *);
+      slen = strlen (s) + 1;
+      if (buffer != NULL)
+        {
+          GNUNET_assert (needed + slen <= size);
+          memcpy (&buffer[needed], s, slen);
+        }
+      needed += slen;
+      count--;
+    }
+  va_end (ap);
+  return needed;
+}
+
+
+/**
+ * Given a buffer of a given size, find "count"
+ * 0-terminated strings in the buffer and assign
+ * the count (varargs) of type "const char**" to the
+ * locations of the respective strings in the
+ * buffer.
+ *
+ * @param buffer the buffer to parse
+ * @param size size of the buffer
+ * @param count number of strings to locate
+ * @return offset of the character after the last 0-termination
+ *         in the buffer, or 0 on error.
+ */
+unsigned int
+GNUNET_STRINGS_buffer_tokenize (const char *buffer,
+                                unsigned int size, unsigned int count, ...)
+{
+  unsigned int start;
+  unsigned int needed;
+  const char **r;
+  va_list ap;
+
+  needed = 0;
+  va_start (ap, count);
+  while (count > 0)
+    {
+      r = va_arg (ap, const char **);
+      start = needed;
+      while ((needed < size) && (buffer[needed] != '\0'))
+        needed++;
+      if (needed == size)
+        {
+          va_end (ap);
+          return 0;             /* error */
+        }
+      *r = &buffer[start];
+      needed++;                 /* skip 0-termination */
+      count--;
+    }
+  va_end (ap);
+  return needed;
+}
+
+
+/**
+ * Convert a given filesize into a fancy human-readable format.
+ */
+char *
+GNUNET_STRINGS_byte_size_fancy (unsigned long long size)
+{
+  const char *unit = _( /* size unit */ "b");
+  char *ret;
+
+  if (size > 5 * 1024)
+    {
+      size = size / 1024;
+      unit = _( /* size unit */ "KiB");
+      if (size > 5 * 1024)
+        {
+          size = size / 1024;
+          unit = _( /* size unit */ "MiB");
+          if (size > 5 * 1024)
+            {
+              size = size / 1024;
+              unit = _( /* size unit */ "GiB");
+              if (size > 5 * 1024)
+                {
+                  size = size / 1024;
+                  unit = _( /* size unit */ "TiB");
+                }
+            }
+        }
+    }
+  ret = GNUNET_malloc (32);
+  GNUNET_snprintf (ret, 32, "%llu%s", size, unit);
+  return ret;
+}
+
+
+/**
+ * Convert the len characters long character sequence
+ * given in input that is in the given charset
+ * to UTF-8.
+ * @return the converted string (0-terminated),
+ *  if conversion fails, a copy of the orignal
+ *  string is returned.
+ */
+char *
+GNUNET_STRINGS_to_utf8 (const char *input, size_t len, const char *charset)
+{
+  char *ret;
+#if ENABLE_NLS && HAVE_ICONV
+  size_t tmpSize;
+  size_t finSize;
+  char *tmp;
+  char *itmp;
+  iconv_t cd;
+
+  cd = iconv_open ("UTF-8", charset);
+  if (cd == (iconv_t) - 1)
+    {
+      GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "iconv_open");
+      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                  _("Character set requested was `%s'\n"), charset);
+      ret = GNUNET_malloc (len + 1);
+      memcpy (ret, input, len);
+      ret[len] = '\0';
+      return ret;
+    }
+  tmpSize = 3 * len + 4;
+  tmp = GNUNET_malloc (tmpSize);
+  itmp = tmp;
+  finSize = tmpSize;
+  if (iconv (cd, (char **) &input, &len, &itmp, &finSize) == (size_t) - 1)
+    {
+      GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "iconv");
+      iconv_close (cd);
+      GNUNET_free (tmp);
+      ret = GNUNET_malloc (len + 1);
+      memcpy (ret, input, len);
+      ret[len] = '\0';
+      return ret;
+    }
+  ret = GNUNET_malloc (tmpSize - finSize + 1);
+  memcpy (ret, tmp, tmpSize - finSize);
+  ret[tmpSize - finSize] = '\0';
+  GNUNET_free (tmp);
+  if (0 != iconv_close (cd))
+    GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "iconv_close");
+  return ret;
+#else
+  ret = GNUNET_malloc (len + 1);
+  memcpy (ret, input, len);
+  ret[len] = '\0';
+  return ret;
+#endif
+}
+
+
+/**
+ * Complete filename (a la shell) from abbrevition.
+ * @param fil the name of the file, may contain ~/ or
+ *        be relative to the current directory
+ * @returns the full file name,
+ *          NULL is returned on error
+ */
+char *
+GNUNET_STRINGS_filename_expand (const char *fil)
+{
+  char *buffer;
+#ifndef MINGW
+  size_t len;
+  size_t n;
+  char *fm;
+  const char *fil_ptr;
+#else
+  char *fn;
+  long lRet;
+#endif
+
+  if (fil == NULL)
+    return NULL;
+
+#ifndef MINGW
+  if (fil[0] == DIR_SEPARATOR)
+    /* absolute path, just copy */
+    return GNUNET_strdup (fil);
+  if (fil[0] == '~')
+    {
+      fm = getenv ("HOME");
+      if (fm == NULL)
+        {
+          GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                      _
+                      ("Failed to expand `$HOME': environment variable `HOME' not set"));
+          return NULL;
+        }
+      fm = GNUNET_strdup (fm);
+      /* do not copy '~' */
+      fil_ptr = fil + 1;
+
+      /* skip over dir seperator to be consistent */
+      if (fil_ptr[0] == DIR_SEPARATOR)
+        fil_ptr++;
+    }
+  else
+    {
+      /* relative path */
+      fil_ptr = fil;
+      len = 512;
+      fm = NULL;
+      while (1)
+        {
+          buffer = GNUNET_malloc (len);
+          if (getcwd (buffer, len) != NULL)
+            {
+              fm = buffer;
+              break;
+            }
+          if ((errno == ERANGE) && (len < 1024 * 1024 * 4))
+            {
+              len *= 2;
+              GNUNET_free (buffer);
+              continue;
+            }
+          GNUNET_free (buffer);
+          break;
+        }
+      if (fm == NULL)
+        {
+          GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "getcwd");
+          buffer = getenv ("PWD");      /* alternative */
+          if (buffer != NULL)
+            fm = GNUNET_strdup (buffer);
+        }
+      if (fm == NULL)
+        fm = GNUNET_strdup ("./");      /* give up */
+    }
+  n = strlen (fm) + 1 + strlen (fil_ptr) + 1;
+  buffer = GNUNET_malloc (n);
+  GNUNET_snprintf (buffer, n, "%s%s%s",
+                   fm,
+                   (fm[strlen (fm) - 1] ==
+                    DIR_SEPARATOR) ? "" : DIR_SEPARATOR_STR, fil_ptr);
+  GNUNET_free (fm);
+  return buffer;
+#else
+  fn = GNUNET_malloc (MAX_PATH + 1);
+
+  if ((lRet = plibc_conv_to_win_path (fil, fn)) != ERROR_SUCCESS)
+    {
+      SetErrnoFromWinError (lRet);
+      GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING,
+                           "plibc_conv_to_win_path");
+      return NULL;
+    }
+  /* is the path relative? */
+  if ((strncmp (fn + 1, ":\\", 2) != 0) && (strncmp (fn, "\\\\", 2) != 0))
+    {
+      char szCurDir[MAX_PATH + 1];
+      lRet = GetCurrentDirectory (MAX_PATH + 1, szCurDir);
+      if (lRet + strlen (fn) + 1 > (MAX_PATH + 1))
+        {
+          SetErrnoFromWinError (ERROR_BUFFER_OVERFLOW);
+          GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING,
+                               "GetCurrentDirectory");
+          return NULL;
+        }
+      buffer = GNUNET_malloc (MAX_PATH + 1);
+      GNUNET_snprintf (buffer, MAX_PATH + 1, "%s\\%s", szCurDir, fn);
+      GNUNET_free (fn);
+      fn = buffer;
+    }
+
+  return fn;
+#endif
+}
+
+
+/**
+ * Give relative time in human-readable fancy format.
+ * @param delta time in milli seconds
+ */
+char *
+GNUNET_STRINGS_relative_time_to_string (struct GNUNET_TIME_Relative del)
+{
+  const char *unit = _( /* time unit */ "ms");
+  char *ret;
+  uint64_t delta = del.value;
+
+  if (delta > 5 * 1000)
+    {
+      delta = delta / 1000;
+      unit = _( /* time unit */ "s");
+      if (delta > 5 * 60)
+        {
+          delta = delta / 60;
+          unit = _( /* time unit */ "m");
+          if (delta > 5 * 60)
+            {
+              delta = delta / 60;
+              unit = _( /* time unit */ "h");
+              if (delta > 5 * 24)
+                {
+                  delta = delta / 24;
+                  unit = _( /* time unit */ " days");
+                }
+            }
+        }
+    }
+  GNUNET_asprintf (&ret, "%llu%s", delta, unit);
+  return ret;
+}
+
+
+/**
+ * "man ctime_r", except for GNUnet time; also, unlike ctime, the
+ * return value does not include the newline character.
+ */
+char *
+GNUNET_STRINGS_absolute_time_to_string (struct GNUNET_TIME_Absolute t)
+{
+  time_t tt;
+  char *ret;
+
+  tt = t.value / 1000;
+#ifdef ctime_r
+  ret = ctime_r (&tt, GNUNET_malloc (32));
+#else
+  ret = GNUNET_strdup (ctime (&tt));
+#endif
+  ret[strlen (ret) - 1] = '\0';
+  return ret;
+}
+
+
+
+/* end of strings.c */
diff --git a/src/util/test_client.c b/src/util/test_client.c
new file mode 100644
index 000000000..5c2e552e9
--- /dev/null
+++ b/src/util/test_client.c
@@ -0,0 +1,195 @@
+/*
+     This file is part of GNUnet.
+     (C) 2009 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 util/test_client.c
+ * @brief tests for client.c
+ */
+#include "platform.h"
+#include "gnunet_common.h"
+#include "gnunet_client_lib.h"
+#include "gnunet_configuration_lib.h"
+#include "gnunet_scheduler_lib.h"
+#include "gnunet_server_lib.h"
+#include "gnunet_time_lib.h"
+
+#define VERBOSE GNUNET_NO
+
+#define PORT 14325
+
+#define MYNAME "test_client"
+
+static struct GNUNET_CLIENT_Connection *client;
+
+static struct GNUNET_SERVER_Handle *server;
+
+static struct GNUNET_CONFIGURATION_Handle *cfg;
+
+#define MY_TYPE 130
+
+struct CopyContext
+{
+  struct GNUNET_SERVER_Client *client;
+  struct GNUNET_MessageHeader *cpy;
+};
+
+static size_t
+copy_msg (void *cls, size_t size, void *buf)
+{
+  struct CopyContext *ctx = cls;
+  struct GNUNET_MessageHeader *cpy = ctx->cpy;
+
+  GNUNET_assert (sizeof (struct GNUNET_MessageHeader) == ntohs (cpy->size));
+  GNUNET_assert (size >= ntohs (cpy->size));
+  memcpy (buf, cpy, ntohs (cpy->size));
+  GNUNET_SERVER_receive_done (ctx->client, GNUNET_OK);
+  GNUNET_free (cpy);
+  GNUNET_free (ctx);
+  return sizeof (struct GNUNET_MessageHeader);
+}
+
+
+/**
+ * Callback that just bounces the message back to the sender.
+ */
+static void
+echo_cb (void *cls,
+         struct GNUNET_SERVER_Handle *server,
+         struct GNUNET_SERVER_Client *client,
+         const struct GNUNET_MessageHeader *message)
+{
+  struct CopyContext *cc;
+  struct GNUNET_MessageHeader *cpy;
+
+  GNUNET_assert (sizeof (struct GNUNET_MessageHeader) ==
+                 ntohs (message->size));
+  cc = GNUNET_malloc (sizeof (struct CopyContext));
+  cc->client = client;
+  cpy = GNUNET_malloc (ntohs (message->size));
+  memcpy (cpy, message, ntohs (message->size));
+  cc->cpy = cpy;
+  GNUNET_assert (NULL !=
+                 GNUNET_SERVER_notify_transmit_ready (client,
+                                                      ntohs (message->size),
+                                                      GNUNET_TIME_UNIT_SECONDS,
+                                                      &copy_msg, cc));
+}
+
+
+static struct GNUNET_SERVER_MessageHandler handlers[] = {
+  {&echo_cb, NULL, MY_TYPE, sizeof (struct GNUNET_MessageHeader)},
+  {NULL, NULL, 0, 0}
+};
+
+
+static void
+recv_bounce (void *cls, const struct GNUNET_MessageHeader *got)
+{
+  int *ok = cls;
+  struct GNUNET_MessageHeader msg;
+
+  GNUNET_assert (got != NULL);  /* timeout */
+  msg.type = htons (MY_TYPE);
+  msg.size = htons (sizeof (msg));
+  GNUNET_assert (0 == memcmp (got, &msg, sizeof (msg)));
+  GNUNET_CLIENT_disconnect (client);
+  client = NULL;
+  GNUNET_SERVER_destroy (server);
+  server = NULL;
+  *ok = 0;
+}
+
+
+static size_t
+make_msg (void *cls, size_t size, void *buf)
+{
+  struct GNUNET_MessageHeader *msg = buf;
+  GNUNET_assert (size >= sizeof (struct GNUNET_MessageHeader));
+  msg->type = htons (MY_TYPE);
+  msg->size = htons (sizeof (msg));
+  return sizeof (struct GNUNET_MessageHeader);
+}
+
+
+static void
+task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+{
+  struct sockaddr_in sa;
+
+  memset (&sa, 0, sizeof (sa));
+  sa.sin_family = AF_INET;
+  sa.sin_port = htons (PORT);
+  server = GNUNET_SERVER_create (tc->sched,
+                                 NULL,
+                                 NULL,
+                                 (const struct sockaddr *) &sa,
+                                 sizeof (sa),
+                                 1024,
+                                 GNUNET_TIME_relative_multiply
+                                 (GNUNET_TIME_UNIT_MILLISECONDS, 250),
+                                 GNUNET_NO);
+  GNUNET_assert (server != NULL);
+  handlers[0].callback_cls = cls;
+  handlers[1].callback_cls = cls;
+  GNUNET_SERVER_add_handlers (server, handlers);
+  client = GNUNET_CLIENT_connect (tc->sched, MYNAME, cfg);
+  GNUNET_assert (client != NULL);
+  GNUNET_assert (NULL !=
+                 GNUNET_CLIENT_notify_transmit_ready (client,
+                                                      sizeof (struct
+                                                              GNUNET_MessageHeader),
+                                                      GNUNET_TIME_UNIT_SECONDS,
+                                                      &make_msg, NULL));
+  GNUNET_CLIENT_receive (client, &recv_bounce, cls,
+                         GNUNET_TIME_relative_multiply
+                         (GNUNET_TIME_UNIT_MILLISECONDS, 250));
+}
+
+
+/**
+ * Main method, starts scheduler with task1,
+ * checks that "ok" is correct at the end.
+ */
+static int
+check ()
+{
+  int ok;
+
+  cfg = GNUNET_CONFIGURATION_create ();
+  GNUNET_CONFIGURATION_set_value_number (cfg, MYNAME, "PORT", PORT);
+  GNUNET_CONFIGURATION_set_value_string (cfg,
+                                         MYNAME, "HOSTNAME", "localhost");
+  ok = 1;
+  GNUNET_SCHEDULER_run (&task, &ok);
+  GNUNET_CONFIGURATION_destroy (cfg);
+  return ok;
+}
+
+int
+main (int argc, char *argv[])
+{
+  int ret = 0;
+
+  GNUNET_log_setup ("test_client", "WARNING", NULL);
+  ret += check ();
+
+  return ret;
+}
+
+/* end of test_client.c */
diff --git a/src/util/test_common_allocation.c b/src/util/test_common_allocation.c
new file mode 100644
index 000000000..76c7dc8a3
--- /dev/null
+++ b/src/util/test_common_allocation.c
@@ -0,0 +1,112 @@
+/*
+     This file is part of GNUnet.
+     (C) 2001, 2002, 2003, 2005, 2006 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 util/test_common_allocation.c
+ * @brief testcase for common_allocation.c
+ */
+#include "platform.h"
+#include "gnunet_common.h"
+
+static int
+check ()
+{
+#define MAX_TESTVAL 1024
+  char *ptrs[MAX_TESTVAL];
+  int i;
+  int j;
+  int k;
+  unsigned int ui;
+
+  /* GNUNET_malloc/GNUNET_free test */
+  k = 352;                      /* random start value */
+  for (i = 1; i < MAX_TESTVAL; i++)
+    {
+      ptrs[i] = GNUNET_malloc (i);
+      for (j = 0; j < i; j++)
+        ptrs[i][j] = k++;
+    }
+
+  for (i = MAX_TESTVAL - 1; i >= 1; i--)
+    {
+      for (j = i - 1; j >= 0; j--)
+        if (ptrs[i][j] != (char) --k)
+          return 1;
+      GNUNET_free (ptrs[i]);
+    }
+
+  /* GNUNET_free_non_null test */
+  GNUNET_free_non_null (NULL);
+  GNUNET_free_non_null (GNUNET_malloc (4));
+
+  /* GNUNET_strdup tests */
+  ptrs[0] = GNUNET_strdup ("bar");
+  if (0 != strcmp (ptrs[0], "bar"))
+    return 3;
+  /* now realloc */
+  ptrs[0] = GNUNET_realloc (ptrs[0], 12);
+  strcpy (ptrs[0], "Hello World");
+
+  GNUNET_free (ptrs[0]);
+  GNUNET_asprintf (&ptrs[0], "%s %s", "Hello", "World");
+  GNUNET_assert (strlen (ptrs[0]) == 11);
+  GNUNET_free (ptrs[0]);
+
+  /* GNUNET_array_grow tests */
+  ptrs[0] = NULL;
+  ui = 0;
+  GNUNET_array_grow (ptrs[0], ui, 42);
+  if (ui != 42)
+    return 4;
+  GNUNET_array_grow (ptrs[0], ui, 22);
+  if (ui != 22)
+    return 5;
+  for (j = 0; j < 22; j++)
+    ptrs[0][j] = j;
+  GNUNET_array_grow (ptrs[0], ui, 32);
+  for (j = 0; j < 22; j++)
+    if (ptrs[0][j] != j)
+      return 6;
+  for (j = 22; j < 32; j++)
+    if (ptrs[0][j] != 0)
+      return 7;
+  GNUNET_array_grow (ptrs[0], ui, 0);
+  if (i != 0)
+    return 8;
+  if (ptrs[0] != NULL)
+    return 9;
+
+
+  return 0;
+}
+
+int
+main (int argc, char *argv[])
+{
+  int ret;
+
+  GNUNET_log_setup ("test-common-allocation", "WARNING", NULL);
+  ret = check ();
+  if (ret != 0)
+    fprintf (stderr, "ERROR %d.\n", ret);
+  return ret;
+}
+
+/* end of test_common_allocation.c */
diff --git a/src/util/test_common_endian.c b/src/util/test_common_endian.c
new file mode 100644
index 000000000..43f163902
--- /dev/null
+++ b/src/util/test_common_endian.c
@@ -0,0 +1,42 @@
+/*
+     This file is part of GNUnet.
+     (C) 2009 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 util/test_common_endian.c
+ * @brief testcase for common_endian.c
+ */
+#include "platform.h"
+#include "gnunet_common.h"
+
+#define CHECK(n) if (n != GNUNET_htonll(GNUNET_ntohll(n))) return 1;
+
+int
+main (int argc, char *argv[])
+{
+  GNUNET_log_setup ("test-common-endian", "WARNING", NULL);
+  CHECK (1);
+  CHECK (0x12345678);
+  CHECK (123456789012345LL);
+  if ((0x1234567890ABCDEFLL !=
+       GNUNET_htonll (0xEFCDAB9078563412LL)) && 42 != htonl (42))
+    return 1;
+  return 0;
+}
+
+/* end of test_common_endian.c */
diff --git a/src/util/test_common_logging.c b/src/util/test_common_logging.c
new file mode 100644
index 000000000..eb337aac4
--- /dev/null
+++ b/src/util/test_common_logging.c
@@ -0,0 +1,100 @@
+/*
+     This file is part of GNUnet.
+     (C) 2008 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 util/test_common_logging.c
+ * @brief testcase for the logging module
+ * @author Christian Grothoff
+ */
+#include "platform.h"
+#include "gnunet_common.h"
+
+static void
+my_log (void *ctx, enum GNUNET_ErrorType kind,
+        const char *component, const char *date, const char *msg)
+{
+  unsigned int *c = ctx;
+  (*c)++;
+}
+
+
+
+int
+main (int argc, char *argv[])
+{
+  unsigned int failureCount = 0;
+  unsigned int logs = 0;
+
+  fclose (stderr);
+  stderr = NULL;
+  GNUNET_logger_add (&my_log, &logs);
+  GNUNET_logger_add (&my_log, &logs);
+  GNUNET_log (GNUNET_ERROR_TYPE_BULK, "Testing...\n");
+  GNUNET_log (GNUNET_ERROR_TYPE_BULK, "Testing...\n");
+  GNUNET_log (GNUNET_ERROR_TYPE_BULK, "Testing...\n");
+  GNUNET_log (GNUNET_ERROR_TYPE_BULK, "Testing...\n");
+  GNUNET_log (GNUNET_ERROR_TYPE_BULK, "Testing...\n");
+  GNUNET_log (GNUNET_ERROR_TYPE_BULK, "Testing...\n");
+  GNUNET_logger_remove (&my_log, &logs);
+  GNUNET_log (GNUNET_ERROR_TYPE_BULK, "Flusher...\n");
+  /* the last 6 calls should be merged (repated bulk messages!) */
+  GNUNET_logger_remove (&my_log, &logs);
+  if (logs != 4)
+    {
+      fprintf (stdout, "Expected 4 log calls, got %u\n", logs);
+      failureCount++;
+    }
+  GNUNET_break (0 ==
+                strcmp (_("ERROR"),
+                        GNUNET_error_type_to_string
+                        (GNUNET_ERROR_TYPE_ERROR)));
+  GNUNET_break (0 ==
+                strcmp (_("WARNING"),
+                        GNUNET_error_type_to_string
+                        (GNUNET_ERROR_TYPE_WARNING)));
+  GNUNET_break (0 ==
+                strcmp (_("INFO"),
+                        GNUNET_error_type_to_string
+                        (GNUNET_ERROR_TYPE_INFO)));
+  GNUNET_break (0 ==
+                strcmp (_("DEBUG"),
+                        GNUNET_error_type_to_string
+                        (GNUNET_ERROR_TYPE_DEBUG)));
+  GNUNET_log_setup ("test_common_logging", "WARNING", "/dev/null");
+  logs = 0;
+  GNUNET_logger_add (&my_log, &logs);
+  GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Checker...\n");
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Drop me...\n");
+  GNUNET_logger_remove (&my_log, &logs);
+  if (logs != 1)
+    {
+      fprintf (stdout, "Expected 1 log call, got %u\n", logs);
+      failureCount++;
+    }
+
+  if (failureCount != 0)
+    {
+      fprintf (stdout, "%u TESTS FAILED!\n", failureCount);
+      return -1;
+    }
+  return 0;
+}                               /* end of main */
+
+/* end of test_common_logging.c */
diff --git a/src/util/test_configuration.c b/src/util/test_configuration.c
new file mode 100644
index 000000000..2f37c684c
--- /dev/null
+++ b/src/util/test_configuration.c
@@ -0,0 +1,229 @@
+/*
+     This file is part of GNUnet.
+     (C) 2003, 2004, 2005, 2006, 2007 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 util/test_configuration.c
+ * @brief Test that the configuration module works.
+ * @author Christian Grothoff
+ */
+
+#include "platform.h"
+#include "gnunet_common.h"
+#include "gnunet_configuration_lib.h"
+
+static struct GNUNET_CONFIGURATION_Handle *cfg;
+
+static int
+testConfig ()
+{
+  char *c;
+  unsigned long long l;
+
+  if (GNUNET_OK !=
+      GNUNET_CONFIGURATION_get_value_string (cfg, "test", "b", &c))
+    return 1;
+  if (0 != strcmp ("b", c))
+    {
+      fprintf (stderr, "Got `%s'\n", c);
+      GNUNET_free (c);
+      return 2;
+    }
+  GNUNET_free (c);
+  if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_number (cfg,
+                                                          "test", "five", &l))
+    return 3;
+  if (5 != l)
+    return 4;
+  GNUNET_CONFIGURATION_set_value_string (cfg, "more", "c", "YES");
+  if (GNUNET_NO == GNUNET_CONFIGURATION_get_value_yesno (cfg, "more", "c"))
+    return 5;
+  GNUNET_CONFIGURATION_set_value_number (cfg, "NUMBERS", "TEN", 10);
+  if (GNUNET_OK !=
+      GNUNET_CONFIGURATION_get_value_string (cfg, "NUMBERS", "TEN", &c))
+    return 6;
+  if (0 != strcmp (c, "10"))
+    {
+      GNUNET_free (c);
+      return 7;
+    }
+  GNUNET_free (c);
+
+  if (GNUNET_OK !=
+      GNUNET_CONFIGURATION_get_value_filename (cfg, "last", "test", &c))
+    return 8;
+  if (0 != strcmp (c, "/hello/world"))
+    {
+      GNUNET_free (c);
+      return 9;
+    }
+  GNUNET_free (c);
+
+  return 0;
+}
+
+static const char *want[] = {
+  "/Hello",
+  "/File Name",
+  "/World",
+  NULL,
+  NULL,
+};
+
+static int
+check (void *data, const char *fn)
+{
+  int *idx = data;
+
+  if (0 == strcmp (want[*idx], fn))
+    {
+      (*idx)++;
+      return GNUNET_OK;
+    }
+  return GNUNET_SYSERR;
+}
+
+static int
+testConfigFilenames ()
+{
+  int idx;
+
+  idx = 0;
+  if (3 != GNUNET_CONFIGURATION_iterate_value_filenames (cfg,
+                                                         "FILENAMES",
+                                                         "test",
+                                                         &check, &idx))
+    return 8;
+  if (idx != 3)
+    return 16;
+  if (GNUNET_OK !=
+      GNUNET_CONFIGURATION_remove_value_filename (cfg,
+                                                  "FILENAMES",
+                                                  "test", "/File Name"))
+    return 24;
+
+  if (GNUNET_NO !=
+      GNUNET_CONFIGURATION_remove_value_filename (cfg,
+                                                  "FILENAMES",
+                                                  "test", "/File Name"))
+    return 32;
+  if (GNUNET_NO !=
+      GNUNET_CONFIGURATION_remove_value_filename (cfg,
+                                                  "FILENAMES",
+                                                  "test", "Stuff"))
+    return 40;
+
+  if (GNUNET_NO !=
+      GNUNET_CONFIGURATION_append_value_filename (cfg,
+                                                  "FILENAMES",
+                                                  "test", "/Hello"))
+    return 48;
+  if (GNUNET_NO !=
+      GNUNET_CONFIGURATION_append_value_filename (cfg,
+                                                  "FILENAMES",
+                                                  "test", "/World"))
+    return 56;
+
+  if (GNUNET_YES !=
+      GNUNET_CONFIGURATION_append_value_filename (cfg,
+                                                  "FILENAMES",
+                                                  "test", "/File 1"))
+    return 64;
+
+  if (GNUNET_YES !=
+      GNUNET_CONFIGURATION_append_value_filename (cfg,
+                                                  "FILENAMES",
+                                                  "test", "/File 2"))
+    return 72;
+
+  idx = 0;
+  want[1] = "/World";
+  want[2] = "/File 1";
+  want[3] = "/File 2";
+  if (4 != GNUNET_CONFIGURATION_iterate_value_filenames (cfg,
+                                                         "FILENAMES",
+                                                         "test",
+                                                         &check, &idx))
+    return 80;
+  if (idx != 4)
+    return 88;
+  return 0;
+}
+
+int
+main (int argc, char *argv[])
+{
+  int failureCount = 0;
+  char *c;
+
+  GNUNET_log_setup ("test_configuration", "WARNING", NULL);
+  cfg = GNUNET_CONFIGURATION_create ();
+  GNUNET_assert (cfg != NULL);
+  if (GNUNET_OK !=
+      GNUNET_CONFIGURATION_parse (cfg, "test_configuration_data.conf"))
+    {
+      fprintf (stderr, "Failed to parse configuration file\n");
+      GNUNET_CONFIGURATION_destroy (cfg);
+      return 1;
+    }
+  failureCount += testConfig ();
+  failureCount += 2 * testConfigFilenames ();
+
+  if (GNUNET_OK != GNUNET_CONFIGURATION_write (cfg, "/tmp/gnunet-test.conf"))
+    {
+      fprintf (stderr, "Failed to write configuration file\n");
+      GNUNET_CONFIGURATION_destroy (cfg);
+      return 1;
+    }
+  GNUNET_CONFIGURATION_destroy (cfg);
+  GNUNET_assert (0 == UNLINK ("/tmp/gnunet-test.conf"));
+
+  cfg = GNUNET_CONFIGURATION_create ();
+  if (GNUNET_OK !=
+      GNUNET_CONFIGURATION_load (cfg, "test_configuration_data.conf"))
+    {
+      GNUNET_break (0);
+      GNUNET_CONFIGURATION_destroy (cfg);
+      return 1;
+    }
+  if ((GNUNET_OK !=
+       GNUNET_CONFIGURATION_get_value_string (cfg, "TESTING", "WEAKRANDOM",
+                                              &c))
+      || (0 != strcmp (c, "YES")))
+    {
+      GNUNET_CONFIGURATION_destroy (cfg);
+      return 1;
+    }
+  GNUNET_free (c);
+  if ((GNUNET_OK !=
+       GNUNET_CONFIGURATION_get_value_string (cfg, "PATHS", "SERVICEHOME",
+                                              &c))
+      || (0 != strcmp (c, "/var/lib/gnunet/")))
+    {
+      GNUNET_CONFIGURATION_destroy (cfg);
+      return 1;
+    }
+  GNUNET_free (c);
+  GNUNET_CONFIGURATION_destroy (cfg);
+  if (failureCount != 0)
+    {
+      fprintf (stderr, "Test failed: %u\n", failureCount);
+      return 1;
+    }
+  return 0;
+}
diff --git a/src/util/test_configuration_data.conf b/src/util/test_configuration_data.conf
new file mode 100644
index 000000000..52b6b8220
--- /dev/null
+++ b/src/util/test_configuration_data.conf
@@ -0,0 +1,30 @@
+[PATHS]
+SUBST=/hello
+
+[GNUNET]
+SUBST=hello
+GNUNET_HOME=/tmp
+
+[test]
+a=a
+b=b
+five=5
+
+[more]
+c=c
+five=42
+
+                
+[last]
+test = $SUBST/world
+boom = "1 2 3 testing"
+trailing = YES 
+
+[FILENAMES]
+test = "/Hello /File\ Name /World"
+
+
+[TESTING]
+WEAKRANDOM = YES
+
+
diff --git a/src/util/test_container_bloomfilter.c b/src/util/test_container_bloomfilter.c
new file mode 100644
index 000000000..9beb11298
--- /dev/null
+++ b/src/util/test_container_bloomfilter.c
@@ -0,0 +1,246 @@
+/*
+     This file is part of GNUnet.
+     (C) 2004, 2009 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 util/test_container_bloomfilter.c
+ * @brief Testcase for the bloomfilter.
+ * @author Christian Grothoff
+ * @author Igor Wronsky
+ */
+
+#include "platform.h"
+#include "gnunet_common.h"
+#include "gnunet_container_lib.h"
+
+#define K 4
+#define SIZE 65536
+#define TESTFILE "/tmp/bloomtest.dat"
+
+/**
+ * Generate a random hashcode.
+ */
+static void
+nextHC (GNUNET_HashCode * hc)
+{
+  GNUNET_CRYPTO_hash_create_random (hc);
+}
+
+static int
+add_iterator (GNUNET_HashCode * next, void *arg)
+{
+  int *ret = arg;
+  GNUNET_HashCode pos;
+
+  if (0 == (*ret)--)
+    return GNUNET_NO;
+  nextHC (&pos);
+  *next = pos;
+  return GNUNET_YES;
+}
+
+int
+main (int argc, char *argv[])
+{
+  struct GNUNET_CONTAINER_BloomFilter *bf;
+  struct GNUNET_CONTAINER_BloomFilter *bfi;
+  GNUNET_HashCode tmp;
+  int i;
+  int ok1;
+  int ok2;
+  int falseok;
+  char buf[SIZE];
+  struct stat sbuf;
+
+  GNUNET_log_setup ("test-container-bloomfilter", "WARNING", NULL);
+  srand (1);
+  if (0 == stat (TESTFILE, &sbuf))
+    if (0 != UNLINK (TESTFILE))
+      GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_ERROR, "unlink", TESTFILE);
+  bf = GNUNET_CONTAINER_bloomfilter_load (TESTFILE, SIZE, K);
+
+  for (i = 0; i < 200; i++)
+    {
+      nextHC (&tmp);
+      GNUNET_CONTAINER_bloomfilter_add (bf, &tmp);
+    }
+  srand (1);
+  ok1 = 0;
+  for (i = 0; i < 200; i++)
+    {
+      nextHC (&tmp);
+      if (GNUNET_CONTAINER_bloomfilter_test (bf, &tmp) == GNUNET_YES)
+        ok1++;
+    }
+  if (ok1 != 200)
+    {
+      printf ("Got %d elements out of"
+              "200 expected after insertion.\n", ok1);
+      GNUNET_CONTAINER_bloomfilter_free (bf);
+      return -1;
+    }
+  if (GNUNET_OK != GNUNET_CONTAINER_bloomfilter_get_raw_data (bf, buf, SIZE))
+    {
+      GNUNET_CONTAINER_bloomfilter_free (bf);
+      return -1;
+    }
+
+  GNUNET_CONTAINER_bloomfilter_free (bf);
+
+  bf = GNUNET_CONTAINER_bloomfilter_load (TESTFILE, SIZE, K);
+  GNUNET_assert (bf != NULL);
+  bfi = GNUNET_CONTAINER_bloomfilter_init (buf, SIZE, K);
+  GNUNET_assert (bfi != NULL);
+
+  srand (1);
+  ok1 = 0;
+  ok2 = 0;
+  for (i = 0; i < 200; i++)
+    {
+      nextHC (&tmp);
+      if (GNUNET_CONTAINER_bloomfilter_test (bf, &tmp) == GNUNET_YES)
+        ok1++;
+      if (GNUNET_CONTAINER_bloomfilter_test (bfi, &tmp) == GNUNET_YES)
+        ok2++;
+    }
+  if (ok1 != 200)
+    {
+      printf ("Got %d elements out of 200 "
+              "expected after reloading.\n", ok1);
+      GNUNET_CONTAINER_bloomfilter_free (bf);
+      GNUNET_CONTAINER_bloomfilter_free (bfi);
+      return -1;
+    }
+
+  if (ok2 != 200)
+    {
+      printf ("Got %d elements out of 200 "
+              "expected after initialization.\n", ok2);
+      GNUNET_CONTAINER_bloomfilter_free (bf);
+      GNUNET_CONTAINER_bloomfilter_free (bfi);
+      return -1;
+    }
+
+  srand (1);
+  for (i = 0; i < 100; i++)
+    {
+      nextHC (&tmp);
+      GNUNET_CONTAINER_bloomfilter_remove (bf, &tmp);
+      GNUNET_CONTAINER_bloomfilter_remove (bfi, &tmp);
+    }
+
+  srand (1);
+
+  ok1 = 0;
+  ok2 = 0;
+  for (i = 0; i < 200; i++)
+    {
+      nextHC (&tmp);
+      if (GNUNET_CONTAINER_bloomfilter_test (bf, &tmp) == GNUNET_YES)
+        ok1++;
+      if (GNUNET_CONTAINER_bloomfilter_test (bfi, &tmp) == GNUNET_YES)
+        ok2++;
+    }
+
+  if (ok1 != 100)
+    {
+      printf ("Expected 100 elements in loaded filter"
+              " after adding 200 and deleting 100, got %d\n", ok1);
+      GNUNET_CONTAINER_bloomfilter_free (bf);
+      GNUNET_CONTAINER_bloomfilter_free (bfi);
+      return -1;
+    }
+  if (ok2 != 200)
+    {
+      printf ("Expected 200 elements in initialized filter"
+              " after adding 200 and deleting 100 "
+              "(which should do nothing for a filter not backed by a file), got %d\n",
+              ok2);
+      GNUNET_CONTAINER_bloomfilter_free (bf);
+      GNUNET_CONTAINER_bloomfilter_free (bfi);
+      return -1;
+    }
+
+  srand (3);
+
+  GNUNET_CONTAINER_bloomfilter_clear (bf);
+  falseok = 0;
+  for (i = 0; i < 1000; i++)
+    {
+      nextHC (&tmp);
+      if (GNUNET_CONTAINER_bloomfilter_test (bf, &tmp) == GNUNET_YES)
+        falseok++;
+    }
+  if (falseok > 0)
+    {
+      GNUNET_CONTAINER_bloomfilter_free (bf);
+      GNUNET_CONTAINER_bloomfilter_free (bfi);
+      return -1;
+    }
+
+  if (GNUNET_OK != GNUNET_CONTAINER_bloomfilter_or (bf, buf, SIZE))
+    {
+      GNUNET_CONTAINER_bloomfilter_free (bf);
+      GNUNET_CONTAINER_bloomfilter_free (bfi);
+      return -1;
+    }
+
+  srand (2);
+  i = 20;
+  GNUNET_CONTAINER_bloomfilter_resize (bfi, &add_iterator, &i, SIZE * 2, K);
+
+  srand (2);
+  i = 20;
+  GNUNET_CONTAINER_bloomfilter_resize (bf, &add_iterator, &i, SIZE * 2, K);
+  srand (2);
+
+  ok1 = 0;
+  ok2 = 0;
+  for (i = 0; i < 20; i++)
+    {
+      nextHC (&tmp);
+      if (GNUNET_CONTAINER_bloomfilter_test (bf, &tmp) == GNUNET_YES)
+        ok1++;
+      if (GNUNET_CONTAINER_bloomfilter_test (bfi, &tmp) == GNUNET_YES)
+        ok2++;
+    }
+
+  if (ok1 != 20)
+    {
+      printf ("Expected 20 elements in resized file-backed filter"
+              " after adding 20, got %d\n", ok1);
+      GNUNET_CONTAINER_bloomfilter_free (bf);
+      GNUNET_CONTAINER_bloomfilter_free (bfi);
+      return -1;
+    }
+  if (ok2 != 20)
+    {
+      printf ("Expected 20 elements in resized filter"
+              " after adding 20, got %d\n", ok2);
+      GNUNET_CONTAINER_bloomfilter_free (bf);
+      GNUNET_CONTAINER_bloomfilter_free (bfi);
+      return -1;
+    }
+
+
+  GNUNET_CONTAINER_bloomfilter_free (bf);
+  GNUNET_CONTAINER_bloomfilter_free (bfi);
+
+  GNUNET_break (0 == UNLINK (TESTFILE));
+  return 0;
+}
diff --git a/src/util/test_container_heap.c b/src/util/test_container_heap.c
new file mode 100644
index 000000000..511589af5
--- /dev/null
+++ b/src/util/test_container_heap.c
@@ -0,0 +1,112 @@
+/*
+ This file is part of GNUnet.
+ (C) 2008 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.
+ */
+
+/**
+ * @author Nathan Evans
+ * @file util/containers/heaptest.c
+ * @brief Test of heap operations
+ */
+
+#include "gnunet_util.h"
+#include "gnunet_util_containers.h"
+#include "dv.h"
+
+static int
+iterator_callback (void *element, GNUNET_CONTAINER_HeapCost cost,
+                   struct GNUNET_CONTAINER_Heap *root, void *cls)
+{
+  struct GNUNET_dv_neighbor *node;
+  node = (struct GNUNET_dv_neighbor *) element;
+  fprintf (stdout, "%d\n", node->cost);
+  //fprintf (stdout, "%d\n", ((struct GNUNET_dv_neighbor *)element)->cost);
+
+  return GNUNET_OK;
+}
+
+
+int
+main (int argc, char **argv)
+{
+  struct GNUNET_CONTAINER_Heap *myHeap;
+  struct GNUNET_dv_neighbor *neighbor1;
+  struct GNUNET_dv_neighbor *neighbor2;
+  struct GNUNET_dv_neighbor *neighbor3;
+  struct GNUNET_dv_neighbor *neighbor4;
+  struct GNUNET_dv_neighbor *neighbor5;
+  struct GNUNET_dv_neighbor *neighbor6;
+
+  GNUNET_log_setup ("test-container-heap", "WARNING", NULL);
+
+  myHeap = GNUNET_CONTAINER_heap_create (GNUNET_CONTAINER_HEAP_ORDER_MAX);
+
+  neighbor1 = malloc (sizeof (struct GNUNET_dv_neighbor));
+  neighbor2 = malloc (sizeof (struct GNUNET_dv_neighbor));
+  neighbor3 = malloc (sizeof (struct GNUNET_dv_neighbor));
+  neighbor4 = malloc (sizeof (struct GNUNET_dv_neighbor));
+  neighbor5 = malloc (sizeof (struct GNUNET_dv_neighbor));
+  neighbor6 = malloc (sizeof (struct GNUNET_dv_neighbor));
+
+  neighbor1->cost = 60;
+  neighbor2->cost = 50;
+  neighbor3->cost = 70;
+  neighbor4->cost = 120;
+  neighbor5->cost = 100;
+  neighbor6->cost = 30;
+
+  GNUNET_CONTAINER_heap_insert (myHeap, neighbor1, neighbor1->cost);
+  GNUNET_CONTAINER_heap_iterate (myHeap, iterator_callback, NULL);
+
+  fprintf (stdout, "\n");
+  GNUNET_CONTAINER_heap_insert (myHeap, neighbor2, neighbor2->cost);
+
+  GNUNET_CONTAINER_heap_iterate (myHeap, iterator_callback, NULL);
+  fprintf (stdout, "\n");
+  GNUNET_CONTAINER_heap_insert (myHeap, neighbor3, neighbor3->cost);
+
+  GNUNET_CONTAINER_heap_iterate (myHeap, iterator_callback, NULL);
+  fprintf (stdout, "\n");
+  GNUNET_CONTAINER_heap_insert (myHeap, neighbor4, neighbor4->cost);
+
+  GNUNET_CONTAINER_heap_iterate (myHeap, iterator_callback, NULL);
+  fprintf (stdout, "\n");
+  GNUNET_CONTAINER_heap_insert (myHeap, neighbor5, neighbor5->cost);
+
+  GNUNET_CONTAINER_heap_iterate (myHeap, iterator_callback, NULL);
+  fprintf (stdout, "\n");
+  GNUNET_CONTAINER_heap_insert (myHeap, neighbor6, neighbor6->cost);
+
+  GNUNET_CONTAINER_heap_iterate (myHeap, iterator_callback, NULL);
+  fprintf (stdout, "\n");
+  GNUNET_CONTAINER_heap_remove_node (myHeap, neighbor5);
+
+  GNUNET_CONTAINER_heap_iterate (myHeap, iterator_callback, NULL);
+  fprintf (stdout, "\n");
+  GNUNET_CONTAINER_heap_remove_root (myHeap);
+
+  GNUNET_CONTAINER_heap_iterate (myHeap, iterator_callback, NULL);
+  fprintf (stdout, "\n");
+  GNUNET_CONTAINER_heap_update_cost (myHeap, neighbor6, 200);
+
+  GNUNET_CONTAINER_heap_iterate (myHeap, iterator_callback, NULL);
+  fprintf (stdout, "\n");
+  return 0;
+}
+
+/* end of heaptest.c */
diff --git a/src/util/test_container_meta_data.c b/src/util/test_container_meta_data.c
new file mode 100644
index 000000000..17ef79161
--- /dev/null
+++ b/src/util/test_container_meta_data.c
@@ -0,0 +1,262 @@
+/*
+     This file is part of GNUnet.
+     (C) 2003, 2004, 2006, 2009 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 util/test_container_meta_data.c
+ * @brief Test for container_meta_data.c
+ * @author Christian Grothoff
+ */
+
+#include "platform.h"
+#include "gnunet_common.h"
+#include "gnunet_container_lib.h"
+
+#define ABORT(m) { fprintf(stderr, "Error at %s:%d\n", __FILE__, __LINE__); if (m != NULL) GNUNET_CONTAINER_meta_data_destroy(m); return 1; }
+
+static int
+testMeta (int i)
+{
+  struct GNUNET_CONTAINER_MetaData *m;
+  char *val;
+  int j;
+  unsigned int size;
+
+  m = GNUNET_CONTAINER_meta_data_create ();
+  if (GNUNET_OK !=
+      GNUNET_CONTAINER_meta_data_insert (m, EXTRACTOR_TITLE, "TestTitle"))
+    ABORT (m);
+  if (GNUNET_OK !=
+      GNUNET_CONTAINER_meta_data_insert (m, EXTRACTOR_AUTHOR, "TestTitle"))
+    ABORT (m);
+  if (GNUNET_OK == GNUNET_CONTAINER_meta_data_insert (m, EXTRACTOR_TITLE, "TestTitle")) /* dup! */
+    ABORT (m);
+  if (GNUNET_OK == GNUNET_CONTAINER_meta_data_insert (m, EXTRACTOR_AUTHOR, "TestTitle"))        /* dup! */
+    ABORT (m);
+  if (2 != GNUNET_CONTAINER_meta_data_get_contents (m, NULL, NULL))
+    ABORT (m);
+  if (GNUNET_OK !=
+      GNUNET_CONTAINER_meta_data_delete (m, EXTRACTOR_AUTHOR, "TestTitle"))
+    ABORT (m);
+  if (GNUNET_OK == GNUNET_CONTAINER_meta_data_delete (m, EXTRACTOR_AUTHOR, "TestTitle"))        /* already gone */
+    ABORT (m);
+  if (1 != GNUNET_CONTAINER_meta_data_get_contents (m, NULL, NULL))
+    ABORT (m);
+  if (GNUNET_OK !=
+      GNUNET_CONTAINER_meta_data_delete (m, EXTRACTOR_TITLE, "TestTitle"))
+    ABORT (m);
+  if (GNUNET_OK == GNUNET_CONTAINER_meta_data_delete (m, EXTRACTOR_TITLE, "TestTitle")) /* already gone */
+    ABORT (m);
+  if (0 != GNUNET_CONTAINER_meta_data_get_contents (m, NULL, NULL))
+    ABORT (m);
+  val = GNUNET_malloc (256);
+  for (j = 0; j < i; j++)
+    {
+      GNUNET_snprintf (val, 256, "%s.%d",
+                       "A teststring that should compress well.", j);
+      if (GNUNET_OK !=
+          GNUNET_CONTAINER_meta_data_insert (m, EXTRACTOR_UNKNOWN, val))
+        {
+          GNUNET_free (val);
+          ABORT (m);
+        }
+    }
+  GNUNET_free (val);
+  if (i != GNUNET_CONTAINER_meta_data_get_contents (m, NULL, NULL))
+    ABORT (m);
+
+  size =
+    GNUNET_CONTAINER_meta_data_get_serialized_size (m,
+                                                    GNUNET_CONTAINER_META_DATA_SERIALIZE_FULL);
+  val = GNUNET_malloc (size);
+  if (size != GNUNET_CONTAINER_meta_data_serialize (m, val, size,
+                                                    GNUNET_CONTAINER_META_DATA_SERIALIZE_FULL))
+    {
+      GNUNET_free (val);
+      ABORT (m);
+    }
+  GNUNET_CONTAINER_meta_data_destroy (m);
+  m = GNUNET_CONTAINER_meta_data_deserialize (val, size);
+  GNUNET_free (val);
+  if (m == NULL)
+    ABORT (m);
+  val = GNUNET_malloc (256);
+  for (j = 0; j < i; j++)
+    {
+      GNUNET_snprintf (val, 256, "%s.%d",
+                       "A teststring that should compress well.", j);
+      if (GNUNET_OK !=
+          GNUNET_CONTAINER_meta_data_delete (m, EXTRACTOR_UNKNOWN, val))
+        {
+          GNUNET_free (val);
+          ABORT (m);
+        }
+    }
+  GNUNET_free (val);
+  if (0 != GNUNET_CONTAINER_meta_data_get_contents (m, NULL, NULL))
+    {
+      ABORT (m);
+    }
+  GNUNET_CONTAINER_meta_data_destroy (m);
+  return 0;
+}
+
+int
+testMetaMore (int i)
+{
+  struct GNUNET_CONTAINER_MetaData *meta;
+  int q;
+  char txt[128];
+  char *data;
+  unsigned long long size;
+
+  meta = GNUNET_CONTAINER_meta_data_create ();
+  for (q = 0; q <= i; q++)
+    {
+      GNUNET_snprintf (txt, 128, "%u -- %u\n", i, q);
+      GNUNET_CONTAINER_meta_data_insert (meta,
+                                         q %
+                                         EXTRACTOR_getHighestKeywordTypeNumber
+                                         (), txt);
+    }
+  size =
+    GNUNET_CONTAINER_meta_data_get_serialized_size (meta,
+                                                    GNUNET_CONTAINER_META_DATA_SERIALIZE_FULL);
+  data = GNUNET_malloc (size * 4);
+  if (size != GNUNET_CONTAINER_meta_data_serialize (meta,
+                                                    data, size * 4,
+                                                    GNUNET_CONTAINER_META_DATA_SERIALIZE_FULL))
+    {
+      GNUNET_free (data);
+      ABORT (meta);
+    }
+  GNUNET_CONTAINER_meta_data_destroy (meta);
+  GNUNET_free (data);
+  return 0;
+}
+
+static int
+testMetaLink ()
+{
+  struct GNUNET_CONTAINER_MetaData *m;
+  char *val;
+  unsigned int size;
+
+  m = GNUNET_CONTAINER_meta_data_create ();
+  if (GNUNET_OK !=
+      GNUNET_CONTAINER_meta_data_insert (m, EXTRACTOR_UNKNOWN, "link"))
+    ABORT (m);
+  if (GNUNET_OK !=
+      GNUNET_CONTAINER_meta_data_insert (m, EXTRACTOR_FILENAME,
+                                         "lib-link.m4"))
+    ABORT (m);
+  size =
+    GNUNET_CONTAINER_meta_data_get_serialized_size (m,
+                                                    GNUNET_CONTAINER_META_DATA_SERIALIZE_FULL);
+  val = GNUNET_malloc (size);
+  if (size != GNUNET_CONTAINER_meta_data_serialize (m, val, size,
+                                                    GNUNET_CONTAINER_META_DATA_SERIALIZE_FULL))
+    {
+      GNUNET_free (val);
+      ABORT (m);
+    }
+  GNUNET_CONTAINER_meta_data_destroy (m);
+  m = GNUNET_CONTAINER_meta_data_deserialize (val, size);
+  GNUNET_free (val);
+  if (m == NULL)
+    ABORT (m);
+  GNUNET_CONTAINER_meta_data_destroy (m);
+  return 0;
+}
+
+
+static int
+testThumbnail ()
+{
+  struct GNUNET_CONTAINER_MetaData *m;
+  struct GNUNET_CONTAINER_MetaData *d;
+  EXTRACTOR_ExtractorList *ex;
+  unsigned char *thumb;
+  size_t size;
+  char *date;
+
+  ex = EXTRACTOR_loadConfigLibraries (NULL, "libextractor_thumbnail");
+  if (ex == NULL)
+    {
+      fprintf (stderr,
+               "Test incomplete, have no thumbnail extractor available.\n");
+      return 0;                 /* can not test, no thumbnailer */
+    }
+  ex = EXTRACTOR_loadConfigLibraries (ex, "libextractor_mime");
+  m = GNUNET_CONTAINER_meta_data_create ();
+  if (3 != GNUNET_CONTAINER_meta_data_extract_from_file (m,
+                                                         "test_container_meta_data_image.jpg",
+                                                         ex))
+    {
+      GNUNET_break (0);
+      EXTRACTOR_removeAll (ex);
+      GNUNET_CONTAINER_meta_data_destroy (m);
+      return 1;
+    }
+  EXTRACTOR_removeAll (ex);
+  d = GNUNET_CONTAINER_meta_data_duplicate (m);
+  GNUNET_CONTAINER_meta_data_destroy (m);
+  size = GNUNET_CONTAINER_meta_data_get_thumbnail (d, &thumb);
+  if (size == 0)
+    {
+      GNUNET_break (0);
+      GNUNET_CONTAINER_meta_data_destroy (d);
+      return 1;
+    }
+  GNUNET_free (thumb);
+  GNUNET_CONTAINER_meta_data_add_publication_date (d);
+  date = GNUNET_CONTAINER_meta_data_get_by_type (d,
+                                                 EXTRACTOR_PUBLICATION_DATE);
+  if (date == NULL)
+    {
+      GNUNET_break (0);
+      GNUNET_CONTAINER_meta_data_destroy (d);
+      return 1;
+    }
+  GNUNET_free (date);
+  GNUNET_CONTAINER_meta_data_destroy (d);
+  return 0;
+}
+
+
+int
+main (int argc, char *argv[])
+{
+  int failureCount = 0;
+  int i;
+
+  GNUNET_log_setup ("test-container-meta-data", "WARNING", NULL);
+  for (i = 0; i < 255; i++)
+    failureCount += testMeta (i);
+  for (i = 1; i < 255; i++)
+    failureCount += testMetaMore (i);
+  failureCount += testMetaLink ();
+  failureCount += testThumbnail ();
+
+  if (failureCount != 0)
+    return 1;
+  return 0;
+}
+
+/* end of metatest.c */
diff --git a/src/util/test_container_meta_data_image.jpg b/src/util/test_container_meta_data_image.jpg
new file mode 100644
index 000000000..3d1ba3307
--- /dev/null
+++ b/src/util/test_container_meta_data_image.jpg
diff --git a/src/util/test_container_multihashmap.c b/src/util/test_container_multihashmap.c
new file mode 100644
index 000000000..e92ab49ba
--- /dev/null
+++ b/src/util/test_container_multihashmap.c
@@ -0,0 +1,113 @@
+/*
+     This file is part of GNUnet.
+     (C) 2008 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 util/test_container_multihashmap.c
+ * @brief Test for container_multihashmap.c
+ * @author Christian Grothoff
+ */
+
+#include "platform.h"
+#include "gnunet_common.h"
+#include "gnunet_container_lib.h"
+
+#define ABORT() { fprintf(stderr, "Error at %s:%d\n", __FILE__, __LINE__); if (m != NULL) GNUNET_CONTAINER_multihashmap_destroy(m); return 1; }
+#define CHECK(c) { if (! (c)) ABORT(); }
+
+static int
+testMap (int i)
+{
+  struct GNUNET_CONTAINER_MultiHashMap *m;
+  GNUNET_HashCode k1;
+  GNUNET_HashCode k2;
+  int j;
+  void *r;
+
+  CHECK (NULL != (m = GNUNET_CONTAINER_multihashmap_create (i)));
+  memset (&k1, 0, sizeof (k1));
+  memset (&k2, 1, sizeof (k2));
+  CHECK (GNUNET_NO == GNUNET_CONTAINER_multihashmap_contains (m, &k1));
+  CHECK (GNUNET_NO == GNUNET_CONTAINER_multihashmap_contains (m, &k2));
+  CHECK (GNUNET_NO == GNUNET_CONTAINER_multihashmap_remove (m, &k1, NULL));
+  CHECK (GNUNET_NO == GNUNET_CONTAINER_multihashmap_remove (m, &k2, NULL));
+  CHECK (NULL == GNUNET_CONTAINER_multihashmap_get (m, &k1));
+  CHECK (NULL == GNUNET_CONTAINER_multihashmap_get (m, &k2));
+  CHECK (0 == GNUNET_CONTAINER_multihashmap_remove_all (m, &k1));
+  CHECK (0 == GNUNET_CONTAINER_multihashmap_size (m));
+  CHECK (0 == GNUNET_CONTAINER_multihashmap_iterate (m, NULL, NULL));
+  CHECK (0 ==
+         GNUNET_CONTAINER_multihashmap_get_multiple (m, &k1, NULL, NULL));
+
+  CHECK (GNUNET_OK == GNUNET_CONTAINER_multihashmap_put (m,
+                                                         &k1,
+                                                         "v1",
+                                                         GNUNET_CONTAINER_MULTIHASHMAPOPTION_REPLACE));
+  CHECK (1 == GNUNET_CONTAINER_multihashmap_size (m));
+  CHECK (0 == strcmp ("v1", GNUNET_CONTAINER_multihashmap_get (m, &k1)));
+  CHECK (GNUNET_NO == GNUNET_CONTAINER_multihashmap_put (m,
+                                                         &k1,
+                                                         "v1",
+                                                         GNUNET_CONTAINER_MULTIHASHMAPOPTION_REPLACE));
+  CHECK (1 == GNUNET_CONTAINER_multihashmap_size (m));
+  CHECK (GNUNET_OK == GNUNET_CONTAINER_multihashmap_put (m,
+                                                         &k1,
+                                                         "v2",
+                                                         GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE));
+  CHECK (GNUNET_OK == GNUNET_CONTAINER_multihashmap_put (m,
+                                                         &k1,
+                                                         "v3",
+                                                         GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE));
+  CHECK (3 == GNUNET_CONTAINER_multihashmap_size (m));
+  CHECK (GNUNET_OK == GNUNET_CONTAINER_multihashmap_remove (m, &k1, "v3"));
+  CHECK (2 == GNUNET_CONTAINER_multihashmap_size (m));
+  CHECK (GNUNET_YES == GNUNET_CONTAINER_multihashmap_contains (m, &k1));
+  CHECK (GNUNET_NO == GNUNET_CONTAINER_multihashmap_contains (m, &k2));
+  CHECK (2 ==
+         GNUNET_CONTAINER_multihashmap_get_multiple (m, &k1, NULL, NULL));
+  CHECK (0 ==
+         GNUNET_CONTAINER_multihashmap_get_multiple (m, &k2, NULL, NULL));
+  CHECK (2 == GNUNET_CONTAINER_multihashmap_iterate (m, NULL, NULL));
+  r = GNUNET_CONTAINER_multihashmap_get_random (m);
+  CHECK (0 == strcmp (r, "v1") || 0 == strcmp (r, "v2"));
+  CHECK (2 == GNUNET_CONTAINER_multihashmap_remove_all (m, &k1));
+  for (j = 0; j < 1024; j++)
+    CHECK (GNUNET_OK == GNUNET_CONTAINER_multihashmap_put (m,
+                                                           &k1,
+                                                           "v2",
+                                                           GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE));
+  GNUNET_CONTAINER_multihashmap_destroy (m);
+  return 0;
+}
+
+int
+main (int argc, char *argv[])
+{
+  int failureCount = 0;
+  int i;
+
+  GNUNET_log_setup ("test-container-multihashmap", "WARNING", NULL);
+  for (i = 1; i < 255; i++)
+    failureCount += testMap (i);
+  if (failureCount != 0)
+    return 1;
+  return 0;
+}
+
+/* end of maptest.c */
diff --git a/src/util/test_crypto_aes.c b/src/util/test_crypto_aes.c
new file mode 100644
index 000000000..cdae243e0
--- /dev/null
+++ b/src/util/test_crypto_aes.c
@@ -0,0 +1,180 @@
+/*
+     This file is part of GNUnet.
+     (C) 2002, 2003, 2004, 2006 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.
+
+*/
+/**
+ * @author Christian Grothoff
+ * @file util/test_crypto_aes.c
+ * @brief test for AES ciphers
+ */
+#include "platform.h"
+#include "gnunet_common.h"
+#include "gnunet_crypto_lib.h"
+
+#define TESTSTRING "Hello World!"
+#define INITVALUE "InitializationVectorValue"
+
+static int
+testSymcipher ()
+{
+  struct GNUNET_CRYPTO_AesSessionKey key;
+  char result[100];
+  int size;
+  char res[100];
+
+  GNUNET_CRYPTO_aes_create_session_key (&key);
+  size = GNUNET_CRYPTO_aes_encrypt (TESTSTRING,
+                                    strlen (TESTSTRING) + 1,
+                                    &key,
+                                    (const struct
+                                     GNUNET_CRYPTO_AesInitializationVector *)
+                                    INITVALUE, result);
+  if (size == -1)
+    {
+      printf ("symciphertest failed: encryptBlock returned %d\n", size);
+      return 1;
+    }
+  size = GNUNET_CRYPTO_aes_decrypt (&key,
+                                    result, size,
+                                    (const struct
+                                     GNUNET_CRYPTO_AesInitializationVector *)
+                                    INITVALUE, res);
+  if (strlen (TESTSTRING) + 1 != size)
+    {
+      printf ("symciphertest failed: decryptBlock returned %d\n", size);
+      return 1;
+    }
+  if (0 != strcmp (res, TESTSTRING))
+    {
+      printf ("symciphertest failed: %s != %s\n", res, TESTSTRING);
+      return 1;
+    }
+  else
+    return 0;
+}
+
+int
+verifyCrypto ()
+{
+  struct GNUNET_CRYPTO_AesSessionKey key;
+  char result[GNUNET_CRYPTO_AES_KEY_LENGTH];
+  char *res;
+  int ret;
+
+  unsigned char plain[] =
+    { 29, 128, 192, 253, 74, 171, 38, 187, 84, 219, 76, 76, 209, 118, 33, 249,
+    172, 124, 96, 9, 157, 110, 8, 215, 200, 63, 69, 230, 157, 104, 247, 164
+  };
+  unsigned char raw_key[] =
+    { 106, 74, 209, 88, 145, 55, 189, 135, 125, 180, 225, 108, 183, 54, 25,
+    169, 129, 188, 131, 75, 227, 245, 105, 10, 225, 15, 115, 159, 148, 184,
+    34, 191
+  };
+  unsigned char encrresult[] =
+    { 167, 102, 230, 233, 127, 195, 176, 107, 17, 91, 199, 127, 96, 113, 75,
+    195, 245, 217, 61, 236, 159, 165, 103, 121, 203, 99, 202, 41, 23, 222, 25,
+    102, 1
+  };
+
+  res = NULL;
+  ret = 0;
+
+  memcpy (key.key, raw_key, GNUNET_CRYPTO_AES_KEY_LENGTH);
+  key.crc32 =
+    htonl (GNUNET_CRYPTO_crc32_n (&key, GNUNET_CRYPTO_AES_KEY_LENGTH));
+
+  if (ntohl (key.crc32) != (unsigned int) 38125195LL)
+    {
+      printf ("Static key has different CRC: %u - %u\n",
+              ntohl (key.crc32), key.crc32);
+
+      ret = 1;
+      goto error;
+    }
+
+  if (GNUNET_CRYPTO_AES_KEY_LENGTH !=
+      GNUNET_CRYPTO_aes_encrypt (plain,
+                                 GNUNET_CRYPTO_AES_KEY_LENGTH,
+                                 &key,
+                                 (const struct
+                                  GNUNET_CRYPTO_AesInitializationVector *)
+                                 "testtesttesttest", result))
+    {
+      printf ("Wrong return value from encrypt block.\n");
+      ret = 1;
+      goto error;
+    }
+
+  if (memcmp (encrresult, result, GNUNET_CRYPTO_AES_KEY_LENGTH) != 0)
+    {
+      printf ("Encrypted result wrong.\n");
+      ret = 1;
+      goto error;
+    }
+
+  res = GNUNET_malloc (GNUNET_CRYPTO_AES_KEY_LENGTH);
+
+  if (GNUNET_CRYPTO_AES_KEY_LENGTH !=
+      GNUNET_CRYPTO_aes_decrypt (&key,
+                                 result,
+                                 GNUNET_CRYPTO_AES_KEY_LENGTH,
+                                 (const struct
+                                  GNUNET_CRYPTO_AesInitializationVector *)
+                                 "testtesttesttest", res))
+    {
+      printf ("Wrong return value from decrypt block.\n");
+      ret = 1;
+      goto error;
+    }
+
+  if (memcmp (res, plain, GNUNET_CRYPTO_AES_KEY_LENGTH) != 0)
+    {
+      printf ("Decrypted result does not match input.\n");
+
+      ret = 1;
+    }
+
+error:
+
+  GNUNET_free_non_null (res);
+
+  return ret;
+}
+
+int
+main (int argc, char *argv[])
+{
+  int failureCount = 0;
+
+  GNUNET_log_setup ("test-crypto-aes", "WARNING", NULL);
+  GNUNET_CRYPTO_random_disable_entropy_gathering ();
+  GNUNET_assert (strlen (INITVALUE) >
+                 sizeof (struct GNUNET_CRYPTO_AesInitializationVector));
+  failureCount += testSymcipher ();
+  failureCount += verifyCrypto ();
+
+  if (failureCount != 0)
+    {
+      printf ("%d TESTS FAILED!\n", failureCount);
+      return -1;
+    }
+  return 0;
+}
+
+/* end of test_crypto_aes.c */
diff --git a/src/util/test_crypto_aes_weak.c b/src/util/test_crypto_aes_weak.c
new file mode 100644
index 000000000..27ee57968
--- /dev/null
+++ b/src/util/test_crypto_aes_weak.c
@@ -0,0 +1,203 @@
+/*
+     This file is part of GNUnet.
+     (C) 2003, 2004, 2005, 2006 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.
+
+*/
+
+/**
+ * @author Krista Bennett
+ * @author Christian Grothoff
+ * @file util/test_crypto_aes_weak.c
+ * @brief AES weak key test.
+ */
+#include "platform.h"
+#include "gnunet_common.h"
+#include "gnunet_crypto_lib.h"
+#include <gcrypt.h>
+
+#define MAX_WEAK_KEY_TRIALS 100000
+#define GENERATE_WEAK_KEYS GNUNET_NO
+#define WEAK_KEY_TESTSTRING "I hate weak keys."
+
+static void
+printWeakKey (struct GNUNET_CRYPTO_AesSessionKey *key)
+{
+  int i;
+  for (i = 0; i < GNUNET_CRYPTO_AES_KEY_LENGTH; i++)
+    {
+      printf ("%x ", (int) (key->key[i]));
+    }
+}
+
+static int
+testWeakKey ()
+{
+  char result[100];
+  char res[100];
+  int size;
+  struct GNUNET_CRYPTO_AesSessionKey weak_key;
+  struct GNUNET_CRYPTO_AesInitializationVector INITVALUE;
+
+  memset (&INITVALUE, 42,
+          sizeof (struct GNUNET_CRYPTO_AesInitializationVector));
+  /* sorry, this is not a weak key -- I don't have
+     any at the moment! */
+  weak_key.key[0] = (char) (0x4c);
+  weak_key.key[1] = (char) (0x31);
+  weak_key.key[2] = (char) (0xc6);
+  weak_key.key[3] = (char) (0x2b);
+  weak_key.key[4] = (char) (0xc1);
+  weak_key.key[5] = (char) (0x5f);
+  weak_key.key[6] = (char) (0x4d);
+  weak_key.key[7] = (char) (0x1f);
+  weak_key.key[8] = (char) (0x31);
+  weak_key.key[9] = (char) (0xaa);
+  weak_key.key[10] = (char) (0x12);
+  weak_key.key[11] = (char) (0x2e);
+  weak_key.key[12] = (char) (0xb7);
+  weak_key.key[13] = (char) (0x82);
+  weak_key.key[14] = (char) (0xc0);
+  weak_key.key[15] = (char) (0xb6);
+  weak_key.key[16] = (char) (0x4d);
+  weak_key.key[17] = (char) (0x1f);
+  weak_key.key[18] = (char) (0x31);
+  weak_key.key[19] = (char) (0xaa);
+  weak_key.key[20] = (char) (0x4c);
+  weak_key.key[21] = (char) (0x31);
+  weak_key.key[22] = (char) (0xc6);
+  weak_key.key[23] = (char) (0x2b);
+  weak_key.key[24] = (char) (0xc1);
+  weak_key.key[25] = (char) (0x5f);
+  weak_key.key[26] = (char) (0x4d);
+  weak_key.key[27] = (char) (0x1f);
+  weak_key.key[28] = (char) (0x31);
+  weak_key.key[29] = (char) (0xaa);
+  weak_key.key[30] = (char) (0xaa);
+  weak_key.key[31] = (char) (0xaa);
+  /* memset(&weak_key, 0, 32); */
+  weak_key.crc32 =
+    htonl (GNUNET_CRYPTO_crc32_n (&weak_key, GNUNET_CRYPTO_AES_KEY_LENGTH));
+
+  size = GNUNET_CRYPTO_aes_encrypt (WEAK_KEY_TESTSTRING,
+                                    strlen (WEAK_KEY_TESTSTRING) + 1,
+                                    &weak_key, &INITVALUE, result);
+
+  if (size == -1)
+    {
+      GNUNET_break (0);
+      return 1;
+    }
+
+  size = GNUNET_CRYPTO_aes_decrypt (&weak_key, result, size, &INITVALUE, res);
+
+  if ((strlen (WEAK_KEY_TESTSTRING) + 1) != size)
+    {
+      GNUNET_break (0);
+      return 1;
+    }
+  if (0 != strcmp (res, WEAK_KEY_TESTSTRING))
+    {
+      GNUNET_break (0);
+      return 1;
+    }
+  else
+    return 0;
+}
+
+static int
+getWeakKeys ()
+{
+  struct GNUNET_CRYPTO_AesSessionKey sessionkey;
+  int number_of_weak_keys = 0;
+  int number_of_runs;
+
+  gcry_cipher_hd_t handle;
+  int rc;
+
+  for (number_of_runs = 0; number_of_runs < MAX_WEAK_KEY_TRIALS;
+       number_of_runs++)
+    {
+
+      if (number_of_runs % 1000 == 0)
+        fprintf (stderr, ".");
+      /*printf("Got to run number %d.\n", number_of_runs); */
+      GNUNET_CRYPTO_aes_create_session_key (&sessionkey);
+
+      rc = gcry_cipher_open (&handle,
+                             GCRY_CIPHER_AES256, GCRY_CIPHER_MODE_CFB, 0);
+
+      if (rc)
+        {
+          printf ("testweakkey: gcry_cipher_open failed on trial %d. %s\n",
+                  number_of_runs, gcry_strerror (rc));
+          rc = 0;
+          continue;
+        }
+
+      rc =
+        gcry_cipher_setkey (handle, &sessionkey,
+                            GNUNET_CRYPTO_AES_KEY_LENGTH);
+
+      if ((char) rc == GPG_ERR_WEAK_KEY)
+        {
+          printf ("\nWeak key (in hex): ");
+          printWeakKey (&sessionkey);
+          printf ("\n");
+          number_of_weak_keys++;
+        }
+      else if (rc)
+        {
+          printf ("\nUnexpected error generating keys. Error is %s\n",
+                  gcry_strerror (rc));
+        }
+
+      gcry_cipher_close (handle);
+
+    }
+
+  return number_of_weak_keys;
+}
+
+int
+main (int argc, char *argv[])
+{
+  int weak_keys;
+
+  GNUNET_log_setup ("test-crypto-aes-weak", "WARNING", NULL);
+  GNUNET_CRYPTO_random_disable_entropy_gathering ();
+  if (GENERATE_WEAK_KEYS)
+    {
+      weak_keys = getWeakKeys ();
+
+      if (weak_keys == 0)
+        {
+          printf ("\nNo weak keys found in %d runs.\n", MAX_WEAK_KEY_TRIALS);
+        }
+      else
+        {
+          printf ("\n%d weak keys found in %d runs.\n",
+                  weak_keys, MAX_WEAK_KEY_TRIALS);
+        }
+    }
+
+  if (testWeakKey () != 0)
+    return -1;
+  return 0;
+}
+
+/* end of weakkeytest.c */
diff --git a/src/util/test_crypto_crc.c b/src/util/test_crypto_crc.c
new file mode 100644
index 000000000..d1505516b
--- /dev/null
+++ b/src/util/test_crypto_crc.c
@@ -0,0 +1,221 @@
+/*
+     This file is part of GNUnet.
+     (C) 2001, 2002, 2003, 2004, 2006 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.
+
+     For the actual CRC code:
+     Copyright abandoned; this code is in the public domain.
+     Provided to GNUnet by peter@horizon.com
+*/
+
+/**
+ * @file util/test_crypto_crc.c
+ * @brief testcase for crypto_crc.c
+ */
+#include "platform.h"
+#include "gnunet_common.h"
+#include "gnunet_crypto_lib.h"
+
+static int expected[] = {
+  -1223996378, 929797997, -1048047323, 1791081351, -425765913, 2138425902,
+  82584863, 1939615314, 1806463044, -1505003452, 1878277636, -997353517,
+  201238705, 1723258694, -1107452366, -344562561, -1102247383, 1973035265,
+  715213337, -1886586005, 2021214515, -1387332962, 593019378, -571088044,
+  1412577760, 412164558, -1626111170, 1556494863, -289796528, -850404775,
+  2066714587, -911838105, -1426027382, 499684507, -835420055, 1817119454,
+  -1221795958, 1516966784, -1038806877, -2115880691, 532627620, 1984437415,
+  -396341583, -1345366324, -590766745, -1801923449, 1752427988, -386896390,
+  453906317, 1552589433, -858925718, 1160445643, -740188079, -486609040,
+  1102529269, -515846212, -1614217202, 1572162207, 943558923, -467330358,
+  -1870764193, 1477005328, -793029208, -888983175, -696956020, 842706021,
+  1642390067, -805889494, 1284862057, 1562545388, 2091626273, 1852404553,
+  -2076508101, 370903003, 1186422975, 1936085227, 769358463, 180401058,
+  2032612572, -105461719, -1119935472, 617249831, 1169304728, 1771205256,
+  -2042554284, 653270859, -918610713, 336081663, -913685370, 1962213744,
+  -505406126, -838622649, -1141518710, 893143582, -1330296611, 122119483,
+  1111564496, 688811976, 1016241049, -1803438473, 359630107, 1034798954,
+  -581359286, 1590946527, -389997034, 2020318460, 1695967527, -464069727,
+  -862641495, -1405012109, -771244841, 738226150, -1035328134, -933945474,
+  1254965774, 1661863830, -884127998, 1800460481, 814702567, -1214068102,
+  -541120421, 1898656429, -236825530, 1505866267, 1252462132, -981007520,
+  1502096471, -2134644056, 483221797, 1276403836, 541133290, -1234093967,
+  350748780, 257941070, 1030457090, 434988890, -1098135432, -1000556640,
+  -577128022, 644806294, -787536281, -1288346343, 998079404, 1259353935,
+  955771631, -958377466, 1746756252, 451579658, 1913409243, -952026299,
+  -1556035958, -830279881, 834744289, -1878491428, 700000962, -1027245802,
+  1393574384, -1260409147, -841420884, 892132797, 1494730226, -1649181766,
+  1651097838, -1041807403, -1916675721, -1324525963, 157405899, -655788033,
+  -1943555237, -79747022, 339721623, -138341083, 1111902411, -435322914,
+  -533294200, -190220608, -1718346014, -1631301894, 1706265243, 745533899,
+  1351941230, 1803009594, -1218191958, 1467751062, 84368433, -711251880,
+  1699423788, -768792716, 846639904, 2103267723, -2095288070, -440571408,
+  -362144485, 2020468971, 352105963, -849211036, -1272592429, 1743440467,
+  2020667861, -1649992312, 172682343, 816705364, -1990206923, 902689869,
+  -298510060, 164207498, 190378213, 242531543, 113383268, 304810777,
+  -1081099373, 819221134, -1100982926, -855941239, 1091308887, -934548124,
+  520508733, -1381763773, -491593287, -2143492665, 700894653, -2049034808,
+  -160942046, -2009323577, 1464245054, 1584746011, -768646852, -993282698,
+  1265838699, -1873820824, 575704373, -986682955, 1270688416, 88587481,
+  -1723991633, -409928242, 866669946, -483811323, -181759253, -963525431,
+  -1686612238, -1663460076, -1128449775, -1368922329, 122318131, 795862385,
+  528576131, -19927090, 1369299478, 1285665642, -738964611, 1328292127,
+  552041252, -1431494354, -1205275362, 42768297, -1329537238, -449177266,
+  943925221, 987016465, -945138414, -270064876, 1650366626, -369252552,
+  582030210, -1229235374, 147901387, -517510506, -1609742888, -1086838308,
+  1391998445, -313975512, -613392078, 855706229, 1475706341, -1112105406,
+  2032001400, 1565777625, 2030937777, 435522421, 1823527907, -691390605,
+  -827253664, 1057171580, -314146639, -630099999, -1347514552, 478716232,
+  -1533658804, -1425371979, 761987780, 1560243817, -1945893959, 1205759225,
+  -959343783, -576742354, -154125407, -1158108776, 1183788580, 1354198127,
+  -1534207721, -823991517, -170534462, -912524170, 1858513573, 467072185,
+  2091040157, -1765027018, -1659401643, -1173890143, -1912754057, -84568053,
+  2010781784, -921970156, 944508352, -922040609, 1055102010, 1018688871,
+  -1186761311, -2012263648, 1311654161, 277659086, 2029602288, 1127061510,
+  1029452642, 285677123, -188521091, -641039012, 653836416, -805916340,
+  -1644860596, 1352872213, 691634876, -1477113308, -748430369, 1030697363,
+  -2007864449, -1196662616, 1313997192, 177342476, -566676450, -1118618118,
+  1697953104, 344671484, -1489783116, -889507873, 1259591310, -716567168,
+  2116447062, 324368527, 1789366816, 1558930442, 1950250221, -785460151,
+  1174714258, -430047304, -859487565, -580633932, 607732845, -1128150220,
+  1544355315, 1460298016, -1771194297, 1215703690, 277231808, -416020628,
+  -418936577, -1724839216, 404731389, 1058730508, -1508366681, 229883053,
+  -572310243, 1883189553, 931286849, 1659300867, -94236383, -241524462,
+  548020458, -302406981, 579986475, 73468197, -984957614, 1554382245,
+  2084807492, -1456802798, -1105192593, 629440327, -16313961, -2102585261,
+  1873675206, 161035128, 1497033351, 1990150811, -499405222, 304019482,
+  41935663, -805987182, -571699268, 1748462913, 2096239823, -116359807,
+  -1871127553, -1074832534, -1558866192, 231353861, 2122854560, -2102323721,
+  -281462361, -343403210, -673268171, 1776058383, 1581561150, 2059580579,
+  768848632, 1347190372, -1701705879, 245282007, -563267886, -592558289,
+  1662399958, 1390406821, -1522485580, -706446863, 2069516289, -301855859,
+  -778346387, -1454093198, 1249083752, -1760506745, 262193320, 630751125,
+  -1495939124, -29980580, -1989626563, 659039376, -329477132, -1003507166,
+  -1322549020, 358606508, -2052572059, 1848014133, 1826958586, -1004948862,
+  -1775370541, 2134177912, -1739214473, 1892700918, 926629675, -1042761322,
+  2020075900, 606370962, -1256609305, 117577265, -586848924, 191368285,
+  1653535275, -1329269701, -375879127, -1089901406, 1206489978, 534223924,
+  -1042752982, -1178316881, -445594741, -1501682065, -1598136839,
+  -467688289, 750784023, 1781080461, 1729380226, 16906088, 862168532,
+  -2037752683, 1455274138, -1491220107, 1058323960, 1711530558, 1355062750,
+  227640096, 396568027, -173579098, -408975801, -993618329, -1470751562,
+  371076647, 209563718, 2015405719, -723460281, -1423934420, -2089643958,
+  353260489, 2084264341, -792676687, 701391030, -1440658244, 1479321011,
+  1907822880, 1232524257, -256712289, 401077577, 621808069, 868263613,
+  1244930119, 2020996902, 117483907, 1341376744, -1936988014, -445200547,
+  -843751811, -435291191, 1041695743, 476132726, -1226874735, -1436046747,
+  -297047422, 1739645396, 1948680937, -718144374, 1141983978, 1673650568,
+  -197244350, 1604464002, 1424069853, -485626505, 1708710014, -849136541,
+  1573778103, 530360999, 1777767203, 1376958336, -1088364352, 1826167753,
+  742735448, -1386211659, -1991323164, -444115655, -443055378, -1586901006,
+  -1741686587, 1925818034, -2118916824, 803890920, -1481793154, 992278937,
+  1302616410, 444517030, 1393144770, -2025632978, 1902300505, -1683582981,
+  800654133, 873850324, -619580878, -2002070410, -2024936385, 1978986634,
+  2012024264, 675768872, 389435615, -867217540, 231209167, -303917385,
+  1445676969, -1385982721, 1310476490, 580273453, -160600202, -1330895874,
+  487110497, 1124384798, 227637416, -1829783306, 1014818058, -1336870683,
+  -1042199518, -468525587, -1186267363, -472843891, 1215617600, -2056648329,
+  -873216891, 156780951, -1883246047, -842549253, -717684332, 760531638,
+  1074787431, 786267513, 814031289, -561255343, -110302255, -1837376592,
+  989669060, -81350614, 546038730, 222899882, 1298746805, 1791615733,
+  1565630269, 1516024174, 421691479, 1860326051, -1973359550, 1854393443,
+  -1401468528, -158562295, 1509929255, -124024738, -462937489, 259890715,
+  -1515121317, -289511197, -913738664, 698079062, -1631229382, -507275144,
+  1897739663, -1118192766, -1687033399, 61405556, -1913606579, -473308896,
+  -259107170, -576944609, -1689355510, 322156799, 545090192, 127425176,
+  -1815211748, -2070235628, -1172529316, 599259550, -910906653, 1797380363,
+  -938649427, 142991392, 504559631, 1208867355, -807699247, -616021271,
+  -254935281, -57151221, -1095534993, 1998380318, 1772459584, 713271407,
+  -1197898266, 808881935, -308133481, -1314455137, 284321772, -743117625,
+  -1622364240, -1667535152, 118713606, 1053615347, -2072876023, -178189072,
+  -828319551, 2047304928, -1311435786, -1970672907, -747972100, 86806159,
+  -436088421, 1464645587, 735840899, 32600466, -190473426, -735703440,
+  482872155, 475662392, -713681085, 1424078728, -150668609, -1137197868,
+  -1682762563, -48035649, 1143959866, -1542015129, 284920371, -1587695586,
+  -625236551, -753893357, -433976266, -1329796037, -1636712478, 1686783454,
+  27839146, 1748631474, -879528256, 2057796026, 773734654, 112269667,
+  -2011541314, 1517797297, -1943171794, 268166111, -1037010413, -1945824504,
+  -1672323792, 306260758, -692968628, -701704965, -462980996, 939188824,
+  553289792, 1790245000, 2093793129, -658085781, -186055037, -2130433650,
+  -1013235433, 1190870089, -2126586963, -1509655742, -1291895256,
+  -1427857845, 309538950, 388316741, 259659733, -1895092434, 110126220,
+  -170175575, -419430224, -696234084, -832170948, -353431720, -797675726,
+  -1644136054, 715163272, -1305904349, -145786463, -99586244, -695450446,
+  -871327102, -725496060, 952863853, -688441983, -1729929460, -103732092,
+  1059054528, 568873585, -982665223, -128672783, 2099418320, 1508239336,
+  -2089480835, -390935727, 664306522, -1607364342, -163246802, -1121295140,
+  -128375779, -615694409, -2079391797, 760542037, 677761593, -750117849,
+  -1060525080, 2128437080, 525250908, 1987657172, 2032530557, -2011247936,
+  1942775263, 1681562788, 688229491, -803856505, 684707948, 1308988965,
+  1455480037, 790659611, 1557968784, -383203149, -361510986, -742575828,
+  558837193, -1214977424, 1253274105, -119513513, -993964385, -33438767,
+  -177452803, 1186928041, -2073533871, 1188528559, 1896514695, 1200128512,
+  1930588755, -1914141443, 1534656032, -1192989829, -1848274656, -220848455,
+  1001806509, 1298797392, 1533031884, -1912322446, 1705583815, 1568094347,
+  -1397640627, 807828512, -1852996497, -1529733505, -1575634185,
+  -1280270160, -1567624159, -1861904922, 1276738579, 1163432999, 626879833,
+  316942006, -1871138342, 1341039701, 1595907877, 1950911580, 1634717748,
+  1071476055, -809354290, -1161553341, -2081621710, -2085557943, 19360224,
+  322135580, -698485151, 1267663094, -233890834, -126361189, -1426257522,
+  1094007921, 500179855, -283548002, -1678987343, 1946999943, 1489410849,
+  2089571262, 1430799093, 1961848046, -99462663, -552833264, 1168700661,
+  -1783882181, 2089196401, 1092839657, 914488673, 80263859, -2140947098,
+  -726384741, -1022448237, 2113887675, 1485770846, -112922517, 1995461466,
+  774613726, 944068011, 1521975359, 289086919, -386920759, -1960513175,
+  358460021, -238698524, -1913640563, -1000324864, 1731755224, -1271586254,
+  -1917469655, 2134162829, -828097534, -1089292503, -1514835999, 1682931514,
+  -482307169, 2110243841, 115744834, -2038340170, 65889188, -539445712,
+  -1713206408, -1842396726, -1659545588, -909558923, 860164922, 1328713040,
+  1044007120, -2103807103, -1073990344, -1312783785, -884980824, -705318011,
+  -1263408788, -2032228692, -1732844111, -1813827156, 1462566279,
+  1179250845, 1732421772, 604429013, -92284336, -1192166516, 304654351,
+  1998552034, -1802461575, -1802704071, -1704833934, -976264396, 1005840702,
+  2108843914, 1363909309, 843040834, -1039625241, 1285007226, 91610001,
+  418426329, 678422358, -945360697, -440008081, -1053091357, 425719777,
+  -1372778676, 591912153, 1229089037, -56663158, 2140251400, 830257037,
+  763914157, 175610373, -2105655963, -1040826150, 1174443038, 339290593,
+  346618443, -180504100, -1363190515, 210620018, 1028894425, 573529714,
+  698460117, 136999397, 1015621712, -1401813739, -297990684, -1820934845,
+  -1299093313, 1299361369, -366522415, 91527707, 1113466178, -956229484,
+  22204763, -1394374195, -1912666711, -1453789804, 1613408399, -169509567,
+  1350520309, 540761213, -2086682848, 1095131491, -812787911, 1860108594,
+  -1121378737, -1667252487, -486084366, 166519760, 1609891237, 728218405,
+  291075010, 646168382, 108462277, -1616661910, 1016600360, 2099958568,
+  27934736, 183821196, 13660496, -805589719, 936068730, -439037934,
+  1414622584, 215845485, -1352304469, -1817427526, -1318710977, -110207199,
+  228524335, 1704746590, 998293651, -1521016702, -641956531, -2089808167,
+  2094404052, -1446381065, -662186492, 1670154584, 9637833, 493925511,
+  660047318, 1197537103, 1696017374, -204994399, -1104145601, -852330465,
+  -1936369658, -829716674, -1255255217, 1264013799, 1642611772, -652520861,
+  777247164, 2028895987, -1424241853, -54367829, -1940161761, -1802831079,
+  -449405299, 838242661, -323055438, 794295411, -136989378, -446686673,
+  -421252799, -16777216,
+};
+
+int
+main (int argc, char *argv[])
+{
+  char buf[1024];
+  int i;
+
+  GNUNET_log_setup ("test-crypto-crc", "WARNING", NULL);
+  for (i = 0; i < 1024; i++)
+    buf[i] = (char) i;
+  for (i = 0; i < 1024; i++)
+    if (expected[i] != GNUNET_CRYPTO_crc32_n (&buf[i], 1024 - i))
+      return 1;
+  return 0;
+}
diff --git a/src/util/test_crypto_hash.c b/src/util/test_crypto_hash.c
new file mode 100644
index 000000000..a22a0e16a
--- /dev/null
+++ b/src/util/test_crypto_hash.c
@@ -0,0 +1,165 @@
+/*
+     This file is part of GNUnet.
+     (C) 2002, 2003, 2004, 2006, 2009 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.
+*/
+
+/**
+ * @author Christian Grothoff
+ * @file util/test_crypto_hash.c
+ * @brief Test for crypto_hash.c
+ */
+#include "platform.h"
+#include "gnunet_common.h"
+#include "gnunet_crypto_lib.h"
+#include "gnunet_scheduler_lib.h"
+
+static char block[65536];
+
+#define FILENAME "testblock.dat"
+
+static int
+test (int number)
+{
+  GNUNET_HashCode h1;
+  GNUNET_HashCode h2;
+  struct GNUNET_CRYPTO_HashAsciiEncoded enc;
+
+  memset (&h1, number, sizeof (GNUNET_HashCode));
+  GNUNET_CRYPTO_hash_to_enc (&h1, &enc);
+  if (GNUNET_OK != GNUNET_CRYPTO_hash_from_string ((char *) &enc, &h2))
+    {
+      printf ("enc2hash failed!\n");
+      return 1;
+    }
+  if (0 != memcmp (&h1, &h2, sizeof (GNUNET_HashCode)))
+    return 1;
+  return 0;
+}
+
+static int
+testEncoding ()
+{
+  int i;
+  for (i = 0; i < 255; i++)
+    if (0 != test (i))
+      return 1;
+  return 0;
+}
+
+static int
+testArithmetic ()
+{
+  static struct GNUNET_CRYPTO_AesSessionKey zskey;
+  static struct GNUNET_CRYPTO_AesInitializationVector ziv;
+  GNUNET_HashCode h1;
+  GNUNET_HashCode h2;
+  GNUNET_HashCode d;
+  GNUNET_HashCode s;
+  struct GNUNET_CRYPTO_AesSessionKey skey;
+  struct GNUNET_CRYPTO_AesInitializationVector iv;
+
+  GNUNET_CRYPTO_hash_create_random (&h1);
+  GNUNET_CRYPTO_hash_create_random (&h2);
+  if (GNUNET_CRYPTO_hash_distance_u32 (&h1, &h2) !=
+      GNUNET_CRYPTO_hash_distance_u32 (&h2, &h1))
+    return 1;
+  GNUNET_CRYPTO_hash_difference (&h1, &h2, &d);
+  GNUNET_CRYPTO_hash_sum (&h1, &d, &s);
+  if (0 != GNUNET_CRYPTO_hash_cmp (&s, &h2))
+    return 1;
+  GNUNET_CRYPTO_hash_xor (&h1, &h2, &d);
+  GNUNET_CRYPTO_hash_xor (&h1, &d, &s);
+  if (0 != GNUNET_CRYPTO_hash_cmp (&s, &h2))
+    return 1;
+  if (0 != GNUNET_CRYPTO_hash_xorcmp (&s, &h2, &h1))
+    return 1;
+  if (-1 != GNUNET_CRYPTO_hash_xorcmp (&h1, &h2, &h1))
+    return 1;
+  if (1 != GNUNET_CRYPTO_hash_xorcmp (&h1, &h2, &h2))
+    return 1;
+  memset (&d, 0xF0, sizeof (d));
+  if (0 != GNUNET_CRYPTO_hash_get_bit (&d, 3))
+    return 1;
+  if (1 != GNUNET_CRYPTO_hash_get_bit (&d, 6))
+    return 1;
+  memset (&d, 0, sizeof (d));
+  GNUNET_CRYPTO_hash_to_AES_key (&d, &skey, &iv);
+  if ((0 != memcmp (&skey, &zskey, sizeof (skey) - sizeof (unsigned int))) ||
+      (0 != memcmp (&iv, &ziv, sizeof (iv))))
+    return 1;
+  return 0;
+}
+
+static void
+finished_task (void *cls, const GNUNET_HashCode * res)
+{
+  int *ret = cls;
+  GNUNET_HashCode want;
+
+  GNUNET_CRYPTO_hash (block, sizeof (block), &want);
+  if (0 != memcmp (res, &want, sizeof (want)))
+    *ret = 2;
+  else
+    *ret = 0;
+}
+
+
+static void
+file_hasher (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+{
+  GNUNET_CRYPTO_hash_file (tc->sched,
+                           GNUNET_SCHEDULER_PRIORITY_DEFAULT,
+                           GNUNET_NO, FILENAME, 1024, &finished_task, cls);
+}
+
+
+static int
+testFileHash ()
+{
+  int ret;
+  FILE *f;
+
+  memset (block, 42, sizeof (block) / 2);
+  memset (&block[sizeof (block) / 2], 43, sizeof (block) / 2);
+  GNUNET_assert (NULL != (f = fopen (FILENAME, "w+")));
+  GNUNET_break (sizeof (block) == fwrite (block, 1, sizeof (block), f));
+  GNUNET_break (0 == fclose (f));
+  ret = 1;
+  GNUNET_SCHEDULER_run (&file_hasher, &ret);
+  GNUNET_break (0 == UNLINK (FILENAME));
+  return ret;
+}
+
+
+int
+main (int argc, char *argv[])
+{
+  int failureCount = 0;
+  int i;
+
+  GNUNET_log_setup ("test-crypto-hash", "WARNING", NULL);
+  for (i = 0; i < 10; i++)
+    failureCount += testEncoding ();
+  failureCount += testArithmetic ();
+  failureCount += testFileHash ();
+  if (failureCount != 0)
+    return 1;
+  return 0;
+}
+
+/* end of hashingtest.c */
diff --git a/src/util/test_crypto_ksk.c b/src/util/test_crypto_ksk.c
new file mode 100644
index 000000000..c8555b5de
--- /dev/null
+++ b/src/util/test_crypto_ksk.c
@@ -0,0 +1,220 @@
+/*
+     This file is part of GNUnet.
+     Copyright (C) 2004, 2005, 2006 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 util/test_crypto_ksk.c
+ * @brief testcase for util/crypto_ksk.c
+ * @author Christian Grothoff
+ */
+#include "platform.h"
+#include "gnunet_common.h"
+#include "gnunet_crypto_lib.h"
+#include "gnunet_signatures.h"
+#include "gnunet_time_lib.h"
+
+#define TESTSTRING "Hello World\0"
+#define MAX_TESTVAL 20
+#define UNIQUE_ITER 6
+#define ITER 25
+
+
+static int
+testMultiKey (const char *word)
+{
+  GNUNET_HashCode in;
+  struct GNUNET_CRYPTO_RsaPrivateKey *hostkey;
+  struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded pkey;
+  struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded pkey1;
+  int i;
+
+  fprintf (stderr, "Testing KBlock key uniqueness (%s) ", word);
+  GNUNET_CRYPTO_hash (word, strlen (word), &in);
+  hostkey = GNUNET_CRYPTO_rsa_key_create_from_hash (&in);
+  if (hostkey == NULL)
+    {
+      GNUNET_break (0);
+      return GNUNET_SYSERR;
+    }
+  GNUNET_CRYPTO_rsa_key_get_public (hostkey, &pkey);
+  /*
+     for (i=0;i<sizeof(struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded);i++)
+     printf("%02x", ((unsigned char*) &pkey)[i]);
+     printf("\n"); */
+  GNUNET_CRYPTO_rsa_key_free (hostkey);
+  for (i = 0; i < UNIQUE_ITER; i++)
+    {
+      fprintf (stderr, ".");
+      hostkey = GNUNET_CRYPTO_rsa_key_create_from_hash (&in);
+      if (hostkey == NULL)
+        {
+          GNUNET_break (0);
+          fprintf (stderr, " ERROR\n");
+          return GNUNET_SYSERR;
+        }
+      GNUNET_CRYPTO_rsa_key_get_public (hostkey, &pkey1);
+      GNUNET_CRYPTO_rsa_key_free (hostkey);
+      if (0 !=
+          memcmp (&pkey, &pkey1,
+                  sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded)))
+        {
+          GNUNET_break (0);
+          fprintf (stderr, " ERROR\n");
+          return GNUNET_SYSERR;
+        }
+    }
+  fprintf (stderr, " OK\n");
+  return GNUNET_OK;
+}
+
+
+static int
+testEncryptDecrypt (struct GNUNET_CRYPTO_RsaPrivateKey *hostkey)
+{
+  struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded pkey;
+  struct GNUNET_CRYPTO_RsaEncryptedData target;
+  char result[MAX_TESTVAL];
+  int i;
+  struct GNUNET_TIME_Absolute start;
+  int ok;
+
+  fprintf (stderr, "W");
+  GNUNET_CRYPTO_rsa_key_get_public (hostkey, &pkey);
+
+  ok = 0;
+  start = GNUNET_TIME_absolute_get ();
+  for (i = 0; i < ITER; i++)
+    {
+      fprintf (stderr, ".");
+      if (GNUNET_SYSERR == GNUNET_CRYPTO_rsa_encrypt (TESTSTRING,
+                                                      strlen (TESTSTRING) + 1,
+                                                      &pkey, &target))
+        {
+          fprintf (stderr, "GNUNET_CRYPTO_rsa_encrypt returned SYSERR\n");
+          ok++;
+          continue;
+        }
+      if (-1 == GNUNET_CRYPTO_rsa_decrypt (hostkey,
+                                           &target, result,
+                                           strlen (TESTSTRING) + 1))
+        {
+          fprintf (stderr, "GNUNET_CRYPTO_rsa_decrypt returned SYSERR\n");
+          ok++;
+          continue;
+        }
+      if (strncmp (TESTSTRING, result, strlen (TESTSTRING)) != 0)
+        {
+          printf ("%s != %.*s - testEncryptDecrypt failed!\n",
+                  TESTSTRING, MAX_TESTVAL, result);
+          ok++;
+          continue;
+        }
+    }
+  printf ("%d RSA encrypt/decrypt operations %llums (%d failures)\n",
+          ITER,
+          (unsigned long long) GNUNET_TIME_absolute_get_duration (start).
+          value, ok);
+  if (ok == 0)
+    return GNUNET_OK;
+  else
+    return GNUNET_SYSERR;
+}
+
+static int
+testSignVerify (struct GNUNET_CRYPTO_RsaPrivateKey *hostkey)
+{
+  struct GNUNET_CRYPTO_RsaSignature sig;
+  struct GNUNET_CRYPTO_RsaSignaturePurpose purp;
+  struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded pkey;
+  int i;
+  struct GNUNET_TIME_Absolute start;
+  int ok = GNUNET_OK;
+
+  fprintf (stderr, "W");
+  GNUNET_CRYPTO_rsa_key_get_public (hostkey, &pkey);
+  start = GNUNET_TIME_absolute_get ();
+  purp.size = htonl (sizeof (struct GNUNET_CRYPTO_RsaSignaturePurpose));
+  purp.purpose = htonl (GNUNET_SIGNATURE_PURPOSE_TEST);
+  for (i = 0; i < ITER; i++)
+    {
+      fprintf (stderr, ".");
+      if (GNUNET_SYSERR == GNUNET_CRYPTO_rsa_sign (hostkey, &purp, &sig))
+        {
+          fprintf (stderr, "GNUNET_CRYPTO_rsa_sign returned SYSERR\n");
+          ok = GNUNET_SYSERR;
+          continue;
+        }
+      if (GNUNET_SYSERR ==
+          GNUNET_CRYPTO_rsa_verify (GNUNET_SIGNATURE_PURPOSE_TEST,
+                                    &purp, &sig, &pkey))
+        {
+          printf ("GNUNET_CRYPTO_rsa_verify failed!\n");
+          ok = GNUNET_SYSERR;
+          continue;
+        }
+      if (GNUNET_SYSERR !=
+          GNUNET_CRYPTO_rsa_verify (GNUNET_SIGNATURE_PURPOSE_TRANSPORT_HELLO,
+                                    &purp, &sig, &pkey))
+        {
+          printf ("GNUNET_CRYPTO_rsa_verify failed to fail!\n");
+          ok = GNUNET_SYSERR;
+          continue;
+        }
+    }
+  printf ("%d RSA sign/verify operations %llums\n",
+          ITER,
+          (unsigned long long) GNUNET_TIME_absolute_get_duration (start).
+          value);
+  return ok;
+}
+
+
+int
+main (int argc, char *argv[])
+{
+  int failureCount = 0;
+  GNUNET_HashCode in;
+  struct GNUNET_CRYPTO_RsaPrivateKey *hostkey;
+
+  GNUNET_log_setup ("test-crypto-ksk", "WARNING", NULL);
+  GNUNET_CRYPTO_hash_create_random (&in);
+  hostkey = GNUNET_CRYPTO_rsa_key_create_from_hash (&in);
+  if (hostkey == NULL)
+    {
+      printf ("\nGNUNET_CRYPTO_rsa_key_create_from_hash failed!\n");
+      return 1;
+    }
+
+  if (GNUNET_OK != testMultiKey ("foo"))
+    failureCount++;
+  if (GNUNET_OK != testMultiKey ("bar"))
+    failureCount++;
+  if (GNUNET_OK != testEncryptDecrypt (hostkey))
+    failureCount++;
+  if (GNUNET_OK != testSignVerify (hostkey))
+    failureCount++;
+  GNUNET_CRYPTO_rsa_key_free (hostkey);
+
+  if (failureCount != 0)
+    {
+      printf ("\n\n%d TESTS FAILED!\n\n", failureCount);
+      return -1;
+    }
+  return 0;
+}
diff --git a/src/util/test_crypto_random.c b/src/util/test_crypto_random.c
new file mode 100644
index 000000000..e237c14a4
--- /dev/null
+++ b/src/util/test_crypto_random.c
@@ -0,0 +1,71 @@
+/*
+     This file is part of GNUnet.
+     (C) 2009 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 util/test_crypto_random.c
+ * @brief testcase for crypto_random.c
+ */
+#include "platform.h"
+#include "gnunet_common.h"
+#include "gnunet_crypto_lib.h"
+
+static int
+test (enum GNUNET_CRYPTO_Quality mode)
+{
+
+  int buf[1024];
+  unsigned int *b2;
+  int i;
+  unsigned long long n;
+
+  for (i = 0; i < 1024; i++)
+    GNUNET_break (1024 > (buf[i] = GNUNET_CRYPTO_random_u32 (mode, 1024)));
+  for (i = 0; i < 10; i++)
+    {
+      b2 = GNUNET_CRYPTO_random_permute (mode, 1024);
+      if (0 == memcmp (b2, buf, sizeof (buf)))
+        {
+          fprintf (stderr, "!");
+          GNUNET_free (b2);
+          continue;
+        }
+      GNUNET_free (b2);
+      break;
+    }
+  if (i == 10)
+    return 1;                   /* virtually impossible... */
+
+  for (n = 10; n < 1024LL * 1024LL * 1024LL; n *= 10)
+    GNUNET_break (n > GNUNET_CRYPTO_random_u64 (mode, n));
+  return 0;
+}
+
+int
+main (int argc, char *argv[])
+{
+  GNUNET_log_setup ("test-crypto-random", "WARNING", NULL);
+  if (0 != test (GNUNET_CRYPTO_QUALITY_WEAK))
+    return 1;
+  if (0 != test (GNUNET_CRYPTO_QUALITY_STRONG))
+    return 1;
+
+  return 0;
+}
diff --git a/src/util/test_crypto_rsa.c b/src/util/test_crypto_rsa.c
new file mode 100644
index 000000000..e71decca8
--- /dev/null
+++ b/src/util/test_crypto_rsa.c
@@ -0,0 +1,335 @@
+/*
+     This file is part of GNUnet.
+     (C) 2002, 2003, 2004, 2006, 2009 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 util/test_crypto_rsa.c
+ * @brief testcase for RSA public key crypto
+ * @author Christian Grothoff
+ */
+#include "platform.h"
+#include "gnunet_common.h"
+#include "gnunet_crypto_lib.h"
+#include "gnunet_signatures.h"
+#include "gnunet_time_lib.h"
+
+#define TESTSTRING "Hello World\0"
+#define MAX_TESTVAL sizeof(struct GNUNET_CRYPTO_AesSessionKey)
+#define ITER 25
+#define KEYFILE "/tmp/test-gnunet-crypto-rsa.key"
+
+#define PERF GNUNET_YES
+
+static int
+testEncryptDecrypt ()
+{
+  struct GNUNET_CRYPTO_RsaPrivateKey *hostkey;
+  struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded pkey;
+  struct GNUNET_CRYPTO_RsaEncryptedData target;
+  char result[MAX_TESTVAL];
+  int i;
+  struct GNUNET_TIME_Absolute start;
+  int ok;
+
+  fprintf (stderr, "W");
+  hostkey = GNUNET_CRYPTO_rsa_key_create ();
+  GNUNET_CRYPTO_rsa_key_get_public (hostkey, &pkey);
+
+  ok = 0;
+  start = GNUNET_TIME_absolute_get ();
+  for (i = 0; i < ITER; i++)
+    {
+      fprintf (stderr, ".");
+      if (GNUNET_SYSERR == GNUNET_CRYPTO_rsa_encrypt (TESTSTRING,
+                                                      strlen (TESTSTRING) + 1,
+                                                      &pkey, &target))
+        {
+          fprintf (stderr, "GNUNET_CRYPTO_rsa_encrypt returned SYSERR\n");
+          ok++;
+          continue;
+        }
+      if (-1 == GNUNET_CRYPTO_rsa_decrypt (hostkey,
+                                           &target, result,
+                                           strlen (TESTSTRING) + 1))
+        {
+          fprintf (stderr, "GNUNET_CRYPTO_rsa_decrypt returned SYSERR\n");
+          ok++;
+          continue;
+
+        }
+      if (strncmp (TESTSTRING, result, strlen (TESTSTRING)) != 0)
+        {
+          printf ("%s != %.*s - testEncryptDecrypt failed!\n",
+                  TESTSTRING, MAX_TESTVAL, result);
+          ok++;
+          continue;
+        }
+    }
+  printf ("%d RSA encrypt/decrypt operations %llums (%d failures)\n",
+          ITER,
+          (unsigned long long) GNUNET_TIME_absolute_get_duration (start).
+          value, ok);
+  GNUNET_CRYPTO_rsa_key_free (hostkey);
+  if (ok == 0)
+    return GNUNET_OK;
+  else
+    return GNUNET_SYSERR;
+}
+
+#if PERF
+static int
+testEncryptPerformance ()
+{
+  struct GNUNET_CRYPTO_RsaPrivateKey *hostkey;
+  struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded pkey;
+  struct GNUNET_CRYPTO_RsaEncryptedData target;
+  int i;
+  struct GNUNET_TIME_Absolute start;
+  int ok;
+
+  fprintf (stderr, "W");
+  hostkey = GNUNET_CRYPTO_rsa_key_create ();
+  GNUNET_CRYPTO_rsa_key_get_public (hostkey, &pkey);
+
+  ok = 0;
+  start = GNUNET_TIME_absolute_get ();
+  for (i = 0; i < ITER; i++)
+    {
+      fprintf (stderr, ".");
+      if (GNUNET_SYSERR == GNUNET_CRYPTO_rsa_encrypt (TESTSTRING,
+                                                      strlen (TESTSTRING) + 1,
+                                                      &pkey, &target))
+        {
+          fprintf (stderr, "GNUNET_CRYPTO_rsa_encrypt returned SYSERR\n");
+          ok++;
+          continue;
+        }
+    }
+  printf ("%d RSA encrypt operations %llu ms (%d failures)\n",
+          ITER,
+          (unsigned long long) GNUNET_TIME_absolute_get_duration (start).
+          value, ok);
+  GNUNET_CRYPTO_rsa_key_free (hostkey);
+  if (ok != 0)
+    return GNUNET_SYSERR;
+  return GNUNET_OK;
+}
+#endif
+
+static int
+testEncryptDecryptSK ()
+{
+  struct GNUNET_CRYPTO_RsaPrivateKey *hostkey;
+  struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded pkey;
+  struct GNUNET_CRYPTO_RsaEncryptedData target;
+  struct GNUNET_CRYPTO_AesSessionKey insk;
+  struct GNUNET_CRYPTO_AesSessionKey outsk;
+  int i;
+  struct GNUNET_TIME_Absolute start;
+  int ok;
+
+  fprintf (stderr, "W");
+  hostkey = GNUNET_CRYPTO_rsa_key_create ();
+  GNUNET_CRYPTO_rsa_key_get_public (hostkey, &pkey);
+
+  ok = 0;
+  start = GNUNET_TIME_absolute_get ();
+  for (i = 0; i < ITER; i++)
+    {
+      fprintf (stderr, ".");
+      GNUNET_CRYPTO_aes_create_session_key (&insk);
+      if (GNUNET_SYSERR == GNUNET_CRYPTO_rsa_encrypt (&insk,
+                                                      sizeof (struct
+                                                              GNUNET_CRYPTO_AesSessionKey),
+                                                      &pkey, &target))
+        {
+          fprintf (stderr, "GNUNET_CRYPTO_rsa_encrypt returned SYSERR\n");
+          ok++;
+          continue;
+        }
+      if (-1 == GNUNET_CRYPTO_rsa_decrypt (hostkey,
+                                           &target, &outsk,
+                                           sizeof (struct
+                                                   GNUNET_CRYPTO_AesSessionKey)))
+        {
+          fprintf (stderr, "GNUNET_CRYPTO_rsa_decrypt returned SYSERR\n");
+          ok++;
+          continue;
+        }
+      if (0 !=
+          memcmp (&insk, &outsk, sizeof (struct GNUNET_CRYPTO_AesSessionKey)))
+        {
+          printf ("testEncryptDecryptSK failed!\n");
+          ok++;
+          continue;
+        }
+    }
+  printf ("%d RSA encrypt/decrypt SK operations %llus (%d failures)\n",
+          ITER,
+          (unsigned long long) GNUNET_TIME_absolute_get_duration (start).
+          value, ok);
+  GNUNET_CRYPTO_rsa_key_free (hostkey);
+  if (ok != 0)
+    return GNUNET_SYSERR;
+  return GNUNET_OK;
+}
+
+
+static int
+testSignVerify ()
+{
+  struct GNUNET_CRYPTO_RsaPrivateKey *hostkey;
+  struct GNUNET_CRYPTO_RsaSignature sig;
+  struct GNUNET_CRYPTO_RsaSignaturePurpose purp;
+  struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded pkey;
+  int i;
+  struct GNUNET_TIME_Absolute start;
+  int ok = GNUNET_OK;
+
+  fprintf (stderr, "W");
+  hostkey = GNUNET_CRYPTO_rsa_key_create ();
+  GNUNET_CRYPTO_rsa_key_get_public (hostkey, &pkey);
+  start = GNUNET_TIME_absolute_get ();
+  purp.size = htonl (sizeof (struct GNUNET_CRYPTO_RsaSignaturePurpose));
+  purp.purpose = htonl (GNUNET_SIGNATURE_PURPOSE_TEST);
+
+  for (i = 0; i < ITER; i++)
+    {
+      fprintf (stderr, ".");
+      if (GNUNET_SYSERR == GNUNET_CRYPTO_rsa_sign (hostkey, &purp, &sig))
+        {
+          fprintf (stderr, "GNUNET_CRYPTO_rsa_sign returned SYSERR\n");
+          ok = GNUNET_SYSERR;
+          continue;
+        }
+      if (GNUNET_SYSERR ==
+          GNUNET_CRYPTO_rsa_verify (GNUNET_SIGNATURE_PURPOSE_TEST,
+                                    &purp, &sig, &pkey))
+        {
+          printf ("GNUNET_CRYPTO_rsa_verify failed!\n");
+          ok = GNUNET_SYSERR;
+          continue;
+        }
+      if (GNUNET_SYSERR !=
+          GNUNET_CRYPTO_rsa_verify (GNUNET_SIGNATURE_PURPOSE_TRANSPORT_HELLO,
+                                    &purp, &sig, &pkey))
+        {
+          printf ("GNUNET_CRYPTO_rsa_verify failed to fail!\n");
+          ok = GNUNET_SYSERR;
+          continue;
+        }
+    }
+  printf ("%d RSA sign/verify operations %llums\n",
+          ITER,
+          (unsigned long long) GNUNET_TIME_absolute_get_duration (start).
+          value);
+  GNUNET_CRYPTO_rsa_key_free (hostkey);
+  return ok;
+}
+
+
+#if PERF
+static int
+testSignPerformance ()
+{
+  struct GNUNET_CRYPTO_RsaPrivateKey *hostkey;
+  struct GNUNET_CRYPTO_RsaSignaturePurpose purp;
+  struct GNUNET_CRYPTO_RsaSignature sig;
+  struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded pkey;
+  int i;
+  struct GNUNET_TIME_Absolute start;
+  int ok = GNUNET_OK;
+
+  purp.size = htonl (sizeof (struct GNUNET_CRYPTO_RsaSignaturePurpose));
+  purp.purpose = htonl (GNUNET_SIGNATURE_PURPOSE_TEST);
+  fprintf (stderr, "W");
+  hostkey = GNUNET_CRYPTO_rsa_key_create ();
+  GNUNET_CRYPTO_rsa_key_get_public (hostkey, &pkey);
+  start = GNUNET_TIME_absolute_get ();
+  for (i = 0; i < ITER; i++)
+    {
+      fprintf (stderr, ".");
+      if (GNUNET_SYSERR == GNUNET_CRYPTO_rsa_sign (hostkey, &purp, &sig))
+        {
+          fprintf (stderr, "GNUNET_CRYPTO_rsa_sign returned SYSERR\n");
+          ok = GNUNET_SYSERR;
+          continue;
+        }
+    }
+  printf ("%d RSA sign operations %llu ms\n", ITER,
+          GNUNET_TIME_absolute_get_duration (start).value);
+  GNUNET_CRYPTO_rsa_key_free (hostkey);
+  return ok;
+}
+#endif
+
+
+static int
+testCreateFromFile ()
+{
+  struct GNUNET_CRYPTO_RsaPrivateKey *key;
+  struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded p1;
+  struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded p2;
+
+  key = GNUNET_CRYPTO_rsa_key_create_from_file (KEYFILE);
+  GNUNET_CRYPTO_rsa_key_get_public (key, &p1);
+  GNUNET_CRYPTO_rsa_key_free (key);
+  key = GNUNET_CRYPTO_rsa_key_create_from_file (KEYFILE);
+  GNUNET_CRYPTO_rsa_key_get_public (key, &p2);
+  GNUNET_assert (0 == memcmp (&p1, &p2, sizeof (p1)));
+  GNUNET_CRYPTO_rsa_key_free (key);
+  GNUNET_assert (0 == UNLINK (KEYFILE));
+  key = GNUNET_CRYPTO_rsa_key_create_from_file (KEYFILE);
+  GNUNET_CRYPTO_rsa_key_get_public (key, &p2);
+  GNUNET_assert (0 != memcmp (&p1, &p2, sizeof (p1)));
+  GNUNET_CRYPTO_rsa_key_free (key);
+  GNUNET_assert (0 == UNLINK (KEYFILE));
+  return GNUNET_OK;
+}
+
+
+int
+main (int argc, char *argv[])
+{
+  int failureCount = 0;
+
+  GNUNET_log_setup ("test-crypto-rsa", "WARNING", NULL);
+  GNUNET_CRYPTO_random_disable_entropy_gathering ();
+  if (GNUNET_OK != testCreateFromFile ())
+    failureCount++;
+#if PERF
+  if (GNUNET_OK != testEncryptPerformance ())
+    failureCount++;
+  if (GNUNET_OK != testSignPerformance ())
+    failureCount++;
+#endif
+  if (GNUNET_OK != testEncryptDecryptSK ())
+    failureCount++;
+  if (GNUNET_OK != testEncryptDecrypt ())
+    failureCount++;
+  if (GNUNET_OK != testSignVerify ())
+    failureCount++;
+
+  if (failureCount != 0)
+    {
+      printf ("\n\n%d TESTS FAILED!\n\n", failureCount);
+      return -1;
+    }
+  return 0;
+}                               /* end of main */
diff --git a/src/util/test_disk.c b/src/util/test_disk.c
new file mode 100644
index 000000000..0d385afa7
--- /dev/null
+++ b/src/util/test_disk.c
@@ -0,0 +1,274 @@
+/*
+     This file is part of GNUnet.
+     (C) 2001, 2002, 2003, 2005, 2006 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 util/test_disk.c
+ * @brief testcase for the storage module
+ * @author Christian Grothoff
+ */
+#include "platform.h"
+#include "gnunet_common.h"
+#include "gnunet_disk_lib.h"
+#include "gnunet_scheduler_lib.h"
+
+#define TESTSTRING "Hello World\0"
+
+static int
+testReadWrite ()
+{
+  char tmp[100 + 1];
+  int ret;
+
+  if (GNUNET_OK !=
+      GNUNET_DISK_file_write (".testfile", TESTSTRING, strlen (TESTSTRING),
+                              "644"))
+    return 1;
+  if (GNUNET_OK != GNUNET_DISK_file_test (".testfile"))
+    return 1;
+  ret = GNUNET_DISK_file_read (".testfile", sizeof (tmp) - 1, tmp);
+  if (ret < 0)
+    {
+      fprintf (stderr,
+               "Error reading file `%s' in testReadWrite\n", ".testfile");
+      return 1;
+    }
+  tmp[ret] = '\0';
+  if (0 != memcmp (tmp, TESTSTRING, strlen (TESTSTRING) + 1))
+    {
+      fprintf (stderr,
+               "Error in testReadWrite: *%s* != *%s* for file %s\n",
+               tmp, TESTSTRING, ".testfile");
+      return 1;
+    }
+  GNUNET_DISK_file_copy (".testfile", ".testfile2");
+  memset (tmp, 0, sizeof (tmp));
+  ret = GNUNET_DISK_file_read (".testfile2", sizeof (tmp) - 1, tmp);
+  if (ret < 0)
+    {
+      fprintf (stderr,
+               "Error reading file `%s' in testReadWrite\n", ".testfile2");
+      return 1;
+    }
+  tmp[ret] = '\0';
+  if (0 != memcmp (tmp, TESTSTRING, strlen (TESTSTRING) + 1))
+    {
+      fprintf (stderr,
+               "Error in testReadWrite: *%s* != *%s* for file %s\n",
+               tmp, TESTSTRING, ".testfile2");
+      return 1;
+    }
+
+  GNUNET_break (0 == UNLINK (".testfile"));
+  GNUNET_break (0 == UNLINK (".testfile2"));
+  if (GNUNET_NO != GNUNET_DISK_file_test (".testfile"))
+    return 1;
+
+  return 0;
+}
+
+static int
+testOpenClose ()
+{
+  int fd;
+  unsigned long long size;
+  long avail;
+
+  fd = GNUNET_DISK_file_open (".testfile",
+                              O_RDWR | O_CREAT, S_IWUSR | S_IRUSR);
+  GNUNET_assert (-1 != fd);
+  GNUNET_break (5 == WRITE (fd, "Hello", 5));
+  GNUNET_DISK_file_close (".testfile", fd);
+  GNUNET_break (GNUNET_OK ==
+                GNUNET_DISK_file_size (".testfile", &size, GNUNET_NO));
+  if (size != 5)
+    return 1;
+  GNUNET_break (0 == UNLINK (".testfile"));
+
+  /* test that avail goes down as we fill the disk... */
+  GNUNET_log_skip (1);
+  avail = GNUNET_DISK_get_blocks_available (".testfile");
+  GNUNET_log_skip (0);
+  fd = GNUNET_DISK_file_open (".testfile",
+                              O_RDWR | O_CREAT, S_IWUSR | S_IRUSR);
+  GNUNET_assert (-1 != fd);
+  while ((avail == GNUNET_DISK_get_blocks_available (".testfile")) &&
+         (avail != -1))
+    if (16 != WRITE (fd, "HelloWorld123456", 16))
+      {
+        GNUNET_DISK_file_close (".testfile", fd);
+        GNUNET_break (0 == UNLINK (".testfile"));
+        return 1;
+      }
+  GNUNET_DISK_file_close (".testfile", fd);
+  GNUNET_break (0 == UNLINK (".testfile"));
+
+  return 0;
+}
+
+static int ok;
+
+static int
+scan_callback (void *want, const char *filename)
+{
+  if (NULL != strstr (filename, want))
+    ok++;
+  return GNUNET_OK;
+}
+
+static int
+testDirScan ()
+{
+  if (GNUNET_OK != GNUNET_DISK_directory_create ("test/entry"))
+    return 1;
+  if (GNUNET_OK != GNUNET_DISK_directory_create ("test/entry_more"))
+    return 1;
+  GNUNET_DISK_directory_scan ("test", &scan_callback, "test/entry");
+  if (GNUNET_OK != GNUNET_DISK_directory_remove ("test"))
+    return 1;
+  if (ok < 2)
+    return 1;
+  return 0;
+}
+
+static void
+iter_callback (void *cls,
+               struct GNUNET_DISK_DirectoryIterator *di,
+               const char *filename, const char *dirname)
+{
+  int *i = cls;
+  (*i)++;
+  GNUNET_DISK_directory_iterator_next (di, GNUNET_NO);
+}
+
+static void
+iter_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+{
+  GNUNET_DISK_directory_iterator_start (tc->sched,
+                                        GNUNET_SCHEDULER_PRIORITY_DEFAULT,
+                                        "test", &iter_callback, cls);
+}
+
+static int
+testDirIter ()
+{
+  int i;
+
+  i = 0;
+  if (GNUNET_OK != GNUNET_DISK_directory_create ("test/entry"))
+    return 1;
+  if (GNUNET_OK != GNUNET_DISK_directory_create ("test/entry_many"))
+    return 1;
+  if (GNUNET_OK != GNUNET_DISK_directory_create ("test/entry_more"))
+    return 1;
+  GNUNET_SCHEDULER_run (&iter_task, &i);
+  if (GNUNET_OK != GNUNET_DISK_directory_remove ("test"))
+    return 1;
+  if (i < 3)
+    return 1;
+  return 0;
+}
+
+
+static int
+testGetHome ()
+{
+  struct GNUNET_CONFIGURATION_Handle *cfg;
+  char *fn;
+  int ret;
+
+  cfg = GNUNET_CONFIGURATION_create ();
+  GNUNET_assert (cfg != NULL);
+  GNUNET_CONFIGURATION_set_value_string (cfg, "service", "HOME",
+                                         "/tmp/a/b/c");
+  fn = GNUNET_DISK_get_home_filename (cfg, "service", "d", "e", NULL);
+  GNUNET_assert (fn != NULL);
+  GNUNET_CONFIGURATION_destroy (cfg);
+  ret = strcmp ("/tmp/a/b/c/d/e", fn);
+  GNUNET_free (fn);
+  return ret;
+}
+
+static int
+testCanonicalize ()
+{
+  char *fn = GNUNET_strdup ("ab?><|cd*ef:/g\"");
+  GNUNET_DISK_filename_canonicalize (fn);
+  if (0 != strcmp (fn, "ab____cd_ef__g_"))
+    {
+      GNUNET_free (fn);
+      return 1;
+    }
+  GNUNET_free (fn);
+  return 0;
+}
+
+static int
+testChangeOwner ()
+{
+  GNUNET_log_skip (1);
+  if (GNUNET_OK == GNUNET_DISK_file_change_owner ("/dev/null", "unknownuser"))
+    return 1;
+  return 0;
+}
+
+static int
+testDirMani ()
+{
+  if (GNUNET_OK != GNUNET_DISK_directory_create_for_file ("test/ing"))
+    return 1;
+  if (GNUNET_NO != GNUNET_DISK_file_test ("test"))
+    return 1;
+  if (GNUNET_NO != GNUNET_DISK_file_test ("test/ing"))
+    return 1;
+  if (GNUNET_OK != GNUNET_DISK_directory_remove ("test"))
+    return 1;
+  if (GNUNET_OK != GNUNET_DISK_directory_create ("test"))
+    return 1;
+  if (GNUNET_YES != GNUNET_DISK_directory_test ("test"))
+    return 1;
+  if (GNUNET_OK != GNUNET_DISK_directory_remove ("test"))
+    return 1;
+
+
+  return 0;
+}
+
+
+int
+main (int argc, char *argv[])
+{
+  unsigned int failureCount = 0;
+
+  GNUNET_log_setup ("test-disk", "WARNING", NULL);
+  failureCount += testReadWrite ();
+  failureCount += testOpenClose ();
+  failureCount += testDirScan ();
+  failureCount += testDirIter ();
+  failureCount += testGetHome ();
+  failureCount += testCanonicalize ();
+  failureCount += testChangeOwner ();
+  failureCount += testDirMani ();
+  if (failureCount != 0)
+    {
+      fprintf (stderr, "\n%u TESTS FAILED!\n", failureCount);
+      return -1;
+    }
+  return 0;
+}                               /* end of main */
diff --git a/src/util/test_getopt.c b/src/util/test_getopt.c
new file mode 100644
index 000000000..89e7be863
--- /dev/null
+++ b/src/util/test_getopt.c
@@ -0,0 +1,239 @@
+/*
+     This file is part of GNUnet.
+     (C) 2003, 2004, 2005, 2006, 2009 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 util/test_getopt.c
+ * @brief testcase for util/getopt.c
+ */
+#include "platform.h"
+#include "gnunet_common.h"
+#include "gnunet_configuration_lib.h"
+#include "gnunet_getopt_lib.h"
+
+#define VERBOSE 0
+
+static int
+testMinimal ()
+{
+  struct GNUNET_CONFIGURATION_Handle *cfg;
+  char *const emptyargv[] = {
+    "test",
+    NULL
+  };
+  const struct GNUNET_GETOPT_CommandLineOption emptyoptionlist[] = {
+    GNUNET_GETOPT_OPTION_END
+  };
+
+  cfg = GNUNET_CONFIGURATION_create ();
+  if (1 != GNUNET_GETOPT_run ("test", cfg, emptyoptionlist, 1, emptyargv))
+    {
+      GNUNET_CONFIGURATION_destroy (cfg);
+      return 1;
+    }
+  GNUNET_CONFIGURATION_destroy (cfg);
+
+  return 0;
+}
+
+static int
+testVerbose ()
+{
+  struct GNUNET_CONFIGURATION_Handle *cfg;
+  char *const myargv[] = {
+    "test",
+    "-V",
+    "-V",
+    "more",
+    NULL
+  };
+  unsigned int vflags = 0;
+  const struct GNUNET_GETOPT_CommandLineOption verboseoptionlist[] = {
+    GNUNET_GETOPT_OPTION_VERBOSE (&vflags),
+    GNUNET_GETOPT_OPTION_END
+  };
+
+  cfg = GNUNET_CONFIGURATION_create ();
+  if (3 != GNUNET_GETOPT_run ("test", cfg, verboseoptionlist, 4, myargv))
+    {
+      GNUNET_break (0);
+      GNUNET_CONFIGURATION_destroy (cfg);
+      return 1;
+    }
+  GNUNET_CONFIGURATION_destroy (cfg);
+  if (vflags != 2)
+    {
+      GNUNET_break (0);
+      return 1;
+    }
+  return 0;
+}
+
+static int
+testVersion ()
+{
+  struct GNUNET_CONFIGURATION_Handle *cfg;
+  char *const myargv[] = {
+    "test_getopt",
+    "-v",
+    NULL
+  };
+  const struct GNUNET_GETOPT_CommandLineOption versionoptionlist[] = {
+    GNUNET_GETOPT_OPTION_VERSION (PACKAGE_VERSION),
+    GNUNET_GETOPT_OPTION_END
+  };
+
+  cfg = GNUNET_CONFIGURATION_create ();
+  if (-1 != GNUNET_GETOPT_run ("test_getopt",
+                               cfg, versionoptionlist, 2, myargv))
+    {
+      GNUNET_break (0);
+      GNUNET_CONFIGURATION_destroy (cfg);
+      return 1;
+    }
+  GNUNET_CONFIGURATION_destroy (cfg);
+  return 0;
+}
+
+static int
+testAbout ()
+{
+  struct GNUNET_CONFIGURATION_Handle *cfg;
+  char *const myargv[] = {
+    "test_getopt",
+    "-h",
+    NULL
+  };
+  const struct GNUNET_GETOPT_CommandLineOption aboutoptionlist[] = {
+    GNUNET_GETOPT_OPTION_HELP ("Testing"),
+    GNUNET_GETOPT_OPTION_END
+  };
+
+  cfg = GNUNET_CONFIGURATION_create ();
+  if (-1 != GNUNET_GETOPT_run ("test_getopt",
+                               cfg, aboutoptionlist, 2, myargv))
+    {
+      GNUNET_break (0);
+      GNUNET_CONFIGURATION_destroy (cfg);
+      return 1;
+    }
+  GNUNET_CONFIGURATION_destroy (cfg);
+  return 0;
+}
+
+static int
+testLogOpts ()
+{
+  struct GNUNET_CONFIGURATION_Handle *cfg;
+  char *const myargv[] = {
+    "test_getopt",
+    "-l", "filename",
+    "-L", "WARNING",
+    NULL
+  };
+  char *level = GNUNET_strdup ("stuff");
+  char *fn = NULL;
+  const struct GNUNET_GETOPT_CommandLineOption logoptionlist[] = {
+    GNUNET_GETOPT_OPTION_LOGFILE (&fn),
+    GNUNET_GETOPT_OPTION_LOGLEVEL (&level),
+    GNUNET_GETOPT_OPTION_END
+  };
+
+  cfg = GNUNET_CONFIGURATION_create ();
+  if (5 != GNUNET_GETOPT_run ("test_getopt", cfg, logoptionlist, 5, myargv))
+    {
+      GNUNET_break (0);
+      GNUNET_CONFIGURATION_destroy (cfg);
+      return 1;
+    }
+  GNUNET_assert (fn != NULL);
+  GNUNET_CONFIGURATION_destroy (cfg);
+  if ((0 != strcmp (level, "WARNING")) || (0 != strcmp (fn, "filename")))
+    {
+      GNUNET_break (0);
+      GNUNET_free (level);
+      GNUNET_free (fn);
+      return 1;
+    }
+  GNUNET_free (level);
+  GNUNET_free (fn);
+  return 0;
+}
+
+static int
+testFlagNum ()
+{
+  struct GNUNET_CONFIGURATION_Handle *cfg;
+  char *const myargv[] = {
+    "test_getopt",
+    "-f",
+    "-n", "42",
+    "-N", "42",
+    NULL
+  };
+  int flag = 0;
+  unsigned int num = 0;
+  unsigned long long lnum = 0;
+  const struct GNUNET_GETOPT_CommandLineOption logoptionlist[] = {
+    {'f', "--flag", NULL, "helptext", 0, &GNUNET_GETOPT_set_one,
+     (void *) &flag},
+    {'n', "--num", "ARG", "helptext", 1, &GNUNET_GETOPT_set_uint,
+     (void *) &num},
+    {'N', "--lnum", "ARG", "helptext", 1, &GNUNET_GETOPT_set_ulong,
+     (void *) &lnum},
+    GNUNET_GETOPT_OPTION_END
+  };
+
+  cfg = GNUNET_CONFIGURATION_create ();
+  if (6 != GNUNET_GETOPT_run ("test_getopt", cfg, logoptionlist, 6, myargv))
+    {
+      GNUNET_break (0);
+      GNUNET_CONFIGURATION_destroy (cfg);
+      return 1;
+    }
+  GNUNET_CONFIGURATION_destroy (cfg);
+  if ((1 != flag) || (42 != num) || (42 != lnum))
+    {
+      GNUNET_break (0);
+      return 1;
+    }
+  return 0;
+}
+
+int
+main (int argc, char *argv[])
+{
+  int errCnt = 0;
+
+  GNUNET_log_setup ("test_getopt", "WARNING", NULL);
+  /* suppress output from -h, -v options */
+  GNUNET_break (0 == CLOSE (1));
+  if (0 != testMinimal ())
+    errCnt++;
+  if (0 != testVerbose ())
+    errCnt++;
+  if (0 != testVersion ())
+    errCnt++;
+  if (0 != testAbout ())
+    errCnt++;
+  if (0 != testLogOpts ())
+    errCnt++;
+  if (0 != testFlagNum ())
+    errCnt++;
+  return errCnt;
+}
diff --git a/src/util/test_network.c b/src/util/test_network.c
new file mode 100644
index 000000000..377ec836f
--- /dev/null
+++ b/src/util/test_network.c
@@ -0,0 +1,209 @@
+/*
+     This file is part of GNUnet.
+     (C) 2009 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 util/test_network.c
+ * @brief tests for network.c
+ */
+#include "platform.h"
+#include "gnunet_common.h"
+#include "gnunet_network_lib.h"
+#include "gnunet_scheduler_lib.h"
+#include "gnunet_time_lib.h"
+
+#define VERBOSE GNUNET_NO
+
+#define PORT 12435
+
+
+static struct GNUNET_NETWORK_SocketHandle *csock;
+
+static struct GNUNET_NETWORK_SocketHandle *asock;
+
+static struct GNUNET_NETWORK_SocketHandle *lsock;
+
+static size_t sofar;
+
+static int ls;
+
+
+
+/**
+ * Create and initialize a listen socket for the server.
+ *
+ * @return -1 on error, otherwise the listen socket
+ */
+static int
+open_listen_socket ()
+{
+  const static int on = 1;
+  struct sockaddr_in sa;
+  int fd;
+
+  memset (&sa, 0, sizeof (sa));
+  sa.sin_port = htons (PORT);
+  fd = SOCKET (AF_INET, SOCK_STREAM, 0);
+  GNUNET_assert (fd >= 0);
+  if (SETSOCKOPT (fd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof (on)) < 0)
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
+                "setsockopt");
+  GNUNET_assert (BIND (fd, &sa, sizeof (sa)) >= 0);
+  LISTEN (fd, 5);
+  return fd;
+}
+
+static void
+receive_check (void *cls,
+               const void *buf,
+               size_t available,
+               const struct sockaddr *addr, socklen_t addrlen, int errCode)
+{
+  int *ok = cls;
+
+#if VERBOSE
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Receive validates incoming data\n");
+#endif
+  GNUNET_assert (buf != NULL);  /* no timeout */
+  if (0 == memcmp (&"Hello World"[sofar], buf, available))
+    sofar += available;
+  if (sofar < 12)
+    {
+#if VERBOSE
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Receive needs more data\n");
+#endif
+      GNUNET_NETWORK_receive (asock,
+                              1024,
+                              GNUNET_TIME_relative_multiply
+                              (GNUNET_TIME_UNIT_SECONDS, 5), &receive_check,
+                              cls);
+    }
+  else
+    {
+#if VERBOSE
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "Receive closes accepted socket\n");
+#endif
+      *ok = 0;
+      GNUNET_NETWORK_socket_destroy (asock);
+    }
+}
+
+
+static void
+run_accept (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+{
+#if VERBOSE
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Test accepts connection\n");
+#endif
+  asock = GNUNET_NETWORK_socket_create_from_accept (tc->sched,
+                                                    NULL, NULL, ls, 1024);
+  GNUNET_assert (asock != NULL);
+  GNUNET_assert (GNUNET_YES == GNUNET_NETWORK_socket_check (asock));
+#if VERBOSE
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Test destroys listen socket\n");
+#endif
+  GNUNET_NETWORK_socket_destroy (lsock);
+#if VERBOSE
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Test asks to receive on accepted socket\n");
+#endif
+  GNUNET_NETWORK_receive (asock,
+                          1024,
+                          GNUNET_TIME_relative_multiply
+                          (GNUNET_TIME_UNIT_SECONDS, 5), &receive_check, cls);
+}
+
+static size_t
+make_hello (void *cls, size_t size, void *buf)
+{
+#if VERBOSE
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Test prepares to transmit on connect socket\n");
+#endif
+  GNUNET_assert (size >= 12);
+  strcpy ((char *) buf, "Hello World");
+  return 12;
+}
+
+static void
+task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+{
+  ls = open_listen_socket ();
+  lsock = GNUNET_NETWORK_socket_create_from_existing (tc->sched, ls, 0);
+  GNUNET_assert (lsock != NULL);
+  csock = GNUNET_NETWORK_socket_create_from_connect (tc->sched,
+                                                     "localhost", PORT, 1024);
+  GNUNET_assert (csock != NULL);
+#if VERBOSE
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Test asks for write notification\n");
+#endif
+  GNUNET_assert (NULL !=
+                 GNUNET_NETWORK_notify_transmit_ready (csock,
+                                                       12,
+                                                       GNUNET_TIME_UNIT_SECONDS,
+                                                       &make_hello, NULL));
+#if VERBOSE
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Test destroys client socket\n");
+#endif
+  GNUNET_NETWORK_socket_destroy (csock);
+#if VERBOSE
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Test prepares to accept\n");
+#endif
+  GNUNET_SCHEDULER_add_read (tc->sched,
+                             GNUNET_NO,
+                             GNUNET_SCHEDULER_PRIORITY_HIGH,
+                             GNUNET_SCHEDULER_NO_PREREQUISITE_TASK,
+                             GNUNET_TIME_UNIT_FOREVER_REL,
+                             ls, &run_accept, cls);
+}
+
+
+/**
+ * Main method, starts scheduler with task ,
+ * checks that "ok" is correct at the end.
+ */
+static int
+check ()
+{
+  int ok;
+
+  ok = 1;
+  GNUNET_SCHEDULER_run (&task, &ok);
+  return ok;
+}
+
+
+
+int
+main (int argc, char *argv[])
+{
+  int ret = 0;
+
+  GNUNET_log_setup ("test_network",
+#if VERBOSE
+                    "DEBUG",
+#else
+                    "WARNING",
+#endif
+                    NULL);
+  ret += check ();
+  return ret;
+}
+
+/* end of test_network.c */
diff --git a/src/util/test_network_addressing.c b/src/util/test_network_addressing.c
new file mode 100644
index 000000000..8312b721f
--- /dev/null
+++ b/src/util/test_network_addressing.c
@@ -0,0 +1,193 @@
+/*
+     This file is part of GNUnet.
+     (C) 2009 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 util/test_network_addressing.c
+ * @brief tests for network.c
+ */
+#include "platform.h"
+#include "gnunet_common.h"
+#include "gnunet_network_lib.h"
+#include "gnunet_scheduler_lib.h"
+#include "gnunet_time_lib.h"
+
+#define VERBOSE GNUNET_NO
+
+#define PORT 12435
+
+
+static struct GNUNET_NETWORK_SocketHandle *csock;
+
+static struct GNUNET_NETWORK_SocketHandle *asock;
+
+static struct GNUNET_NETWORK_SocketHandle *lsock;
+
+static size_t sofar;
+
+static int ls;
+
+
+
+/**
+ * Create and initialize a listen socket for the server.
+ *
+ * @return -1 on error, otherwise the listen socket
+ */
+static int
+open_listen_socket ()
+{
+  const static int on = 1;
+  struct sockaddr_in sa;
+  int fd;
+
+  memset (&sa, 0, sizeof (sa));
+  sa.sin_port = htons (PORT);
+  fd = SOCKET (AF_INET, SOCK_STREAM, 0);
+  GNUNET_assert (fd >= 0);
+  if (SETSOCKOPT (fd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof (on)) < 0)
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
+                "setsockopt");
+  GNUNET_assert (BIND (fd, &sa, sizeof (sa)) >= 0);
+  LISTEN (fd, 5);
+  return fd;
+}
+
+
+static void
+receive_check (void *cls,
+               const void *buf,
+               size_t available,
+               const struct sockaddr *addr, socklen_t addrlen, int errCode)
+{
+  int *ok = cls;
+
+  GNUNET_assert (buf != NULL);  /* no timeout */
+  if (0 == memcmp (&"Hello World"[sofar], buf, available))
+    sofar += available;
+  if (sofar < 12)
+    {
+      GNUNET_NETWORK_receive (asock,
+                              1024,
+                              GNUNET_TIME_relative_multiply
+                              (GNUNET_TIME_UNIT_SECONDS, 5), &receive_check,
+                              cls);
+    }
+  else
+    {
+      *ok = 0;
+      GNUNET_NETWORK_socket_destroy (asock);
+    }
+}
+
+
+static void
+run_accept (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+{
+  void *addr;
+  size_t alen;
+  struct sockaddr_in *v4;
+  struct sockaddr_in expect;
+
+  asock = GNUNET_NETWORK_socket_create_from_accept (tc->sched,
+                                                    NULL, NULL, ls, 1024);
+  GNUNET_assert (asock != NULL);
+  GNUNET_assert (GNUNET_YES == GNUNET_NETWORK_socket_check (asock));
+  GNUNET_assert (GNUNET_OK ==
+                 GNUNET_NETWORK_socket_get_address (asock, &addr, &alen));
+  GNUNET_assert (alen == sizeof (struct sockaddr_in));
+  v4 = addr;
+  memset (&expect, 0, sizeof (expect));
+  expect.sin_family = AF_INET;
+  expect.sin_port = v4->sin_port;
+  expect.sin_addr.s_addr = htonl (INADDR_LOOPBACK);
+  GNUNET_assert (0 == memcmp (&expect, v4, alen));
+  GNUNET_NETWORK_socket_destroy (lsock);
+  GNUNET_NETWORK_receive (asock,
+                          1024,
+                          GNUNET_TIME_relative_multiply
+                          (GNUNET_TIME_UNIT_SECONDS, 5), &receive_check, cls);
+}
+
+static size_t
+make_hello (void *cls, size_t size, void *buf)
+{
+  GNUNET_assert (size >= 12);
+  strcpy ((char *) buf, "Hello World");
+  return 12;
+}
+
+static void
+task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+{
+  struct sockaddr_in v4;
+  ls = open_listen_socket ();
+  lsock = GNUNET_NETWORK_socket_create_from_existing (tc->sched, ls, 0);
+  GNUNET_assert (lsock != NULL);
+
+  v4.sin_family = AF_INET;
+  v4.sin_port = htons (PORT);
+  v4.sin_addr.s_addr = htonl (INADDR_LOOPBACK);
+  csock = GNUNET_NETWORK_socket_create_from_sockaddr (tc->sched,
+                                                      AF_INET,
+                                                      (const struct sockaddr
+                                                       *) &v4, sizeof (v4),
+                                                      1024);
+  GNUNET_assert (csock != NULL);
+  GNUNET_assert (NULL !=
+                 GNUNET_NETWORK_notify_transmit_ready (csock,
+                                                       12,
+                                                       GNUNET_TIME_UNIT_SECONDS,
+                                                       &make_hello, NULL));
+  GNUNET_NETWORK_socket_destroy (csock);
+  GNUNET_SCHEDULER_add_read (tc->sched,
+                             GNUNET_NO,
+                             GNUNET_SCHEDULER_PRIORITY_HIGH,
+                             GNUNET_SCHEDULER_NO_PREREQUISITE_TASK,
+                             GNUNET_TIME_UNIT_FOREVER_REL,
+                             ls, &run_accept, cls);
+}
+
+
+/**
+ * Main method, starts scheduler with task ,
+ * checks that "ok" is correct at the end.
+ */
+static int
+check ()
+{
+  int ok;
+
+  ok = 1;
+  GNUNET_SCHEDULER_run (&task, &ok);
+  return ok;
+}
+
+
+
+int
+main (int argc, char *argv[])
+{
+  int ret = 0;
+
+  GNUNET_log_setup ("test_network_addressing", "WARNING", NULL);
+  ret += check ();
+  return ret;
+}
+
+/* end of test_network_addressing.c */
diff --git a/src/util/test_network_receive_cancel.c b/src/util/test_network_receive_cancel.c
new file mode 100644
index 000000000..e22e24d8c
--- /dev/null
+++ b/src/util/test_network_receive_cancel.c
@@ -0,0 +1,164 @@
+/*
+     This file is part of GNUnet.
+     (C) 2009 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 util/test_network_receive_cancel.c
+ * @brief tests for network.c
+ */
+#include "platform.h"
+#include "gnunet_common.h"
+#include "gnunet_network_lib.h"
+#include "gnunet_scheduler_lib.h"
+#include "gnunet_time_lib.h"
+
+#define VERBOSE GNUNET_NO
+
+#define PORT 12435
+
+
+static struct GNUNET_NETWORK_SocketHandle *csock;
+
+static struct GNUNET_NETWORK_SocketHandle *asock;
+
+static struct GNUNET_NETWORK_SocketHandle *lsock;
+
+static int ls;
+
+static GNUNET_SCHEDULER_TaskIdentifier receive_task;
+
+
+
+
+/**
+ * Create and initialize a listen socket for the server.
+ *
+ * @return -1 on error, otherwise the listen socket
+ */
+static int
+open_listen_socket ()
+{
+  const static int on = 1;
+  struct sockaddr_in sa;
+  int fd;
+
+  memset (&sa, 0, sizeof (sa));
+  sa.sin_port = htons (PORT);
+  fd = SOCKET (AF_INET, SOCK_STREAM, 0);
+  GNUNET_assert (fd >= 0);
+  if (SETSOCKOPT (fd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof (on)) < 0)
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
+                "setsockopt");
+  GNUNET_assert (BIND (fd, &sa, sizeof (sa)) >= 0);
+  LISTEN (fd, 5);
+  return fd;
+}
+
+
+
+static void
+dead_receive (void *cls,
+              const void *buf,
+              size_t available,
+              const struct sockaddr *addr, socklen_t addrlen, int errCode)
+{
+  GNUNET_assert (0);
+}
+
+
+static void
+run_accept_cancel (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+{
+
+  asock = GNUNET_NETWORK_socket_create_from_accept (tc->sched,
+                                                    NULL, NULL, ls, 1024);
+  GNUNET_assert (asock != NULL);
+  GNUNET_assert (GNUNET_YES == GNUNET_NETWORK_socket_check (asock));
+  GNUNET_NETWORK_socket_destroy (lsock);
+  receive_task
+    = GNUNET_NETWORK_receive (asock,
+                              1024,
+                              GNUNET_TIME_relative_multiply
+                              (GNUNET_TIME_UNIT_SECONDS, 5), &dead_receive,
+                              cls);
+}
+
+
+static void
+receive_cancel_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+{
+  int *ok = cls;
+  GNUNET_NETWORK_receive_cancel (asock, receive_task);
+  GNUNET_NETWORK_socket_destroy (csock);
+  GNUNET_NETWORK_socket_destroy (asock);
+  *ok = 0;
+}
+
+
+
+static void
+task_receive_cancel (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+{
+  ls = open_listen_socket ();
+  lsock = GNUNET_NETWORK_socket_create_from_existing (tc->sched, ls, 0);
+  GNUNET_assert (lsock != NULL);
+  csock = GNUNET_NETWORK_socket_create_from_connect (tc->sched,
+                                                     "localhost", PORT, 1024);
+  GNUNET_assert (csock != NULL);
+  GNUNET_SCHEDULER_add_read (tc->sched,
+                             GNUNET_NO,
+                             GNUNET_SCHEDULER_PRIORITY_HIGH,
+                             GNUNET_SCHEDULER_NO_PREREQUISITE_TASK,
+                             GNUNET_TIME_UNIT_FOREVER_REL,
+                             ls, &run_accept_cancel, cls);
+  GNUNET_SCHEDULER_add_delayed (tc->sched,
+                                GNUNET_NO,
+                                GNUNET_SCHEDULER_PRIORITY_KEEP,
+                                GNUNET_SCHEDULER_NO_PREREQUISITE_TASK,
+                                GNUNET_TIME_UNIT_SECONDS,
+                                &receive_cancel_task, cls);
+}
+
+
+
+/**
+ * Main method, starts scheduler with task_timeout.
+ */
+static int
+check_receive_cancel ()
+{
+  int ok;
+
+  ok = 1;
+  GNUNET_SCHEDULER_run (&task_receive_cancel, &ok);
+  return ok;
+}
+
+
+int
+main (int argc, char *argv[])
+{
+  int ret = 0;
+
+  GNUNET_log_setup ("test_network_receive_cancel", "WARNING", NULL);
+  ret += check_receive_cancel ();
+
+  return ret;
+}
+
+/* end of test_network.c */
diff --git a/src/util/test_network_timeout.c b/src/util/test_network_timeout.c
new file mode 100644
index 000000000..2c2f6f9f2
--- /dev/null
+++ b/src/util/test_network_timeout.c
@@ -0,0 +1,144 @@
+/*
+     This file is part of GNUnet.
+     (C) 2009 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 util/test_network_timeout.c
+ * @brief tests for network.c
+ */
+#include "platform.h"
+#include "gnunet_common.h"
+#include "gnunet_network_lib.h"
+#include "gnunet_scheduler_lib.h"
+#include "gnunet_time_lib.h"
+
+#define VERBOSE GNUNET_NO
+
+#define PORT 12435
+
+static struct GNUNET_NETWORK_SocketHandle *csock;
+
+static struct GNUNET_NETWORK_SocketHandle *lsock;
+
+static int ls;
+
+
+/**
+ * Create and initialize a listen socket for the server.
+ *
+ * @return -1 on error, otherwise the listen socket
+ */
+static int
+open_listen_socket ()
+{
+  const static int on = 1;
+  struct sockaddr_in sa;
+  int fd;
+
+  memset (&sa, 0, sizeof (sa));
+  sa.sin_port = htons (PORT);
+  fd = SOCKET (AF_INET, SOCK_STREAM, 0);
+  GNUNET_assert (fd >= 0);
+  if (SETSOCKOPT (fd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof (on)) < 0)
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
+                "setsockopt");
+  GNUNET_assert (BIND (fd, &sa, sizeof (sa)) >= 0);
+  LISTEN (fd, 5);
+  return fd;
+}
+
+
+static size_t
+send_kilo (void *cls, size_t size, void *buf)
+{
+  int *ok = cls;
+  if (size == 0)
+    {
+#if VERBOSE
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Got the desired timeout!\n");
+#endif
+      GNUNET_assert (buf == NULL);
+      *ok = 0;
+      GNUNET_NETWORK_socket_destroy (lsock);
+      GNUNET_NETWORK_socket_destroy (csock);
+      return 0;
+    }
+#if VERBOSE
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sending kilo to fill buffer.\n");
+#endif
+  GNUNET_assert (size >= 1024);
+  memset (buf, 42, 1024);
+
+  GNUNET_assert (NULL !=
+                 GNUNET_NETWORK_notify_transmit_ready (csock,
+                                                       1024,
+                                                       GNUNET_TIME_UNIT_SECONDS,
+                                                       &send_kilo, cls));
+  return 1024;
+}
+
+
+static void
+task_timeout (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+{
+
+  ls = open_listen_socket ();
+  lsock = GNUNET_NETWORK_socket_create_from_existing (tc->sched, ls, 0);
+  GNUNET_assert (lsock != NULL);
+  csock = GNUNET_NETWORK_socket_create_from_connect (tc->sched,
+                                                     "localhost", PORT, 1024);
+  GNUNET_assert (csock != NULL);
+  GNUNET_assert (NULL !=
+                 GNUNET_NETWORK_notify_transmit_ready (csock,
+                                                       1024,
+                                                       GNUNET_TIME_UNIT_SECONDS,
+                                                       &send_kilo, cls));
+}
+
+
+
+/**
+ * Main method, starts scheduler with task_timeout.
+ */
+static int
+check_timeout ()
+{
+  int ok;
+
+  ok = 1;
+  GNUNET_SCHEDULER_run (&task_timeout, &ok);
+  return ok;
+}
+
+int
+main (int argc, char *argv[])
+{
+  int ret = 0;
+
+  GNUNET_log_setup ("test_network_timeout",
+#if VERBOSE
+                    "DEBUG",
+#else
+                    "WARNING",
+#endif
+                    NULL);
+  ret += check_timeout ();
+  return ret;
+}
+
+/* end of test_network_timeout.c */
diff --git a/src/util/test_network_timeout_no_connect.c b/src/util/test_network_timeout_no_connect.c
new file mode 100644
index 000000000..fd5e82dcd
--- /dev/null
+++ b/src/util/test_network_timeout_no_connect.c
@@ -0,0 +1,95 @@
+/*
+     This file is part of GNUnet.
+     (C) 2009 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 util/test_network_timeout.c
+ * @brief tests for network.c, doing timeout which connect failure
+ */
+#include "platform.h"
+#include "gnunet_common.h"
+#include "gnunet_network_lib.h"
+#include "gnunet_scheduler_lib.h"
+#include "gnunet_time_lib.h"
+
+#define VERBOSE GNUNET_NO
+
+#define PORT 13425
+
+static struct GNUNET_NETWORK_SocketHandle *csock;
+
+static size_t
+handle_timeout (void *cls, size_t size, void *buf)
+{
+  int *ok = cls;
+#if VERBOSE
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Received timeout signal.\n");
+#endif
+
+  GNUNET_assert (size == 0);
+  GNUNET_assert (buf == NULL);
+  *ok = 0;
+  return 0;
+}
+
+
+static void
+task_timeout (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+{
+  csock = GNUNET_NETWORK_socket_create_from_connect (tc->sched,
+                                                     "localhost", PORT, 1024);
+  GNUNET_assert (csock != NULL);
+  GNUNET_assert (NULL !=
+                 GNUNET_NETWORK_notify_transmit_ready (csock,
+                                                       1024,
+                                                       GNUNET_TIME_UNIT_SECONDS,
+                                                       &handle_timeout, cls));
+}
+
+
+
+/**
+ * Main method, starts scheduler with task_timeout.
+ */
+static int
+check_timeout ()
+{
+  int ok;
+
+  ok = 1;
+  GNUNET_SCHEDULER_run (&task_timeout, &ok);
+  return ok;
+}
+
+int
+main (int argc, char *argv[])
+{
+  int ret = 0;
+
+  GNUNET_log_setup ("test_network_timeout_no_connect",
+#if VERBOSE
+                    "DEBUG",
+#else
+                    "WARNING",
+#endif
+                    NULL);
+  ret += check_timeout ();
+  return ret;
+}
+
+/* end of test_network_timeout_no_connect.c */
diff --git a/src/util/test_network_transmit_cancel.c b/src/util/test_network_transmit_cancel.c
new file mode 100644
index 000000000..29732d202
--- /dev/null
+++ b/src/util/test_network_transmit_cancel.c
@@ -0,0 +1,97 @@
+/*
+     This file is part of GNUnet.
+     (C) 2009 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 util/test_network_transmit_cancel.c
+ * @brief tests for network.c
+ */
+#include "platform.h"
+#include "gnunet_common.h"
+#include "gnunet_network_lib.h"
+#include "gnunet_scheduler_lib.h"
+#include "gnunet_time_lib.h"
+
+#define VERBOSE GNUNET_YES
+
+#define PORT 12435
+
+
+static size_t
+not_run (void *cls, size_t size, void *buf)
+{
+  GNUNET_assert (0);
+  return 0;
+}
+
+
+static void
+task_transmit_cancel (void *cls,
+                      const struct GNUNET_SCHEDULER_TaskContext *tc)
+{
+  int *ok = cls;
+  struct GNUNET_NETWORK_TransmitHandle *th;
+  struct GNUNET_NETWORK_SocketHandle *csock;
+
+  csock = GNUNET_NETWORK_socket_create_from_connect (tc->sched,
+                                                     "localhost", PORT, 1024);
+  GNUNET_assert (csock != NULL);
+  th = GNUNET_NETWORK_notify_transmit_ready (csock,
+                                             12,
+                                             GNUNET_TIME_UNIT_MINUTES,
+                                             &not_run, cls);
+  GNUNET_NETWORK_notify_transmit_ready_cancel (th);
+  GNUNET_NETWORK_socket_destroy (csock);
+  *ok = 0;
+}
+
+
+
+
+/**
+ * Main method, starts scheduler with task_timeout.
+ */
+static int
+check_transmit_cancel ()
+{
+  int ok;
+
+  ok = 1;
+  GNUNET_SCHEDULER_run (&task_transmit_cancel, &ok);
+  return ok;
+}
+
+
+int
+main (int argc, char *argv[])
+{
+  int ret = 0;
+
+  GNUNET_log_setup ("test_network_transmit_cancel",
+#if VERBOSE
+                    "DEBUG",
+#else
+                    "WARNING",
+#endif
+                    NULL);
+  ret += check_transmit_cancel ();
+
+  return ret;
+}
+
+/* end of test_network_transmit_cancel.c */
diff --git a/src/util/test_os_load.c b/src/util/test_os_load.c
new file mode 100644
index 000000000..2f82f60c7
--- /dev/null
+++ b/src/util/test_os_load.c
@@ -0,0 +1,182 @@
+/*
+     This file is part of GNUnet.
+     (C) 2003, 2004, 2005, 2006, 2009 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 util/test_os_load.c
+ * @brief testcase for util/os_load.c
+ */
+#include "platform.h"
+#include "gnunet_common.h"
+#include "gnunet_configuration_lib.h"
+#include "gnunet_crypto_lib.h"
+#include "gnunet_disk_lib.h"
+#include "gnunet_os_lib.h"
+#include "gnunet_time_lib.h"
+
+#define VERBOSE 0
+
+static int
+testcpu ()
+{
+  static long k;
+  int ret;
+  struct GNUNET_TIME_Absolute start;
+  struct GNUNET_CONFIGURATION_Handle *cfg;
+
+  fprintf (stderr, "CPU load test, this may take a while.");
+  cfg = GNUNET_CONFIGURATION_create ();
+  GNUNET_assert (cfg != NULL);
+  /* need to run each phase for more than 10s since
+     statuscalls only refreshes that often... */
+  GNUNET_CONFIGURATION_set_value_number (cfg, "LOAD", "MAXCPULOAD", 100);
+  GNUNET_OS_load_cpu_get (cfg);
+  start = GNUNET_TIME_absolute_get ();
+  while ((GNUNET_TIME_absolute_get_duration (start).value < 120 * 1000) &&
+         (0 != GNUNET_OS_load_cpu_get (cfg)))
+    sleep (1);
+  start = GNUNET_TIME_absolute_get ();
+  ret = GNUNET_OS_load_cpu_get (cfg);
+  if (ret > 10)
+    {
+      fprintf (stderr,
+               "\nWARNING: base load too high (%d) to run CPU load test.\n",
+               ret);
+      GNUNET_CONFIGURATION_destroy (cfg);
+      return 0;
+    }
+  if (ret == -1)
+    {
+      fprintf (stderr, "\nWARNING: CPU load determination not supported.\n");
+      GNUNET_CONFIGURATION_destroy (cfg);
+      return 0;
+    }
+  while (GNUNET_TIME_absolute_get_duration (start).value < 60 * 1000)
+    {
+      k++;                      /* do some processing to drive load up */
+      if (ret < GNUNET_OS_load_cpu_get (cfg))
+        break;
+    }
+  if (ret >= GNUNET_OS_load_cpu_get (cfg))
+    {
+      fprintf (stderr,
+               "\nbusy loop failed to increase CPU load: %d >= %d.",
+               ret, GNUNET_OS_load_cpu_get (cfg));
+      ret = 1;
+    }
+  else
+    {
+#if VERBOSE
+      fprintf (stderr,
+               "\nbusy loop increased CPU load: %d < %d.",
+               ret, GNUNET_OS_load_cpu_get (cfg));
+#endif
+      ret = 0;
+    }
+  fprintf (stderr, "\n");
+
+
+  GNUNET_CONFIGURATION_destroy (cfg);
+  return ret;
+}
+
+static int
+testdisk ()
+{
+  int ret;
+  int fd;
+  char buf[65536];
+  struct GNUNET_TIME_Absolute start;
+  struct GNUNET_CONFIGURATION_Handle *cfg;
+
+  fprintf (stderr, "IO load test, this may take a while.");
+  cfg = GNUNET_CONFIGURATION_create ();
+  GNUNET_assert (cfg != NULL);
+  /* need to run each phase for more than 10s since
+     statuscalls only refreshes that often... */
+  GNUNET_CONFIGURATION_set_value_number (cfg, "LOAD", "MAXIOLOAD", 100);
+  GNUNET_OS_load_disk_get (cfg);
+  start = GNUNET_TIME_absolute_get ();
+  while ((GNUNET_TIME_absolute_get_duration (start).value < 12 * 1000) &&
+         (0 != GNUNET_OS_load_disk_get (cfg)))
+    sleep (1);
+  start = GNUNET_TIME_absolute_get ();
+  ret = GNUNET_OS_load_disk_get (cfg);
+  if (ret > 10)
+    {
+      fprintf (stderr,
+               "WARNING: base load too high (%d) to run IO load test.\n",
+               ret);
+      GNUNET_CONFIGURATION_destroy (cfg);
+      return 0;
+    }
+  if (ret == -1)
+    {
+      fprintf (stderr, "WARNING: IO load determination not supported.\n");
+      GNUNET_CONFIGURATION_destroy (cfg);
+      return 0;
+    }
+  memset (buf, 42, sizeof (buf));
+  fd =
+    GNUNET_DISK_file_open (".loadfile", O_WRONLY | O_CREAT,
+                           S_IRUSR | S_IWUSR);
+  GNUNET_assert (fd != -1);
+  while (GNUNET_TIME_absolute_get_duration (start).value < 60 * 1000)
+    {
+      LSEEK (fd, GNUNET_CRYPTO_random_u64 (GNUNET_CRYPTO_QUALITY_WEAK,
+                                           1024 * 1024 * 1024), SEEK_SET);
+      GNUNET_assert (sizeof (buf) == WRITE (fd, buf, sizeof (buf)));
+      fsync (fd);
+      if (ret < GNUNET_OS_load_disk_get (cfg))
+        break;
+    }
+  GNUNET_break (0 == CLOSE (fd));
+  GNUNET_break (0 == UNLINK (".loadfile"));
+  if (ret >= GNUNET_OS_load_disk_get (cfg))
+    {
+      fprintf (stderr,
+               "\nbusy loop failed to increase IO load: %d >= %d.",
+               ret, GNUNET_OS_load_disk_get (cfg));
+      ret = 1;
+    }
+  else
+    {
+#if VERBOSE
+      fprintf (stderr,
+               "\nbusy loop increased disk load: %d < %d.",
+               ret, GNUNET_OS_load_disk_get (cfg));
+#endif
+      ret = 0;
+    }
+  fprintf (stderr, "\n");
+  GNUNET_CONFIGURATION_destroy (cfg);
+  return 0;
+}
+
+int
+main (int argc, char *argv[])
+{
+  int errCnt = 0;
+
+  GNUNET_log_setup ("test-os-load", "WARNING", NULL);
+  if (0 != testcpu ())
+    errCnt++;
+  if (0 != testdisk ())
+    errCnt++;
+  return errCnt;
+}
diff --git a/src/util/test_os_network.c b/src/util/test_os_network.c
new file mode 100644
index 000000000..ca57765da
--- /dev/null
+++ b/src/util/test_os_network.c
@@ -0,0 +1,73 @@
+/*
+     This file is part of GNUnet.
+     (C) 2003, 2004, 2005, 2006, 2009 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 util/test_os_network.c
+ * @brief testcase for util/os_network.c
+ */
+#include "platform.h"
+#include "gnunet_common.h"
+#include "gnunet_configuration_lib.h"
+#include "gnunet_os_lib.h"
+
+#define VERBOSE 0
+
+/**
+ * Check if the address we got is IPv4 or IPv6 loopback (which should
+ * be present on all systems at all times); if so, set ok to 0
+ * (success).
+ */
+static int
+proc (void *cls,
+      const char *name,
+      int isDefault, const struct sockaddr *addr, socklen_t addrlen)
+{
+  int *ok = cls;
+  char buf[INET6_ADDRSTRLEN];
+
+  inet_ntop (addr->sa_family,
+             (addr->sa_family == AF_INET) ?
+             (void *) &((struct sockaddr_in *) addr)->sin_addr :
+             (void *) &((struct sockaddr_in6 *) addr)->sin6_addr,
+             buf, sizeof (buf));
+  if ((0 == strcmp ("::1", buf)) || (0 == strcmp ("127.0.0.1", buf)))
+    *ok = 0;
+  return GNUNET_OK;
+}
+
+static int
+testifcs ()
+{
+  int ret;
+
+  ret = 1;
+  GNUNET_OS_network_interfaces_list (&proc, &ret);
+  return ret;
+}
+
+int
+main (int argc, char *argv[])
+{
+  int errCnt = 0;
+
+  GNUNET_log_setup ("test-os-network", "WARNING", NULL);
+  if (0 != testifcs ())
+    errCnt++;
+  return errCnt;
+}
diff --git a/src/util/test_os_priority.c b/src/util/test_os_priority.c
new file mode 100644
index 000000000..8284af5b8
--- /dev/null
+++ b/src/util/test_os_priority.c
@@ -0,0 +1,61 @@
+/*
+     This file is part of GNUnet.
+     (C) 2003, 2004, 2005, 2006, 2009 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 util/test_os_priority.c
+ * @brief testcase for util/os_priority.c
+ */
+#include "platform.h"
+#include "gnunet_common.h"
+#include "gnunet_os_lib.h"
+
+#define VERBOSE 0
+
+static int
+testprio ()
+{
+  pid_t child;
+  if (GNUNET_OK !=
+      GNUNET_OS_set_process_priority (getpid (),
+                                      GNUNET_SCHEDULER_PRIORITY_DEFAULT))
+    return 1;
+#ifndef MINGW
+  child = fork ();
+  if (child == 0)
+    {
+      sleep (10);
+      exit (0);
+    }
+  if (GNUNET_OK !=
+      GNUNET_OS_set_process_priority (child, GNUNET_SCHEDULER_PRIORITY_IDLE))
+    return 1;
+#endif
+  return 0;
+}
+
+int
+main (int argc, char *argv[])
+{
+  int errCnt = 0;
+
+  GNUNET_log_setup ("test_os_priority", "WARNING", NULL);
+  if (0 != testprio ())
+    errCnt++;
+  return errCnt;
+}
diff --git a/src/util/test_plugin.c b/src/util/test_plugin.c
new file mode 100644
index 000000000..22bf78b92
--- /dev/null
+++ b/src/util/test_plugin.c
@@ -0,0 +1,64 @@
+/*
+     This file is part of GNUnet.
+     (C) 2009 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 util/test_plugin.c
+ * @brief testcase for plugin.c
+ */
+#include "platform.h"
+#include "gnunet_plugin_lib.h"
+
+#define VERBOSE GNUNET_NO
+
+static int
+check ()
+{
+  void *ret;
+
+  GNUNET_log_skip (1);
+  ret = GNUNET_PLUGIN_load ("libgnunet_plugin_missing", NULL);
+  GNUNET_log_skip (0);
+  if (ret != NULL)
+    return 1;
+  ret = GNUNET_PLUGIN_load ("libgnunet_plugin_test", "in");
+  if (ret == NULL)
+    return 1;
+  if (0 != strcmp (ret, "Hello"))
+    return 2;
+  ret = GNUNET_PLUGIN_unload ("libgnunet_plugin_test", "out");
+  if (ret == NULL)
+    return 3;
+  if (0 != strcmp (ret, "World"))
+    return 4;
+  free (ret);
+  return 0;
+}
+
+int
+main (int argc, char *argv[])
+{
+  int ret;
+
+  GNUNET_log_setup ("test-plugin", "WARNING", NULL);
+  ret = check ();
+
+  return ret;
+}
+
+/* end of test_plugin.c */
diff --git a/src/util/test_plugin_plug.c b/src/util/test_plugin_plug.c
new file mode 100644
index 000000000..ca4bef277
--- /dev/null
+++ b/src/util/test_plugin_plug.c
@@ -0,0 +1,42 @@
+/*
+     This file is part of GNUnet.
+     (C) 2009 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 util/test_plugin_plug.c
+ * @brief plugin for testing
+ */
+#include "platform.h"
+
+void *
+libgnunet_plugin_test_init (void *arg)
+{
+  if (0 == strcmp (arg, "in"))
+    return "Hello";
+  return NULL;
+}
+
+void *
+libgnunet_plugin_test_done (void *arg)
+{
+  if (0 == strcmp (arg, "out"))
+    return strdup ("World");
+  return NULL;
+}
+
+/* end of test_plugin_plug.c */
diff --git a/src/util/test_program.c b/src/util/test_program.c
new file mode 100644
index 000000000..dee602e2a
--- /dev/null
+++ b/src/util/test_program.c
@@ -0,0 +1,94 @@
+/*
+     This file is part of GNUnet.
+     (C) 2009 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 util/test_program.c
+ * @brief tests for program.c
+ */
+#include "platform.h"
+#include "gnunet_common.h"
+#include "gnunet_program_lib.h"
+#include "gnunet_scheduler_lib.h"
+#include "gnunet_time_lib.h"
+
+static int setme;
+
+static struct GNUNET_GETOPT_CommandLineOption options[] = {
+  {'n', "name", NULL, "description", 0, &GNUNET_GETOPT_set_one, &setme},
+  GNUNET_GETOPT_OPTION_END
+};
+
+/**
+ * Main function that will be run.
+ */
+static void
+runner (void *cls,
+        struct GNUNET_SCHEDULER_Handle *sched,
+        char *const *args,
+        const char *cfgfile, struct GNUNET_CONFIGURATION_Handle *cfg)
+{
+  int *ok = cls;
+  GNUNET_assert (setme == 1);
+  GNUNET_assert (sched != NULL);
+  GNUNET_assert (0 == strcmp (args[0], "extra"));
+  GNUNET_assert (args[1] == NULL);
+  GNUNET_assert (0 == strcmp (cfgfile, "test_program_data.conf"));
+
+  *ok = 0;
+}
+
+
+/**
+ * Main method, starts scheduler with task1,
+ * checks that "ok" is correct at the end.
+ */
+static int
+check ()
+{
+  int ok = 1;
+  char *const argv[] = {
+    "test_program",
+    "-c",
+    "test_program_data.conf",
+    "-L",
+    "WARNING",
+    "-n",
+    "extra",
+    NULL
+  };
+  GNUNET_assert (GNUNET_OK ==
+                 GNUNET_PROGRAM_run (7,
+                                     argv,
+                                     "test_program",
+                                     "A test", options, &runner, &ok));
+  return ok;
+}
+
+int
+main (int argc, char *argv[])
+{
+  int ret = 0;
+
+  GNUNET_log_setup ("test_program", "WARNING", NULL);
+  ret += check ();
+
+  return ret;
+}
+
+/* end of test_program.c */
diff --git a/src/util/test_program_data.conf b/src/util/test_program_data.conf
new file mode 100644
index 000000000..e69de29bb
--- /dev/null
+++ b/src/util/test_program_data.conf
diff --git a/src/util/test_pseudonym.c b/src/util/test_pseudonym.c
new file mode 100644
index 000000000..6d31c8a07
--- /dev/null
+++ b/src/util/test_pseudonym.c
@@ -0,0 +1,138 @@
+/*
+     This file is part of GNUnet.
+     (C) 2005, 2006, 2008, 2009 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 util/test_pseudonym.c
+ * @brief testcase for pseudonym.c
+ * @author Christian Grothoff
+ */
+
+#include "platform.h"
+#include "gnunet_common.h"
+#include "gnunet_container_lib.h"
+#include "gnunet_crypto_lib.h"
+#include "gnunet_disk_lib.h"
+#include "gnunet_pseudonym_lib.h"
+
+#define CHECK(a) if (!(a)) { ok = GNUNET_NO; GNUNET_break(0); goto FAILURE; }
+
+static struct GNUNET_CONTAINER_MetaData *meta;
+
+static GNUNET_HashCode id1;
+
+static int
+iter (void *cls,
+      const GNUNET_HashCode *
+      pseudonym, const struct GNUNET_CONTAINER_MetaData *md, int rating)
+{
+  int *ok = cls;
+
+  if ((0 == memcmp (pseudonym,
+                    &id1,
+                    sizeof (GNUNET_HashCode))) &&
+      (!GNUNET_CONTAINER_meta_data_test_equal (md, meta)))
+    {
+      *ok = GNUNET_NO;
+      GNUNET_break (0);
+    }
+  return GNUNET_OK;
+}
+
+static int
+noti_callback (void *cls,
+               const GNUNET_HashCode *
+               pseudonym,
+               const struct GNUNET_CONTAINER_MetaData *md, int rating)
+{
+  int *ret = cls;
+  (*ret)++;
+  return GNUNET_OK;
+}
+
+
+int
+main (int argc, char *argv[])
+{
+  int ok;
+  GNUNET_HashCode rid1;
+  GNUNET_HashCode id2;
+  GNUNET_HashCode rid2;
+  int old;
+  int newVal;
+  struct GNUNET_CONFIGURATION_Handle *cfg;
+  char *name1;
+  char *name2;
+  int notiCount;
+
+  GNUNET_log_setup ("test-psuedonym", "WARNING", NULL);
+  ok = GNUNET_YES;
+  GNUNET_CRYPTO_random_disable_entropy_gathering ();
+  GNUNET_DISK_directory_remove ("/tmp/gnunet-pseudonym-test");
+  cfg = GNUNET_CONFIGURATION_create ();
+  if (-1 == GNUNET_CONFIGURATION_parse (cfg, "test_pseudonym_data.conf"))
+    {
+      GNUNET_CONFIGURATION_destroy (cfg);
+      GNUNET_break (0);
+      return -1;
+    }
+  notiCount = 0;
+  GNUNET_PSEUDONYM_discovery_callback_register (cfg,
+                                                &noti_callback, &notiCount);
+  /* ACTUAL TEST CODE */
+  old = GNUNET_PSEUDONYM_list_all (cfg, NULL, NULL);
+  meta = GNUNET_CONTAINER_meta_data_create ();
+  GNUNET_CONTAINER_meta_data_insert (meta, EXTRACTOR_TITLE, "test");
+  GNUNET_CRYPTO_hash_create_random (&id1);
+  GNUNET_PSEUDONYM_add (cfg, &id1, meta);
+  CHECK (notiCount == 1);
+  GNUNET_PSEUDONYM_add (cfg, &id1, meta);
+  CHECK (notiCount == 2);
+  newVal = GNUNET_PSEUDONYM_list_all (cfg, &iter, &ok);
+  CHECK (old < newVal);
+  old = newVal;
+  GNUNET_CRYPTO_hash_create_random (&id2);
+  GNUNET_PSEUDONYM_add (cfg, &id2, meta);
+  CHECK (notiCount == 3);
+  newVal = GNUNET_PSEUDONYM_list_all (cfg, &iter, &ok);
+  CHECK (old < newVal);
+  name2 = GNUNET_PSEUDONYM_id_to_name (cfg, &id2);
+  CHECK (name2 != NULL);
+  name1 = GNUNET_PSEUDONYM_id_to_name (cfg, &id1);
+  CHECK (name1 != NULL);
+  CHECK (0 != strcmp (name1, name2));
+  CHECK (GNUNET_OK == GNUNET_PSEUDONYM_name_to_id (cfg, name2, &rid2));
+  CHECK (GNUNET_OK == GNUNET_PSEUDONYM_name_to_id (cfg, name1, &rid1));
+  CHECK (0 == memcmp (&id1, &rid1, sizeof (GNUNET_HashCode)));
+  CHECK (0 == memcmp (&id2, &rid2, sizeof (GNUNET_HashCode)));
+  CHECK (0 == GNUNET_PSEUDONYM_rank (cfg, &id1, 0));
+  CHECK (5 == GNUNET_PSEUDONYM_rank (cfg, &id1, 5));
+  CHECK (-5 == GNUNET_PSEUDONYM_rank (cfg, &id1, -10));
+  CHECK (0 == GNUNET_PSEUDONYM_rank (cfg, &id1, 5));
+  GNUNET_free (name1);
+  GNUNET_free (name2);
+  /* END OF TEST CODE */
+FAILURE:
+  GNUNET_PSEUDONYM_discovery_callback_unregister (&noti_callback, &notiCount);
+  GNUNET_CONTAINER_meta_data_destroy (meta);
+  GNUNET_CONFIGURATION_destroy (cfg);
+  return (ok == GNUNET_YES) ? 0 : 1;
+}
+
+/* end of test_pseudoynm.c */
diff --git a/src/util/test_pseudonym_data.conf b/src/util/test_pseudonym_data.conf
new file mode 100644
index 000000000..fd2048586
--- /dev/null
+++ b/src/util/test_pseudonym_data.conf
@@ -0,0 +1,8 @@
+# General settings
+[client]
+HOME = "/tmp/gnunet-pseudonym-test"
+
+[TESTING]
+WEAKRANDOM = YES
+
+
diff --git a/src/util/test_scheduler.c b/src/util/test_scheduler.c
new file mode 100644
index 000000000..fe15e987b
--- /dev/null
+++ b/src/util/test_scheduler.c
@@ -0,0 +1,263 @@
+/*
+     This file is part of GNUnet.
+     (C) 2009 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 util/test_scheduler.c
+ * @brief tests for the scheduler
+ */
+#include "platform.h"
+#include "gnunet_common.h"
+#include "gnunet_scheduler_lib.h"
+#include "gnunet_time_lib.h"
+
+#define VERBOSE GNUNET_NO
+
+static void
+task2 (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+{
+  int *ok = cls;
+  GNUNET_assert (2 == *ok);
+  (*ok) = 3;
+}
+
+static void
+task3 (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+{
+  int *ok = cls;
+  /* t4 should be ready (albeit with lower priority) */
+  GNUNET_assert (1 == GNUNET_SCHEDULER_get_load (tc->sched,
+                                                 GNUNET_SCHEDULER_PRIORITY_COUNT));
+  GNUNET_assert (3 == *ok);
+  (*ok) = 4;
+}
+
+static void
+task4 (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+{
+  int *ok = cls;
+  GNUNET_assert (4 == *ok);
+  (*ok) = 5;
+}
+
+static int fds[2];
+
+
+static void
+taskWrt (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+{
+  static char c;
+  int *ok = cls;
+  GNUNET_assert (6 == *ok);
+  GNUNET_assert (FD_ISSET (fds[1], tc->write_ready));
+  (*ok) = 7;
+  GNUNET_assert (1 == WRITE (fds[1], &c, 1));
+  GNUNET_break (0 == CLOSE (fds[1]));
+}
+
+
+static void
+taskNeverRun (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+{
+  GNUNET_assert (0);
+}
+
+static void
+taskLast (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+{
+  int *ok = cls;
+  /* t4 should be ready (albeit with lower priority) */
+  GNUNET_assert (8 == *ok);
+  (*ok) = 0;
+}
+
+static void
+taskRd (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+{
+  static char c;
+  int *ok = cls;
+  GNUNET_assert (7 == *ok);
+  GNUNET_assert (FD_ISSET (fds[0], tc->read_ready));
+  GNUNET_assert (1 == READ (fds[0], &c, 1));
+  GNUNET_break (0 == CLOSE (fds[0]));
+  (*ok) = 8;
+  GNUNET_SCHEDULER_add_after (tc->sched,
+                              GNUNET_NO,
+                              GNUNET_SCHEDULER_PRIORITY_UI,
+                              0, &taskNeverRun, NULL);
+  GNUNET_SCHEDULER_add_after (tc->sched,
+                              GNUNET_YES,
+                              GNUNET_SCHEDULER_PRIORITY_IDLE,
+                              0, &taskLast, cls);
+  GNUNET_SCHEDULER_shutdown (tc->sched);
+}
+
+
+static void
+task5 (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+{
+  int *ok = cls;
+  GNUNET_assert (5 == *ok);
+  (*ok) = 6;
+  GNUNET_assert (0 == pipe (fds));
+  GNUNET_SCHEDULER_add_read (tc->sched,
+                             GNUNET_NO,
+                             GNUNET_SCHEDULER_PRIORITY_DEFAULT,
+                             GNUNET_SCHEDULER_NO_PREREQUISITE_TASK,
+                             GNUNET_TIME_UNIT_FOREVER_REL,
+                             fds[0], &taskRd, cls);
+  GNUNET_SCHEDULER_add_write (tc->sched,
+                              GNUNET_NO,
+                              GNUNET_SCHEDULER_PRIORITY_DEFAULT,
+                              GNUNET_SCHEDULER_NO_PREREQUISITE_TASK,
+                              GNUNET_TIME_UNIT_FOREVER_REL,
+                              fds[1], &taskWrt, cls);
+}
+
+
+static void
+task1 (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+{
+  int *ok = cls;
+  GNUNET_SCHEDULER_TaskIdentifier t2;
+  GNUNET_SCHEDULER_TaskIdentifier t3;
+  GNUNET_SCHEDULER_TaskIdentifier t4;
+
+  GNUNET_assert (1 == *ok);
+  (*ok) = 2;
+  /* t2 will go first -- prereq for all */
+  t2 = GNUNET_SCHEDULER_add_after (tc->sched,
+                                   GNUNET_NO,
+                                   GNUNET_SCHEDULER_PRIORITY_IDLE,
+                                   GNUNET_SCHEDULER_NO_PREREQUISITE_TASK,
+                                   &task2, cls);
+  /* t3 will go before t4: higher priority */
+  t4 = GNUNET_SCHEDULER_add_after (tc->sched,
+                                   GNUNET_NO,
+                                   GNUNET_SCHEDULER_PRIORITY_IDLE,
+                                   t2, &task4, cls);
+  t3 = GNUNET_SCHEDULER_add_delayed (tc->sched,
+                                     GNUNET_NO,
+                                     GNUNET_SCHEDULER_PRIORITY_DEFAULT,
+                                     t2,
+                                     GNUNET_TIME_relative_get_zero (),
+                                     &task3, cls);
+  /* t4 will go first: lower prio, but prereq! */
+  GNUNET_SCHEDULER_add_after (tc->sched,
+                              GNUNET_NO,
+                              GNUNET_SCHEDULER_PRIORITY_UI, t4, &task5, cls);
+}
+
+
+
+/**
+ * Main method, starts scheduler with task1,
+ * checks that "ok" is correct at the end.
+ */
+static int
+check ()
+{
+  int ok;
+
+  ok = 1;
+  GNUNET_SCHEDULER_run (&task1, &ok);
+  return ok;
+}
+
+
+static void
+taskSig (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+{
+  int *ok = cls;
+  GNUNET_assert (1 == *ok);
+  *ok = 8;
+  GNUNET_SCHEDULER_add_after (tc->sched,
+                              GNUNET_NO,
+                              GNUNET_SCHEDULER_PRIORITY_UI,
+                              0, &taskNeverRun, NULL);
+  GNUNET_SCHEDULER_add_after (tc->sched,
+                              GNUNET_YES,
+                              GNUNET_SCHEDULER_PRIORITY_UI,
+                              0, &taskLast, cls);
+  GNUNET_break (0 == PLIBC_KILL (getpid (), SIGTERM));
+}
+
+
+/**
+ * Main method, starts scheduler with task1,
+ * checks that "ok" is correct at the end.
+ */
+static int
+checkSignal ()
+{
+  int ok;
+
+  ok = 1;
+  GNUNET_SCHEDULER_run (&taskSig, &ok);
+  return ok;
+}
+
+
+
+
+static void
+taskCancel (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+{
+  int *ok = cls;
+
+  GNUNET_assert (1 == *ok);
+  *ok = 0;
+  GNUNET_SCHEDULER_cancel (tc->sched,
+                           GNUNET_SCHEDULER_add_after (tc->sched,
+                                                       GNUNET_NO,
+                                                       GNUNET_SCHEDULER_PRIORITY_UI,
+                                                       0,
+                                                       &taskNeverRun, NULL));
+}
+
+
+/**
+ * Main method, starts scheduler with task1,
+ * checks that "ok" is correct at the end.
+ */
+static int
+checkCancel ()
+{
+  int ok;
+
+  ok = 1;
+  GNUNET_SCHEDULER_run (&taskCancel, &ok);
+  return ok;
+}
+
+
+
+int
+main (int argc, char *argv[])
+{
+  int ret = 0;
+
+  GNUNET_log_setup ("test_scheduler", "WARNING", NULL);
+  ret += check ();
+  ret += checkSignal ();
+  ret += checkCancel ();
+
+  return ret;
+}
+
+/* end of test_scheduler.c */
diff --git a/src/util/test_scheduler_delay.c b/src/util/test_scheduler_delay.c
new file mode 100644
index 000000000..76cbf94d8
--- /dev/null
+++ b/src/util/test_scheduler_delay.c
@@ -0,0 +1,107 @@
+/*
+     This file is part of GNUnet.
+     (C) 2001, 2002, 2003, 2004, 2006 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 util/test_scheduler_delay.c
+ * @brief testcase for delay of scheduler, measures how
+ *  precise the timers are.  Expect values between 10 and 20 ms on
+ *  modern machines.
+ */
+#include "platform.h"
+#include "gnunet_common.h"
+#include "gnunet_scheduler_lib.h"
+#include "gnunet_time_lib.h"
+
+#define VERBOSE GNUNET_NO
+
+static struct GNUNET_TIME_Absolute target;
+
+static int i;
+
+static unsigned long long cumDelta;
+
+#define INCR 47
+
+#define MAXV 1500
+
+/**
+ * Signature of the main function of a task.
+ *
+ * @param cls closure
+ * @param tc context
+ */
+static void
+test_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+{
+  struct GNUNET_TIME_Absolute now;
+
+  now = GNUNET_TIME_absolute_get ();
+  if (now.value > target.value)
+    cumDelta += (now.value - target.value);
+  else
+    cumDelta += (target.value - now.value);
+  target =
+    GNUNET_TIME_relative_to_absolute (GNUNET_TIME_relative_multiply
+                                      (GNUNET_TIME_UNIT_MILLISECONDS, i));
+  fprintf (stderr, ".");
+  if (i > MAXV)
+    {
+      fprintf (stderr, "\n");
+      return;
+    }
+  GNUNET_SCHEDULER_add_delayed (tc->sched,
+                                GNUNET_NO,
+                                GNUNET_SCHEDULER_PRIORITY_DEFAULT,
+                                GNUNET_SCHEDULER_NO_PREREQUISITE_TASK,
+                                GNUNET_TIME_relative_multiply
+                                (GNUNET_TIME_UNIT_MILLISECONDS, i),
+                                &test_task, NULL);
+  i += INCR;
+}
+
+static int
+check ()
+{
+  target = GNUNET_TIME_absolute_get ();
+  GNUNET_SCHEDULER_run (&test_task, NULL);
+  FPRINTF (stdout,
+           "Sleep precision: %llu ms. ", cumDelta / 1000 / (MAXV / INCR));
+  if (cumDelta <= 10 * MAXV / INCR)
+    fprintf (stdout, "Timer precision is excellent.\n");
+  else if (cumDelta <= 50 * MAXV / INCR)        /* 50 ms average deviation */
+    fprintf (stdout, "Timer precision is good.\n");
+  else if (cumDelta > 250 * MAXV / INCR)
+    fprintf (stdout, "Timer precision is awful.\n");
+  else
+    fprintf (stdout, "Timer precision is acceptable.\n");
+  return 0;
+}
+
+int
+main (int argc, char *argv[])
+{
+  int ret;
+
+  GNUNET_log_setup ("test-scheduler-delay", "WARNING", NULL);
+  ret = check ();
+
+  return ret;
+}
+
+/* end of test_scheduler_delay.c */
diff --git a/src/util/test_server.c b/src/util/test_server.c
new file mode 100644
index 000000000..e3df0b456
--- /dev/null
+++ b/src/util/test_server.c
@@ -0,0 +1,287 @@
+/*
+     This file is part of GNUnet.
+     (C) 2009 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 util/test_server.c
+ * @brief tests for server.c
+ */
+#include "platform.h"
+#include "gnunet_common.h"
+#include "gnunet_scheduler_lib.h"
+#include "gnunet_server_lib.h"
+#include "gnunet_time_lib.h"
+
+#define VERBOSE GNUNET_NO
+
+#define PORT 12435
+
+#define MY_TYPE 128
+#define MY_TYPE2 129
+
+static struct GNUNET_SERVER_Handle *server;
+
+static struct GNUNET_SCHEDULER_Handle *sched;
+
+static void
+recv_fin_cb (void *cls,
+             struct GNUNET_SERVER_Handle *server,
+             struct GNUNET_SERVER_Client *client,
+             const struct GNUNET_MessageHeader *message)
+{
+  int *ok = cls;
+  GNUNET_assert (2 == *ok);
+  GNUNET_SERVER_receive_done (client, GNUNET_OK);
+  *ok = 3;
+}
+
+struct SignalTimeoutContext
+{
+  GNUNET_NETWORK_Receiver cb;
+  void *cb_cls;
+};
+
+
+static void
+signal_timeout (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+{
+  struct SignalTimeoutContext *stctx = cls;
+
+  stctx->cb (stctx->cb_cls, NULL, 0, NULL, 0, 0);
+  GNUNET_free (stctx);
+}
+
+
+static GNUNET_SCHEDULER_TaskIdentifier
+my_receive (void *cls,
+            size_t max,
+            struct GNUNET_TIME_Relative timeout,
+            GNUNET_NETWORK_Receiver receiver, void *receiver_cls)
+{
+  int *ok = cls;
+  struct GNUNET_MessageHeader msg;
+  struct SignalTimeoutContext *stctx;
+  GNUNET_SCHEDULER_TaskIdentifier ret;
+
+  ret = GNUNET_SCHEDULER_NO_PREREQUISITE_TASK;
+  switch (*ok)
+    {
+    case 1:
+      *ok = 2;                  /* report success */
+      msg.type = htons (MY_TYPE2);
+      msg.size = htons (sizeof (msg));
+      receiver (receiver_cls, &msg, sizeof (msg), NULL, 0, 0);
+      break;
+    case 3:
+      /* called after first receive instantly
+         produced a reply;
+         schedule receiver call with timeout
+         after timeout expires! */
+      *ok = 4;
+      stctx = GNUNET_malloc (sizeof (struct SignalTimeoutContext));
+      stctx->cb = receiver;
+      stctx->cb_cls = receiver_cls;
+      ret = GNUNET_SCHEDULER_add_delayed (sched,
+                                          GNUNET_NO,
+                                          GNUNET_SCHEDULER_PRIORITY_KEEP,
+                                          GNUNET_SCHEDULER_NO_PREREQUISITE_TASK,
+                                          timeout, &signal_timeout, stctx);
+      break;
+    default:
+      GNUNET_assert (0);
+    }
+  return ret;
+}
+
+
+static void
+my_cancel (void *cls, GNUNET_SCHEDULER_TaskIdentifier ti)
+{
+  GNUNET_SCHEDULER_cancel (sched, ti);
+}
+
+static void *
+my_transmit_ready_cb (void *cls,
+                      size_t size,
+                      struct GNUNET_TIME_Relative timeout,
+                      GNUNET_NETWORK_TransmitReadyNotify notify,
+                      void *notify_cls)
+{
+  static int non_null_addr;
+  int *ok = cls;
+  char buf[size];
+  struct GNUNET_MessageHeader msg;
+
+  GNUNET_assert (4 == *ok);
+  GNUNET_assert (size == sizeof (struct GNUNET_MessageHeader));
+  notify (notify_cls, size, buf);
+  msg.type = htons (MY_TYPE);
+  msg.size = htons (sizeof (msg));
+  GNUNET_assert (0 == memcmp (&msg, buf, size));
+  *ok = 5;                      /* report success */
+  return &non_null_addr;
+}
+
+
+static void
+my_transmit_ready_cancel_cb (void *cls, void *ctx)
+{
+  GNUNET_assert (0);
+}
+
+
+static int
+my_check (void *cls)
+{
+  return GNUNET_YES;
+}
+
+
+static void my_destroy (void *cls);
+
+
+struct CopyContext
+{
+  struct GNUNET_SERVER_Client *client;
+  struct GNUNET_MessageHeader *cpy;
+};
+
+static size_t
+copy_msg (void *cls, size_t size, void *buf)
+{
+  struct CopyContext *ctx = cls;
+  struct GNUNET_MessageHeader *cpy = ctx->cpy;
+  GNUNET_assert (sizeof (struct GNUNET_MessageHeader) == ntohs (cpy->size));
+  GNUNET_assert (size >= ntohs (cpy->size));
+  memcpy (buf, cpy, ntohs (cpy->size));
+  GNUNET_free (cpy);
+  GNUNET_free (ctx);
+  return sizeof (struct GNUNET_MessageHeader);
+}
+
+
+static void
+recv_cb (void *cls,
+         struct GNUNET_SERVER_Handle *server,
+         struct GNUNET_SERVER_Client *argclient,
+         const struct GNUNET_MessageHeader *message)
+{
+  struct GNUNET_SERVER_Client *client;
+  struct CopyContext *cc;
+  struct GNUNET_MessageHeader *cpy;
+
+  GNUNET_assert (argclient == NULL);
+  GNUNET_assert (sizeof (struct GNUNET_MessageHeader) ==
+                 ntohs (message->size));
+  GNUNET_assert (MY_TYPE == ntohs (message->type));
+  client = GNUNET_SERVER_connect_callback (server,
+                                           cls,
+                                           &my_receive,
+                                           &my_cancel,
+                                           &my_transmit_ready_cb,
+                                           &my_transmit_ready_cancel_cb,
+                                           &my_check, &my_destroy);
+  cc = GNUNET_malloc (sizeof (struct CopyContext));
+  cc->client = client;
+  cpy = GNUNET_malloc (ntohs (message->size));
+  memcpy (cpy, message, ntohs (message->size));
+  cc->cpy = cpy;
+  GNUNET_assert (NULL !=
+                 GNUNET_SERVER_notify_transmit_ready (client,
+                                                      ntohs (message->size),
+                                                      GNUNET_TIME_UNIT_SECONDS,
+                                                      &copy_msg, cc));
+  GNUNET_SERVER_client_drop (client);
+}
+
+
+static struct GNUNET_SERVER_MessageHandler handlers[] = {
+  {&recv_cb, NULL, MY_TYPE, sizeof (struct GNUNET_MessageHeader)},
+  {&recv_fin_cb, NULL, MY_TYPE2, sizeof (struct GNUNET_MessageHeader)},
+  {NULL, NULL, 0, 0}
+};
+
+
+static void
+my_destroy (void *cls)
+{
+  int *ok = cls;
+  GNUNET_assert (5 == *ok);
+  *ok = 0;                      /* report success */
+  /* this will cause us to terminate */
+  GNUNET_SERVER_destroy (server);
+}
+
+
+static void
+task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+{
+  struct sockaddr_in sa;
+  struct GNUNET_MessageHeader msg;
+
+  sched = tc->sched;
+  memset (&sa, 0, sizeof (sa));
+  sa.sin_family = AF_INET;
+  sa.sin_port = htons (PORT);
+  server = GNUNET_SERVER_create (tc->sched,
+                                 NULL,
+                                 NULL,
+                                 (const struct sockaddr *) &sa,
+                                 sizeof (sa),
+                                 1024,
+                                 GNUNET_TIME_relative_multiply
+                                 (GNUNET_TIME_UNIT_MILLISECONDS, 250),
+                                 GNUNET_NO);
+  GNUNET_assert (server != NULL);
+  handlers[0].callback_cls = cls;
+  handlers[1].callback_cls = cls;
+  GNUNET_SERVER_add_handlers (server, handlers);
+  msg.type = htons (MY_TYPE);
+  msg.size = htons (sizeof (msg));
+  GNUNET_SERVER_inject (server, NULL, &msg);
+  memset (&msg, 0, sizeof (msg));
+}
+
+
+/**
+ * Main method, starts scheduler with task1,
+ * checks that "ok" is correct at the end.
+ */
+static int
+check ()
+{
+  int ok;
+
+  ok = 1;
+  GNUNET_SCHEDULER_run (&task, &ok);
+  return ok;
+}
+
+
+int
+main (int argc, char *argv[])
+{
+  int ret = 0;
+
+  GNUNET_log_setup ("test_server", "WARNING", NULL);
+  ret += check ();
+
+  return ret;
+}
+
+/* end of test_server.c */
diff --git a/src/util/test_server_disconnect.c b/src/util/test_server_disconnect.c
new file mode 100644
index 000000000..60604b35c
--- /dev/null
+++ b/src/util/test_server_disconnect.c
@@ -0,0 +1,241 @@
+/*
+     This file is part of GNUnet.
+     (C) 2009 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 util/test_server_disconnect.c
+ * @brief tests for server.c and client.c,
+ *       specifically client_disconnect
+ */
+#include "platform.h"
+#include "gnunet_common.h"
+#include "gnunet_scheduler_lib.h"
+#include "gnunet_client_lib.h"
+#include "gnunet_server_lib.h"
+#include "gnunet_time_lib.h"
+
+#define VERBOSE GNUNET_NO
+
+#define PORT 22335
+
+#define MY_TYPE 128
+
+
+static struct GNUNET_SERVER_Handle *server;
+
+static struct GNUNET_CLIENT_Connection *client;
+
+static struct GNUNET_SCHEDULER_Handle *sched;
+
+static struct GNUNET_CONFIGURATION_Handle *cfg;
+
+static int ok;
+
+static void
+send_done (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+{
+  struct GNUNET_SERVER_Client *argclient = cls;
+  GNUNET_assert (ok == 3);
+  ok++;
+  GNUNET_SERVER_receive_done (argclient, GNUNET_OK);
+}
+
+static void
+server_disconnect (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+{
+  struct GNUNET_SERVER_Client *argclient = cls;
+  GNUNET_assert (ok == 5);
+  ok++;
+  GNUNET_SERVER_client_disconnect (argclient);
+}
+
+
+static void
+recv_cb (void *cls,
+         struct GNUNET_SERVER_Handle *server,
+         struct GNUNET_SERVER_Client *argclient,
+         const struct GNUNET_MessageHeader *message)
+{
+  void *addr;
+  size_t addrlen;
+  struct sockaddr_in sa;
+  struct sockaddr_in *have;
+
+  GNUNET_assert (GNUNET_OK ==
+                 GNUNET_SERVER_client_get_address (argclient,
+                                                   &addr, &addrlen));
+
+  GNUNET_assert (addrlen == sizeof (struct sockaddr_in));
+  have = addr;
+  memset (&sa, 0, sizeof (sa));
+  sa.sin_family = AF_INET;
+  sa.sin_port = have->sin_port;
+  sa.sin_addr.s_addr = htonl (INADDR_LOOPBACK);
+  GNUNET_assert (0 == memcmp (&sa, addr, addrlen));
+  GNUNET_free (addr);
+  switch (ok)
+    {
+    case 2:
+      ok++;
+      GNUNET_SCHEDULER_add_delayed (sched,
+                                    GNUNET_YES,
+                                    GNUNET_SCHEDULER_PRIORITY_KEEP,
+                                    GNUNET_SCHEDULER_NO_PREREQUISITE_TASK,
+                                    GNUNET_TIME_relative_multiply
+                                    (GNUNET_TIME_UNIT_MILLISECONDS, 50),
+                                    &send_done, argclient);
+      break;
+    case 4:
+      ok++;
+      GNUNET_SCHEDULER_add_delayed (sched,
+                                    GNUNET_YES,
+                                    GNUNET_SCHEDULER_PRIORITY_KEEP,
+                                    GNUNET_SCHEDULER_NO_PREREQUISITE_TASK,
+                                    GNUNET_TIME_relative_multiply
+                                    (GNUNET_TIME_UNIT_MILLISECONDS, 50),
+                                    &server_disconnect, argclient);
+      GNUNET_SERVER_receive_done (argclient, GNUNET_OK);
+      break;
+    default:
+      GNUNET_assert (0);
+    }
+
+}
+
+static void
+disconnect_notify (void *cls, const struct GNUNET_MessageHeader *msg)
+{
+  GNUNET_assert (msg == NULL);
+  GNUNET_assert (ok == 7);
+  ok = 0;
+  GNUNET_CLIENT_disconnect (client);
+  GNUNET_SCHEDULER_shutdown (sched);
+  GNUNET_CONFIGURATION_destroy (cfg);
+}
+
+
+/**
+ * Functions with this signature are called whenever a client
+ * is disconnected on the network level.
+ *
+ * @param cls closure
+ * @param client identification of the client
+ */
+static void
+notify_disconnect (void *cls, struct GNUNET_SERVER_Client *clientarg)
+{
+  GNUNET_assert (ok == 6);
+  ok++;
+  GNUNET_CLIENT_receive (client,
+                         &disconnect_notify,
+                         NULL, GNUNET_TIME_UNIT_FOREVER_REL);
+}
+
+
+static size_t
+notify_ready (void *cls, size_t size, void *buf)
+{
+  struct GNUNET_MessageHeader *msg;
+
+  GNUNET_assert (size >= 256);
+  GNUNET_assert (1 == ok);
+  ok++;
+  msg = buf;
+  msg->type = htons (MY_TYPE);
+  msg->size = htons (sizeof (struct GNUNET_MessageHeader));
+  msg++;
+  msg->type = htons (MY_TYPE);
+  msg->size = htons (sizeof (struct GNUNET_MessageHeader));
+  return 2 * sizeof (struct GNUNET_MessageHeader);
+}
+
+
+static struct GNUNET_SERVER_MessageHandler handlers[] = {
+  {&recv_cb, NULL, MY_TYPE, sizeof (struct GNUNET_MessageHeader)},
+  {NULL, NULL, 0, 0}
+};
+
+
+static void
+task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+{
+  struct sockaddr_in sa;
+
+  sched = tc->sched;
+  memset (&sa, 0, sizeof (sa));
+  sa.sin_family = AF_INET;
+  sa.sin_port = htons (PORT);
+  server = GNUNET_SERVER_create (tc->sched,
+                                 NULL,
+                                 NULL,
+                                 (const struct sockaddr *) &sa,
+                                 sizeof (sa),
+                                 1024,
+                                 GNUNET_TIME_relative_multiply
+                                 (GNUNET_TIME_UNIT_MILLISECONDS, 250),
+                                 GNUNET_NO);
+  GNUNET_assert (server != NULL);
+  handlers[0].callback_cls = cls;
+  GNUNET_SERVER_add_handlers (server, handlers);
+  GNUNET_SERVER_disconnect_notify (server, &notify_disconnect, cls);
+  cfg = GNUNET_CONFIGURATION_create ();
+  GNUNET_CONFIGURATION_set_value_number (cfg, "test", "PORT", PORT);
+  GNUNET_CONFIGURATION_set_value_string (cfg, "test", "HOSTNAME",
+                                         "localhost");
+  client = GNUNET_CLIENT_connect (tc->sched, "test", cfg);
+  GNUNET_assert (client != NULL);
+  GNUNET_CLIENT_notify_transmit_ready (client,
+                                       256,
+                                       GNUNET_TIME_relative_multiply
+                                       (GNUNET_TIME_UNIT_MILLISECONDS, 250),
+                                       &notify_ready, NULL);
+}
+
+
+/**
+ * Main method, starts scheduler with task1,
+ * checks that "ok" is correct at the end.
+ */
+static int
+check ()
+{
+
+  ok = 1;
+  GNUNET_SCHEDULER_run (&task, NULL);
+  return ok;
+}
+
+
+int
+main (int argc, char *argv[])
+{
+  int ret = 0;
+
+  GNUNET_log_setup ("test_server_disconnect",
+#if VERBOSE
+                    "DEBUG",
+#else
+                    "WARNING",
+#endif
+                    NULL);
+  ret += check ();
+
+  return ret;
+}
+
+/* end of test_server_disconnect.c */
diff --git a/src/util/test_server_with_client.c b/src/util/test_server_with_client.c
new file mode 100644
index 000000000..4ca2b5bc3
--- /dev/null
+++ b/src/util/test_server_with_client.c
@@ -0,0 +1,215 @@
+/*
+     This file is part of GNUnet.
+     (C) 2009 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 util/test_server_with_client.c
+ * @brief tests for server.c and client.c,
+ *       specifically disconnect_notify,
+ *       client_get_address and receive_done (resume processing)
+ */
+#include "platform.h"
+#include "gnunet_common.h"
+#include "gnunet_scheduler_lib.h"
+#include "gnunet_client_lib.h"
+#include "gnunet_server_lib.h"
+#include "gnunet_time_lib.h"
+
+#define VERBOSE GNUNET_NO
+
+#define PORT 22335
+
+#define MY_TYPE 128
+
+
+static struct GNUNET_SERVER_Handle *server;
+
+static struct GNUNET_CLIENT_Connection *client;
+
+static struct GNUNET_SCHEDULER_Handle *sched;
+
+static struct GNUNET_CONFIGURATION_Handle *cfg;
+
+static int ok;
+
+static void
+send_done (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+{
+  struct GNUNET_SERVER_Client *argclient = cls;
+  GNUNET_assert (ok == 3);
+  ok++;
+  GNUNET_SERVER_receive_done (argclient, GNUNET_OK);
+}
+
+
+static void
+recv_cb (void *cls,
+         struct GNUNET_SERVER_Handle *server,
+         struct GNUNET_SERVER_Client *argclient,
+         const struct GNUNET_MessageHeader *message)
+{
+  void *addr;
+  size_t addrlen;
+  struct sockaddr_in sa;
+  struct sockaddr_in *have;
+
+  GNUNET_assert (GNUNET_OK ==
+                 GNUNET_SERVER_client_get_address (argclient,
+                                                   &addr, &addrlen));
+
+  GNUNET_assert (addrlen == sizeof (struct sockaddr_in));
+  have = addr;
+  memset (&sa, 0, sizeof (sa));
+  sa.sin_family = AF_INET;
+  sa.sin_port = have->sin_port;
+  sa.sin_addr.s_addr = htonl (INADDR_LOOPBACK);
+  GNUNET_assert (0 == memcmp (&sa, addr, addrlen));
+  GNUNET_free (addr);
+  switch (ok)
+    {
+    case 2:
+      ok++;
+      GNUNET_SCHEDULER_add_delayed (sched,
+                                    GNUNET_YES,
+                                    GNUNET_SCHEDULER_PRIORITY_KEEP,
+                                    GNUNET_SCHEDULER_NO_PREREQUISITE_TASK,
+                                    GNUNET_TIME_relative_multiply
+                                    (GNUNET_TIME_UNIT_MILLISECONDS, 50),
+                                    &send_done, argclient);
+      break;
+    case 4:
+      ok++;
+      GNUNET_CLIENT_disconnect (client);
+      GNUNET_SERVER_receive_done (argclient, GNUNET_OK);
+      break;
+    default:
+      GNUNET_assert (0);
+    }
+
+}
+
+
+/**
+ * Functions with this signature are called whenever a client
+ * is disconnected on the network level.
+ *
+ * @param cls closure
+ * @param client identification of the client
+ */
+static void
+notify_disconnect (void *cls, struct GNUNET_SERVER_Client *client)
+{
+  GNUNET_assert (ok == 5);
+  ok = 0;
+  GNUNET_SCHEDULER_shutdown (sched);
+  GNUNET_CONFIGURATION_destroy (cfg);
+}
+
+
+static size_t
+notify_ready (void *cls, size_t size, void *buf)
+{
+  struct GNUNET_MessageHeader *msg;
+
+  GNUNET_assert (size >= 256);
+  GNUNET_assert (1 == ok);
+  ok++;
+  msg = buf;
+  msg->type = htons (MY_TYPE);
+  msg->size = htons (sizeof (struct GNUNET_MessageHeader));
+  msg++;
+  msg->type = htons (MY_TYPE);
+  msg->size = htons (sizeof (struct GNUNET_MessageHeader));
+  return 2 * sizeof (struct GNUNET_MessageHeader);
+}
+
+
+static struct GNUNET_SERVER_MessageHandler handlers[] = {
+  {&recv_cb, NULL, MY_TYPE, sizeof (struct GNUNET_MessageHeader)},
+  {NULL, NULL, 0, 0}
+};
+
+
+static void
+task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+{
+  struct sockaddr_in sa;
+
+  sched = tc->sched;
+  memset (&sa, 0, sizeof (sa));
+  sa.sin_family = AF_INET;
+  sa.sin_port = htons (PORT);
+  server = GNUNET_SERVER_create (tc->sched,
+                                 NULL,
+                                 NULL,
+                                 (const struct sockaddr *) &sa,
+                                 sizeof (sa),
+                                 1024,
+                                 GNUNET_TIME_relative_multiply
+                                 (GNUNET_TIME_UNIT_MILLISECONDS, 250),
+                                 GNUNET_NO);
+  GNUNET_assert (server != NULL);
+  handlers[0].callback_cls = cls;
+  GNUNET_SERVER_add_handlers (server, handlers);
+  GNUNET_SERVER_disconnect_notify (server, &notify_disconnect, cls);
+  cfg = GNUNET_CONFIGURATION_create ();
+  GNUNET_CONFIGURATION_set_value_number (cfg, "test", "PORT", PORT);
+  GNUNET_CONFIGURATION_set_value_string (cfg, "test", "HOSTNAME",
+                                         "localhost");
+  client = GNUNET_CLIENT_connect (tc->sched, "test", cfg);
+  GNUNET_assert (client != NULL);
+  GNUNET_CLIENT_notify_transmit_ready (client,
+                                       256,
+                                       GNUNET_TIME_relative_multiply
+                                       (GNUNET_TIME_UNIT_MILLISECONDS, 250),
+                                       &notify_ready, NULL);
+}
+
+
+/**
+ * Main method, starts scheduler with task1,
+ * checks that "ok" is correct at the end.
+ */
+static int
+check ()
+{
+
+  ok = 1;
+  GNUNET_SCHEDULER_run (&task, NULL);
+  return ok;
+}
+
+
+int
+main (int argc, char *argv[])
+{
+  int ret = 0;
+
+  GNUNET_log_setup ("test_server_with_client",
+#if VERBOSE
+                    "DEBUG",
+#else
+                    "WARNING",
+#endif
+                    NULL);
+  ret += check ();
+
+  return ret;
+}
+
+/* end of test_server_with_client.c */
diff --git a/src/util/test_service.c b/src/util/test_service.c
new file mode 100644
index 000000000..b5cf0805e
--- /dev/null
+++ b/src/util/test_service.c
@@ -0,0 +1,337 @@
+/*
+     This file is part of GNUnet.
+     (C) 2009 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 util/test_service.c
+ * @brief tests for service.c
+ */
+#include "platform.h"
+#include "gnunet_common.h"
+#include "gnunet_client_lib.h"
+#include "gnunet_getopt_lib.h"
+#include "gnunet_program_lib.h"
+#include "gnunet_service_lib.h"
+#include "gnunet_scheduler_lib.h"
+#include "gnunet_time_lib.h"
+
+#define VERBOSE GNUNET_NO
+
+#define PORT 12435
+
+#define MY_TYPE 256
+
+static struct GNUNET_SCHEDULER_Handle *sched;
+
+static struct GNUNET_SERVICE_Context *sctx;
+
+static void
+end_it (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+{
+  struct GNUNET_CLIENT_Connection *client = cls;
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Shutting down service\n");
+  GNUNET_CLIENT_service_shutdown (client);
+  GNUNET_CLIENT_disconnect (client);
+  if (sctx != NULL)
+    GNUNET_SERVICE_stop (sctx);
+}
+
+
+static size_t
+build_msg (void *cls, size_t size, void *buf)
+{
+  struct GNUNET_CLIENT_Connection *client = cls;
+  struct GNUNET_MessageHeader *msg = buf;
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Client connected, transmitting\n");
+  GNUNET_assert (size >= sizeof (struct GNUNET_MessageHeader));
+  msg->type = htons (MY_TYPE);
+  msg->size = htons (sizeof (msg));
+  GNUNET_SCHEDULER_add_continuation (sched,
+                                     GNUNET_YES,
+                                     &end_it,
+                                     client,
+                                     GNUNET_SCHEDULER_REASON_PREREQ_DONE);
+  return sizeof (struct GNUNET_MessageHeader);
+}
+
+static void
+ready (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+{
+  struct GNUNET_CONFIGURATION_Handle *cfg = cls;
+  struct GNUNET_CLIENT_Connection *client;
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Service confirmed running\n");
+  sched = tc->sched;
+  GNUNET_assert (0 != (tc->reason & GNUNET_SCHEDULER_REASON_PREREQ_DONE));
+  client = GNUNET_CLIENT_connect (tc->sched, "test_service", cfg);
+  GNUNET_assert (client != NULL);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Client connecting, waiting to transmit\n");
+  GNUNET_CLIENT_notify_transmit_ready (client,
+                                       sizeof (struct GNUNET_MessageHeader),
+                                       GNUNET_TIME_UNIT_SECONDS,
+                                       &build_msg, client);
+}
+
+static void
+recv_cb (void *cls,
+         struct GNUNET_SERVER_Handle *server,
+         struct GNUNET_SERVER_Client *client,
+         const struct GNUNET_MessageHeader *message)
+{
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Receiving client message...\n");
+  GNUNET_SERVER_receive_done (client, GNUNET_OK);
+}
+
+static struct GNUNET_SERVER_MessageHandler myhandlers[] = {
+  {&recv_cb, NULL, MY_TYPE, sizeof (struct GNUNET_MessageHeader)},
+  {NULL, NULL, 0, 0}
+};
+
+static void
+runner (void *cls,
+        struct GNUNET_SCHEDULER_Handle *sched,
+        struct GNUNET_SERVER_Handle *server,
+        struct GNUNET_CONFIGURATION_Handle *cfg)
+{
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Service initializing\n");
+  GNUNET_SERVER_add_handlers (server, myhandlers);
+  GNUNET_CLIENT_service_test (sched,
+                              "test_service",
+                              cfg, GNUNET_TIME_UNIT_SECONDS, &ready, cfg);
+}
+
+static void
+term (void *cls, struct GNUNET_CONFIGURATION_Handle *cfg)
+{
+  int *ok = cls;
+  *ok = 0;
+}
+
+/**
+ * Main method, starts scheduler with task1,
+ * checks that "ok" is correct at the end.
+ */
+static int
+check ()
+{
+  int ok = 1;
+  char *const argv[] = {
+    "test_service",
+    "-c",
+    "test_service_data.conf",
+    "-L",
+#if VERBOSE
+    "DEBUG",
+#else
+    "WARNING",
+#endif
+    NULL
+  };
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Starting service\n");
+  GNUNET_assert (GNUNET_OK ==
+                 GNUNET_SERVICE_run (5,
+                                     argv,
+                                     "test_service",
+                                     &runner, &ok, &term, &ok));
+  GNUNET_assert (0 == ok);
+  return ok;
+}
+
+static void
+ready6 (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+{
+  struct GNUNET_CONFIGURATION_Handle *cfg = cls;
+  struct GNUNET_CLIENT_Connection *client;
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "V6 ready\n");
+  sched = tc->sched;
+  GNUNET_assert (0 != (tc->reason & GNUNET_SCHEDULER_REASON_PREREQ_DONE));
+  client = GNUNET_CLIENT_connect (tc->sched, "test_service6", cfg);
+  GNUNET_assert (client != NULL);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "V6 client connected\n");
+  GNUNET_CLIENT_notify_transmit_ready (client,
+                                       sizeof (struct GNUNET_MessageHeader),
+                                       GNUNET_TIME_UNIT_SECONDS,
+                                       &build_msg, client);
+}
+
+static void
+runner6 (void *cls,
+         struct GNUNET_SCHEDULER_Handle *sched,
+         struct GNUNET_SERVER_Handle *server,
+         struct GNUNET_CONFIGURATION_Handle *cfg)
+{
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Initializing v6 service\n");
+  GNUNET_SERVER_add_handlers (server, myhandlers);
+  GNUNET_CLIENT_service_test (sched,
+                              "test_service6",
+                              cfg, GNUNET_TIME_UNIT_SECONDS, &ready6, cfg);
+}
+
+/**
+ * Main method, starts scheduler with task1,
+ * checks that "ok" is correct at the end.
+ */
+static int
+check6 ()
+{
+  int ok = 1;
+  char *const argv[] = {
+    "test_service6",
+    "-c",
+    "test_service_data.conf",
+    "-L",
+#if VERBOSE
+    "DEBUG",
+#else
+    "WARNING",
+#endif
+    NULL
+  };
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Starting v6 service\n");
+  GNUNET_assert (GNUNET_OK ==
+                 GNUNET_SERVICE_run (5,
+                                     argv,
+                                     "test_service6",
+                                     &runner6, &ok, &term, &ok));
+  GNUNET_assert (0 == ok);
+  return ok;
+}
+
+
+/**
+ * Main method, starts scheduler with task1,
+ * checks that "ok" is correct at the end.
+ */
+static int
+check6d ()
+{
+  int ok = 1;
+  char *const argv[] = {
+    "test_service6",
+    "-c",
+    "test_service_data.conf",
+    "-L",
+#if VERBOSE
+    "DEBUG",
+#else
+    "WARNING",
+#endif
+    "-d",
+    NULL
+  };
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Starting V6 as daemon\n");
+  GNUNET_assert (GNUNET_OK ==
+                 GNUNET_SERVICE_run (6,
+                                     argv,
+                                     "test_service6",
+                                     &runner6, &ok, &term, &ok));
+  GNUNET_break (0 == ok);
+  return ok;
+}
+
+
+static void
+start_stop_main (void *cls,
+                 struct GNUNET_SCHEDULER_Handle *sched,
+                 char *const *args,
+                 const char *cfgfile, struct GNUNET_CONFIGURATION_Handle *cfg)
+{
+  int *ret = cls;
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Starting service using start method\n");
+  sctx = GNUNET_SERVICE_start ("test_service", sched, cfg);
+  runner (cls, sched, GNUNET_SERVICE_get_server (sctx), cfg);
+  *ret = 0;
+}
+
+
+static int
+check_start_stop ()
+{
+  char *const argv[] = {
+    "test-service-program",
+    "-c",
+    "test_service_data.conf",
+    "-L",
+#if VERBOSE
+    "DEBUG",
+#else
+    "WARNING",
+#endif
+    NULL
+  };
+  const struct GNUNET_GETOPT_CommandLineOption options[] = {
+    GNUNET_GETOPT_OPTION_END
+  };
+  int ret = 1;
+  GNUNET_assert (GNUNET_OK ==
+                 GNUNET_PROGRAM_run (5,
+                                     argv,
+                                     "test-service-program",
+                                     "no help",
+                                     options, &start_stop_main, &ret));
+
+  GNUNET_break (0 == ret);
+  return ret;
+}
+
+
+int
+main (int argc, char *argv[])
+{
+  int ret = 0;
+  int s;
+
+  GNUNET_log_setup ("test-service",
+#if VERBOSE
+                    "DEBUG",
+#else
+                    "WARNING",
+#endif
+                    NULL);
+  ret += check ();
+  ret += check ();
+  s = SOCKET (PF_INET6, SOCK_STREAM, 0);
+  if (s == -1)
+    {
+      if ((errno == ENOBUFS) ||
+          (errno == ENOMEM) || (errno == ENFILE) || (errno == EACCES))
+        {
+          GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "socket");
+          return 1;
+        }
+      fprintf (stderr,
+               "IPv6 support seems to not be available (%s), not testing it!\n",
+               strerror (errno));
+    }
+  else
+    {
+      GNUNET_break (0 == CLOSE (s));
+      ret += check6 ();
+      ret += check6d ();        /* with daemonization */
+    }
+  ret += check_start_stop ();
+
+  return ret;
+}
+
+/* end of test_service.c */
diff --git a/src/util/test_service_data.conf b/src/util/test_service_data.conf
new file mode 100644
index 000000000..92c723619
--- /dev/null
+++ b/src/util/test_service_data.conf
@@ -0,0 +1,26 @@
+[test_service]
+PORT=12435
+BINDTO=localhost
+PIDFILE=/tmp/test-service.pid
+TIMEOUT=30000
+MAXBUF=1024
+DISABLEV6=NO
+ACCEPT_FROM=127.0.0.1;
+REJECT_FROM=1.2.3.0/15;4.5.0.0/8;6.7.8.9/255.255.255.0;
+ACCEPT_FROM6=::1;
+REJECT_FROM6=AB:CD:EF::00;AB:CD::00/40;
+HOSTNAME=localhost
+ALLOW_SHUTDOWN=YES
+
+[test_service6]
+PORT=12435
+PIDFILE=/tmp/test-service.pid
+TIMEOUT=30000
+MAXBUF=1024
+DISABLEV6=NO
+ACCEPT_FROM=127.0.0.1;
+REJECT_FROM=1.2.3.0/15;4.5.0.0/8;6.7.8.9/255.255.255.0;
+ACCEPT_FROM6=::1;
+REJECT_FROM6=AB:CD:EF::00;AB:CD::00/40;
+HOSTNAME=::1
+ALLOW_SHUTDOWN=YES
diff --git a/src/util/test_strings.c b/src/util/test_strings.c
new file mode 100644
index 000000000..be166e629
--- /dev/null
+++ b/src/util/test_strings.c
@@ -0,0 +1,111 @@
+/*
+     This file is part of GNUnet.
+     (C) 2009 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 util/test_strings.c
+ * @brief testcase for strings.c
+ */
+#include "platform.h"
+#include "gnunet_common.h"
+#include "gnunet_strings_lib.h"
+
+#define VERBOSE GNUNET_NO
+
+#define WANT(a,b) if (0 != strcmp(a,b)) { fprintf(stderr, "Got `%s', wanted `%s'\n", b, a); GNUNET_free(b); GNUNET_break(0); return 1;} else { GNUNET_free (b); }
+#define WANTB(a,b,l) if (0 != memcmp(a,b,l)) { GNUNET_break(0); return 1;} else { }
+
+static int
+check ()
+{
+  char buf[128];
+  char *r;
+  char *b;
+  struct GNUNET_TIME_Absolute at;
+
+  sprintf (buf, "4%s", _( /* size unit */ "b"));
+  b = GNUNET_STRINGS_byte_size_fancy (4);
+  WANT (buf, b);
+  sprintf (buf, "10%s", _( /* size unit */ "KiB"));
+  b = GNUNET_STRINGS_byte_size_fancy (10240);
+  WANT (buf, b);
+  sprintf (buf, "10%s", _( /* size unit */ "TiB"));
+  b = GNUNET_STRINGS_byte_size_fancy (10240LL * 1024LL * 1024LL * 1024LL);
+  WANT (buf, b);
+  sprintf (buf, "4%s", _( /* time unit */ "ms"));
+  b =
+    GNUNET_STRINGS_relative_time_to_string (GNUNET_TIME_relative_multiply
+                                            (GNUNET_TIME_UNIT_MILLISECONDS,
+                                             4));
+  WANT (buf, b);
+  sprintf (buf, "7%s", _( /* time unit */ "s"));
+  b =
+    GNUNET_STRINGS_relative_time_to_string (GNUNET_TIME_relative_multiply
+                                            (GNUNET_TIME_UNIT_MILLISECONDS,
+                                             7 * 1000));
+  WANT (buf, b);
+  sprintf (buf, "7%s", _( /* time unit */ "h"));
+  b =
+    GNUNET_STRINGS_relative_time_to_string (GNUNET_TIME_relative_multiply
+                                            (GNUNET_TIME_UNIT_MILLISECONDS,
+                                             7 * 60 * 60 * 1000));
+  WANT (buf, b);
+  sprintf (buf, "%s%s", getenv ("HOME"), DIR_SEPARATOR_STR);
+  b = GNUNET_STRINGS_filename_expand ("~");
+  WANT (buf, b);
+  GNUNET_STRINGS_buffer_fill (buf, sizeof (buf), 3, "a", "btx", "c");
+  WANTB ("a\0btx\0c", buf, 8);
+  if (6 != GNUNET_STRINGS_buffer_tokenize (buf, sizeof (buf), 2, &r, &b))
+    return 1;
+  r = GNUNET_strdup (r);
+  WANT ("a", r);
+  b = GNUNET_strdup (b);
+  WANT ("btx", b);
+  if (0 != GNUNET_STRINGS_buffer_tokenize (buf, 2, 2, &r, &b))
+    return 1;
+  at.value = 5000;
+  r = GNUNET_STRINGS_absolute_time_to_string (at);
+  /* r should be something like "Wed Dec 31 17:00:05 1969"
+     where the details of the day and hour depend on the timezone;
+     however, the "0:05 19" should always be there; hence: */
+  if (NULL == strstr (r, "0:05 19"))
+    {
+      fprintf (stderr, "Got %s\n", r);
+      GNUNET_break (0);
+      GNUNET_free (r);
+      return 1;
+    }
+  b = GNUNET_STRINGS_to_utf8 ("TEST", 4, "ASCII");
+  WANT ("TEST", b);
+  b = GNUNET_STRINGS_to_utf8 ("TEST", 4, "unknown");
+  WANT ("TEST", b);
+  GNUNET_free (r);
+  return 0;
+}
+
+int
+main (int argc, char *argv[])
+{
+  int ret;
+
+  GNUNET_log_setup ("test_strings", "ERROR", NULL);
+  ret = check ();
+  return ret;
+}
+
+/* end of test_strings.c */
diff --git a/src/util/test_time.c b/src/util/test_time.c
new file mode 100644
index 000000000..9505952c2
--- /dev/null
+++ b/src/util/test_time.c
@@ -0,0 +1,122 @@
+/*
+     This file is part of GNUnet.
+     (C) 2001, 2002, 2003, 2004, 2006, 2009 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 util/test_time.c
+ * @brief testcase for time.c
+ */
+#include "platform.h"
+#include "gnunet_common.h"
+#include "gnunet_time_lib.h"
+
+#define VERBOSE GNUNET_NO
+
+static int
+check ()
+{
+  struct GNUNET_TIME_Absolute now;
+  struct GNUNET_TIME_AbsoluteNBO nown;
+  struct GNUNET_TIME_Absolute future;
+  struct GNUNET_TIME_Absolute past;
+  struct GNUNET_TIME_Absolute last;
+  struct GNUNET_TIME_Relative rel;
+  struct GNUNET_TIME_RelativeNBO reln;
+  unsigned int i;
+
+  last = now = GNUNET_TIME_absolute_get ();
+  while (now.value == last.value)
+    now = GNUNET_TIME_absolute_get ();
+  GNUNET_assert (now.value > last.value);
+
+  /* test overflow checking in multiply */
+  rel = GNUNET_TIME_UNIT_SECONDS;
+  GNUNET_log_skip (1);
+  for (i = 0; i < 55; i++)
+    rel = GNUNET_TIME_relative_multiply (rel, 2);
+  GNUNET_log_skip (0);
+  GNUNET_assert (rel.value == GNUNET_TIME_UNIT_FOREVER_REL.value);
+
+  /* test infinity-check for relative to absolute */
+  last = GNUNET_TIME_relative_to_absolute (rel);
+  GNUNET_assert (last.value == GNUNET_TIME_UNIT_FOREVER_ABS.value);
+
+  /* check overflow for r2a */
+  rel.value = ((uint64_t) - 1LL) - 1024;
+  GNUNET_log_skip (1);
+  last = GNUNET_TIME_relative_to_absolute (rel);
+  GNUNET_log_skip (0);
+  GNUNET_assert (last.value == GNUNET_TIME_UNIT_FOREVER_ABS.value);
+
+  /* check overflow for relative add */
+  GNUNET_log_skip (1);
+  rel = GNUNET_TIME_relative_add (rel, rel);
+  GNUNET_log_skip (0);
+  GNUNET_assert (rel.value == GNUNET_TIME_UNIT_FOREVER_REL.value);
+
+  /* check relation check in get_duration */
+  future.value = now.value + 1000000;
+  GNUNET_assert (GNUNET_TIME_absolute_get_difference (now, future).value ==
+                 1000000);
+  GNUNET_assert (GNUNET_TIME_absolute_get_difference (future, now).value ==
+                 0);
+
+  past.value = now.value - 1000000;
+  rel = GNUNET_TIME_absolute_get_duration (future);
+  GNUNET_assert (rel.value == 0);
+  rel = GNUNET_TIME_absolute_get_duration (past);
+  GNUNET_assert (rel.value >= 1000000);
+
+  /* check get remaining */
+  rel = GNUNET_TIME_absolute_get_remaining (now);
+  GNUNET_assert (rel.value == 0);
+  rel = GNUNET_TIME_absolute_get_remaining (past);
+  GNUNET_assert (rel.value == 0);
+  rel = GNUNET_TIME_absolute_get_remaining (future);
+  GNUNET_assert (rel.value > 0);
+  GNUNET_assert (rel.value <= 1000000);
+
+  /* check endianess */
+  reln = GNUNET_TIME_relative_hton (rel);
+  GNUNET_assert (rel.value == GNUNET_TIME_relative_ntoh (reln).value);
+  nown = GNUNET_TIME_absolute_hton (now);
+  GNUNET_assert (now.value == GNUNET_TIME_absolute_ntoh (nown).value);
+
+  /* check absolute addition */
+  future = GNUNET_TIME_absolute_add (now, GNUNET_TIME_UNIT_SECONDS);
+  GNUNET_assert (future.value == now.value + 1000);
+
+  /* check zero */
+  future = GNUNET_TIME_absolute_add (now, GNUNET_TIME_UNIT_ZERO);
+  GNUNET_assert (future.value == now.value);
+
+  return 0;
+}
+
+int
+main (int argc, char *argv[])
+{
+  int ret;
+
+  GNUNET_log_setup ("test-time", "WARNING", NULL);
+  ret = check ();
+
+  return ret;
+}
+
+/* end of test_time.c */
diff --git a/src/util/time.c b/src/util/time.c
new file mode 100644
index 000000000..3ae472561
--- /dev/null
+++ b/src/util/time.c
@@ -0,0 +1,286 @@
+/*
+     This file is part of GNUnet.
+     (C) 2001, 2002, 2006, 2009 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 util/time.c
+ * @author Christian Grothoff
+ * @brief functions for handling time and time arithmetic
+ */
+#include "platform.h"
+#include "gnunet_time_lib.h"
+
+
+/**
+ * Get the current time (works just as "time", just that we use the
+ * unit of time that the cron-jobs use (and is 64 bit)).
+ *
+ * @return the current time
+ */
+struct GNUNET_TIME_Absolute
+GNUNET_TIME_absolute_get ()
+{
+  struct GNUNET_TIME_Absolute ret;
+  struct timeval tv;
+
+  gettimeofday (&tv, NULL);
+  ret.value = tv.tv_sec * 1000 + tv.tv_usec / 1000;
+  return ret;
+}
+
+
+/**
+ * Return relative time of 0ms.
+ */
+struct GNUNET_TIME_Relative
+GNUNET_TIME_relative_get_zero ()
+{
+  static struct GNUNET_TIME_Relative zero;
+  return zero;
+}
+
+/**
+ * Return relative time of 1ms.
+ */
+struct GNUNET_TIME_Relative
+GNUNET_TIME_relative_get_unit ()
+{
+  static struct GNUNET_TIME_Relative one = { 1 };
+  return one;
+}
+
+/**
+ * Return "forever".
+ */
+struct GNUNET_TIME_Relative
+GNUNET_TIME_relative_get_forever ()
+{
+  static struct GNUNET_TIME_Relative forever = { (uint64_t) - 1LL };
+  return forever;
+}
+
+/**
+ * Return "forever".
+ */
+struct GNUNET_TIME_Absolute
+GNUNET_TIME_absolute_get_forever ()
+{
+  static struct GNUNET_TIME_Absolute forever = { (uint64_t) - 1LL };
+  return forever;
+}
+
+/**
+ * Convert relative time to an absolute time in the
+ * future.
+ *
+ * @return timestamp that is "rel" in the future, or FOREVER if rel==FOREVER (or if we would overflow)
+ */
+struct GNUNET_TIME_Absolute
+GNUNET_TIME_relative_to_absolute (struct GNUNET_TIME_Relative rel)
+{
+  struct GNUNET_TIME_Absolute ret;
+  if (rel.value == (uint64_t) - 1LL)
+    return GNUNET_TIME_absolute_get_forever ();
+  struct GNUNET_TIME_Absolute now = GNUNET_TIME_absolute_get ();
+  if (rel.value + now.value < rel.value)
+    {
+      GNUNET_break (0);         /* overflow... */
+      return GNUNET_TIME_absolute_get_forever ();
+    }
+  ret.value = rel.value + now.value;
+  return ret;
+}
+
+/**
+ * Given a timestamp in the future, how much time
+ * remains until then?
+ *
+ * @return future - now, or 0 if now >= future, or FOREVER if future==FOREVER.
+ */
+struct GNUNET_TIME_Relative
+GNUNET_TIME_absolute_get_remaining (struct GNUNET_TIME_Absolute future)
+{
+  struct GNUNET_TIME_Relative ret;
+  if (future.value == (uint64_t) - 1LL)
+    return GNUNET_TIME_relative_get_forever ();
+  struct GNUNET_TIME_Absolute now = GNUNET_TIME_absolute_get ();
+  if (now.value > future.value)
+    return GNUNET_TIME_relative_get_zero ();
+  ret.value = future.value - now.value;
+  return ret;
+}
+
+/**
+ * Compute the time difference between the given start and end times.
+ * Use this function instead of actual subtraction to ensure that
+ * "FOREVER" and overflows are handeled correctly.
+ *
+ * @return 0 if start >= end; FOREVER if end==FOREVER; otherwise end - start
+ */
+struct GNUNET_TIME_Relative
+GNUNET_TIME_absolute_get_difference (struct GNUNET_TIME_Absolute start,
+                                     struct GNUNET_TIME_Absolute end)
+{
+  struct GNUNET_TIME_Relative ret;
+  if (end.value == (uint64_t) - 1LL)
+    return GNUNET_TIME_relative_get_forever ();
+  if (end.value < start.value)
+    return GNUNET_TIME_relative_get_zero ();
+  ret.value = end.value - start.value;
+  return ret;
+}
+
+/**
+ * Get the duration of an operation as the
+ * difference of the current time and the given start time "hence".
+ *
+ * @return aborts if hence==FOREVER, 0 if hence > now, otherwise now-hence.
+ */
+struct GNUNET_TIME_Relative
+GNUNET_TIME_absolute_get_duration (struct GNUNET_TIME_Absolute hence)
+{
+  struct GNUNET_TIME_Absolute now;
+  struct GNUNET_TIME_Relative ret;
+
+  now = GNUNET_TIME_absolute_get ();
+  GNUNET_assert (hence.value != (uint64_t) - 1LL);
+  if (hence.value > now.value)
+    return GNUNET_TIME_relative_get_zero ();
+  ret.value = now.value - hence.value;
+  return ret;
+}
+
+
+/**
+ * Add a given relative duration to the
+ * given start time.
+ *
+ * @return FOREVER if either argument is FOREVER or on overflow; start+duration otherwise
+ */
+struct GNUNET_TIME_Absolute
+GNUNET_TIME_absolute_add (struct GNUNET_TIME_Absolute start,
+                          struct GNUNET_TIME_Relative duration)
+{
+  struct GNUNET_TIME_Absolute ret;
+
+  if ((start.value == (uint64_t) - 1LL) ||
+      (duration.value == (uint64_t) - 1LL))
+    return GNUNET_TIME_absolute_get_forever ();
+  if (start.value + duration.value < start.value)
+    {
+      GNUNET_break (0);
+      return GNUNET_TIME_absolute_get_forever ();
+    }
+  ret.value = start.value + duration.value;
+  return ret;
+}
+
+/**
+ * Multiply relative time by a given factor.
+ *
+ * @return FOREVER if rel=FOREVER or on overflow; otherwise rel*factor
+ */
+struct GNUNET_TIME_Relative
+GNUNET_TIME_relative_multiply (struct GNUNET_TIME_Relative rel,
+                               unsigned int factor)
+{
+  struct GNUNET_TIME_Relative ret;
+  if (factor == 0)
+    return GNUNET_TIME_relative_get_zero ();
+  ret.value = rel.value * factor;
+  if (ret.value / factor != rel.value)
+    {
+      GNUNET_break (0);
+      return GNUNET_TIME_relative_get_forever ();
+    }
+  return ret;
+}
+
+/**
+ * Add relative times together.
+ *
+ * @return FOREVER if either argument is FOREVER or on overflow; a1+a2 otherwise
+ */
+struct GNUNET_TIME_Relative
+GNUNET_TIME_relative_add (struct GNUNET_TIME_Relative a1,
+                          struct GNUNET_TIME_Relative a2)
+{
+  struct GNUNET_TIME_Relative ret;
+
+  if ((a1.value == (uint64_t) - 1LL) || (a2.value == (uint64_t) - 1LL))
+    return GNUNET_TIME_relative_get_forever ();
+  if (a1.value + a2.value < a1.value)
+    {
+      GNUNET_break (0);
+      return GNUNET_TIME_relative_get_forever ();
+    }
+  ret.value = a1.value + a2.value;
+  return ret;
+}
+
+
+/**
+ * Convert relative time to network byte order.
+ */
+struct GNUNET_TIME_RelativeNBO
+GNUNET_TIME_relative_hton (struct GNUNET_TIME_Relative a)
+{
+  struct GNUNET_TIME_RelativeNBO ret;
+  ret.value = GNUNET_htonll (a.value);
+  return ret;
+}
+
+/**
+ * Convert relative time from network byte order.
+ */
+struct GNUNET_TIME_Relative
+GNUNET_TIME_relative_ntoh (struct GNUNET_TIME_RelativeNBO a)
+{
+  struct GNUNET_TIME_Relative ret;
+  ret.value = GNUNET_ntohll (a.value);
+  return ret;
+
+}
+
+/**
+ * Convert absolute time to network byte order.
+ */
+struct GNUNET_TIME_AbsoluteNBO
+GNUNET_TIME_absolute_hton (struct GNUNET_TIME_Absolute a)
+{
+  struct GNUNET_TIME_AbsoluteNBO ret;
+  ret.value = GNUNET_htonll (a.value);
+  return ret;
+}
+
+/**
+ * Convert absolute time from network byte order.
+ */
+struct GNUNET_TIME_Absolute
+GNUNET_TIME_absolute_ntoh (struct GNUNET_TIME_AbsoluteNBO a)
+{
+  struct GNUNET_TIME_Absolute ret;
+  ret.value = GNUNET_ntohll (a.value);
+  return ret;
+
+}
+
+
+
+/* end of time.c */