adding --enable-taler-wallet configure option to build a reduced version of libgnunetutil with only the parts needed by GNU Taler wallets

9 files changed, 935 insertions, 783 deletions

diff --git a/src/util/Makefile.am b/src/util/Makefile.am
index 685632b49..a2482fc87 100644
--- a/src/util/Makefile.am
+++ b/src/util/Makefile.am
@@ -46,12 +46,6 @@ gnunet_helper_w32_console_SOURCES = \
 gnunet_helper_w32_console_LDADD = \
   libgnunetutil.la
 
-noinst_PROGRAMS = \
- gnunet-config-diff \
- $(W32CAT) \
- test_common_logging_dummy
-
-
 gnunet_config_diff_SOURCES = \
  gnunet-config-diff.c
 gnunet_config_diff_LDADD = \
@@ -62,8 +56,6 @@ test_common_logging_dummy_SOURCES = \
 test_common_logging_dummy_LDADD = \
  libgnunetutil.la
 
-lib_LTLIBRARIES = libgnunetutil.la
-
 libgnunetutil_la_SOURCES = \
   bandwidth.c \
   bio.c \
@@ -73,6 +65,7 @@ libgnunetutil_la_SOURCES = \
   common_endian.c \
   common_logging.c \
   configuration.c \
+  configuration_loader.c \
   connection.c \
   container_bloomfilter.c \
   container_heap.c \
@@ -83,7 +76,9 @@ libgnunetutil_la_SOURCES = \
   crypto_symmetric.c \
   crypto_crc.c \
   crypto_ecc.c \
+  crypto_ecc_setup.c \
   crypto_hash.c \
+  crypto_hash_file.c \
   crypto_hkdf.c \
   crypto_kdf.c \
   crypto_mpi.c \
@@ -91,6 +86,7 @@ libgnunetutil_la_SOURCES = \
   crypto_random.c \
   crypto_rsa.c \
   disk.c \
+  disk_iterator.c \
   disk.h \
   getopt.c \
   getopt_helpers.c \
@@ -127,11 +123,46 @@ libgnunetutil_la_LDFLAGS = \
   $(GN_LIB_LDFLAGS) \
   -version-info 13:0:0
 
+
+libgnunetutil_taler_wallet_la_SOURCES = \
+  common_allocation.c \
+  common_endian.c \
+  common_logging.c \
+  configuration.c \
+  container_heap.c \
+  container_multihashmap.c \
+  container_multihashmap32.c \
+  crypto_symmetric.c \
+  crypto_crc.c \
+  crypto_ecc.c \
+  crypto_hash.c \
+  crypto_hkdf.c \
+  crypto_kdf.c \
+  crypto_mpi.c \
+  crypto_random.c \
+  crypto_rsa.c \
+  disk.c \
+  disk.h \
+  strings.c \
+  time.c
+
+libgnunetutil_taler_wallet_la_LIBADD = \
+  $(LIBGCRYPT_LIBS) \
+  -lunistring
+
+libgnunetutil_taler_wallet_la_LDFLAGS = \
+  $(GN_LIB_LDFLAGS) \
+  -version-info 0:0:0
+
 if HAVE_TESTING
   GNUNET_ECC = gnunet-ecc
   GNUNET_SCRYPT = gnunet-scrypt
 endif
 
+if TALER_ONLY
+lib_LTLIBRARIES = libgnunetutil_taler_wallet.la
+else
+lib_LTLIBRARIES = libgnunetutil.la
 
 libexec_PROGRAMS = \
  gnunet-service-resolver \
@@ -147,6 +178,20 @@ bin_PROGRAMS = \
  $(GNUNET_SCRYPT) \
  gnunet-uri
 
+noinst_PROGRAMS = \
+ gnunet-config-diff \
+ $(W32CAT) \
+ test_common_logging_dummy
+
+
+if ENABLE_TEST_RUN
+AM_TESTS_ENVIRONMENT=export GNUNET_PREFIX=$${GNUNET_PREFIX:-@libdir@};export PATH=$${GNUNET_PREFIX:-@prefix@}/bin:$$PATH;
+TESTS = $(check_PROGRAMS)
+endif
+
+endif
+
+
 do_subst = $(SED) -e 's,[@]PYTHON[@],$(PYTHON),g'
 
 gnunet-qr: gnunet-qr.py.in Makefile
@@ -266,10 +311,6 @@ check_PROGRAMS = \
  test_os_start_process \
  test_common_logging_runtime_loglevels
 
-if ENABLE_TEST_RUN
-AM_TESTS_ENVIRONMENT=export GNUNET_PREFIX=$${GNUNET_PREFIX:-@libdir@};export PATH=$${GNUNET_PREFIX:-@prefix@}/bin:$$PATH;
-TESTS = $(check_PROGRAMS)
-endif
 
 # Declare .nc (NO-CONCURRENCY) as a test extension so that we can impart
 # sequential execution order for them
diff --git a/src/util/configuration.c b/src/util/configuration.c
index 24b38f933..f61b43d57 100644
--- a/src/util/configuration.c
+++ b/src/util/configuration.c
@@ -1694,47 +1694,4 @@ GNUNET_CONFIGURATION_load_from (struct GNUNET_CONFIGURATION_Handle *cfg,
 }
 
 
-/**
- * Load configuration (starts with defaults, then loads
- * system-specific configuration).
- *
- * @param cfg configuration to update
- * @param filename name of the configuration file, NULL to load defaults
- * @return #GNUNET_OK on success, #GNUNET_SYSERR on error
- */
-int
-GNUNET_CONFIGURATION_load (struct GNUNET_CONFIGURATION_Handle *cfg,
-                           const char *filename)
-{
-  char *baseconfig;
-  char *ipath;
-
-  ipath = GNUNET_OS_installation_get_path (GNUNET_OS_IPK_DATADIR);
-  if (NULL == ipath)
-    return GNUNET_SYSERR;
-  baseconfig = NULL;
-  GNUNET_asprintf (&baseconfig, "%s%s", ipath, "config.d");
-  GNUNET_free (ipath);
-  if (GNUNET_SYSERR ==
-      GNUNET_DISK_directory_scan (baseconfig, &parse_configuration_file, cfg))
-  {
-    GNUNET_free (baseconfig);
-    return GNUNET_SYSERR;       /* no configuration at all found */
-  }
-  GNUNET_free (baseconfig);
-  if ((NULL != filename) &&
-      (GNUNET_OK != GNUNET_CONFIGURATION_parse (cfg, filename)))
-  {
-    /* specified configuration not found */
-    return GNUNET_SYSERR;
-  }
-  if (((GNUNET_YES !=
-        GNUNET_CONFIGURATION_have_value (cfg, "PATHS", "DEFAULTCONFIG"))) &&
-      (filename != NULL))
-    GNUNET_CONFIGURATION_set_value_string (cfg, "PATHS", "DEFAULTCONFIG",
-                                           filename);
-  return GNUNET_OK;
-}
-
-
 /* end of configuration.c */
diff --git a/src/util/configuration_loader.c b/src/util/configuration_loader.c
new file mode 100644
index 000000000..0b7f2865d
--- /dev/null
+++ b/src/util/configuration_loader.c
@@ -0,0 +1,69 @@
+/*
+     This file is part of GNUnet.
+     Copyright (C) 2006, 2007, 2008, 2009, 2013 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 3, 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_loader.c
+ * @brief configuration loading
+ * @author Christian Grothoff
+ */
+
+/**
+ * Load configuration (starts with defaults, then loads
+ * system-specific configuration).
+ *
+ * @param cfg configuration to update
+ * @param filename name of the configuration file, NULL to load defaults
+ * @return #GNUNET_OK on success, #GNUNET_SYSERR on error
+ */
+int
+GNUNET_CONFIGURATION_load (struct GNUNET_CONFIGURATION_Handle *cfg,
+                           const char *filename)
+{
+  char *baseconfig;
+  char *ipath;
+
+  ipath = GNUNET_OS_installation_get_path (GNUNET_OS_IPK_DATADIR);
+  if (NULL == ipath)
+    return GNUNET_SYSERR;
+  baseconfig = NULL;
+  GNUNET_asprintf (&baseconfig, "%s%s", ipath, "config.d");
+  GNUNET_free (ipath);
+  if (GNUNET_SYSERR ==
+      GNUNET_DISK_directory_scan (baseconfig, &parse_configuration_file, cfg))
+  {
+    GNUNET_free (baseconfig);
+    return GNUNET_SYSERR;       /* no configuration at all found */
+  }
+  GNUNET_free (baseconfig);
+  if ((NULL != filename) &&
+      (GNUNET_OK != GNUNET_CONFIGURATION_parse (cfg, filename)))
+  {
+    /* specified configuration not found */
+    return GNUNET_SYSERR;
+  }
+  if (((GNUNET_YES !=
+        GNUNET_CONFIGURATION_have_value (cfg, "PATHS", "DEFAULTCONFIG"))) &&
+      (filename != NULL))
+    GNUNET_CONFIGURATION_set_value_string (cfg, "PATHS", "DEFAULTCONFIG",
+                                           filename);
+  return GNUNET_OK;
+}
+
+/* end of configuration_loader.c */
diff --git a/src/util/crypto_ecc.c b/src/util/crypto_ecc.c
index e6d6bc133..87c787185 100644
--- a/src/util/crypto_ecc.c
+++ b/src/util/crypto_ecc.c
@@ -658,407 +658,6 @@ GNUNET_CRYPTO_ecdsa_key_get_anonymous ()
 
 
 /**
- * Wait for a short time (we're trying to lock a file or want
- * to give another process a shot at finishing a disk write, etc.).
- * Sleeps for 100ms (as that should be long enough for virtually all
- * modern systems to context switch and allow another process to do
- * some 'real' work).
- */
-static void
-short_wait ()
-{
-  struct GNUNET_TIME_Relative timeout;
-
-  timeout = GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MILLISECONDS, 100);
-  (void) GNUNET_NETWORK_socket_select (NULL, NULL, NULL, timeout);
-}
-
-
-/**
- * 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.
- * If the contents of the file
- * are invalid the old file is deleted and a fresh key is
- * created.
- *
- * @param filename name of file to use to store the key
- * @return new private key, NULL on error (for example,
- *   permission denied)
- */
-struct GNUNET_CRYPTO_EddsaPrivateKey *
-GNUNET_CRYPTO_eddsa_key_create_from_file (const char *filename)
-{
-  struct GNUNET_CRYPTO_EddsaPrivateKey *priv;
-  struct GNUNET_DISK_FileHandle *fd;
-  unsigned int cnt;
-  int ec;
-  uint64_t fs;
-
-  if (GNUNET_SYSERR == GNUNET_DISK_directory_create_for_file (filename))
-    return NULL;
-  while (GNUNET_YES != GNUNET_DISK_file_test (filename))
-  {
-    fd = GNUNET_DISK_file_open (filename,
-                                GNUNET_DISK_OPEN_WRITE | GNUNET_DISK_OPEN_CREATE
-                                | GNUNET_DISK_OPEN_FAILIFEXISTS,
-                                GNUNET_DISK_PERM_USER_READ |
-                                GNUNET_DISK_PERM_USER_WRITE);
-    if (NULL == fd)
-    {
-      if (EEXIST == errno)
-      {
-        if (GNUNET_YES != GNUNET_DISK_file_test (filename))
-        {
-          /* must exist but not be accessible, fail for good! */
-          if (0 != ACCESS (filename, R_OK))
-            LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_ERROR, "access", filename);
-          else
-            GNUNET_break (0);   /* what is going on!? */
-          return NULL;
-        }
-        continue;
-      }
-      LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_ERROR, "open", filename);
-      return NULL;
-    }
-    cnt = 0;
-    while (GNUNET_YES !=
-           GNUNET_DISK_file_lock (fd, 0,
-                                  sizeof (struct GNUNET_CRYPTO_EddsaPrivateKey),
-                                  GNUNET_YES))
-    {
-      short_wait ();
-      if (0 == ++cnt % 10)
-      {
-        ec = errno;
-        LOG (GNUNET_ERROR_TYPE_ERROR,
-             _("Could not acquire lock on file `%s': %s...\n"), filename,
-             STRERROR (ec));
-      }
-    }
-    LOG (GNUNET_ERROR_TYPE_INFO,
-         _("Creating a new private key.  This may take a while.\n"));
-    priv = GNUNET_CRYPTO_eddsa_key_create ();
-    GNUNET_assert (NULL != priv);
-    GNUNET_assert (sizeof (*priv) ==
-                   GNUNET_DISK_file_write (fd, priv, sizeof (*priv)));
-    GNUNET_DISK_file_sync (fd);
-    if (GNUNET_YES !=
-        GNUNET_DISK_file_unlock (fd, 0,
-                                 sizeof (struct GNUNET_CRYPTO_EddsaPrivateKey)))
-      LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_WARNING, "fcntl", filename);
-    GNUNET_assert (GNUNET_YES == GNUNET_DISK_file_close (fd));
-    return priv;
-  }
-  /* key file exists already, read it! */
-  fd = GNUNET_DISK_file_open (filename, GNUNET_DISK_OPEN_READ,
-                              GNUNET_DISK_PERM_NONE);
-  if (NULL == fd)
-  {
-    LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_ERROR, "open", filename);
-    return NULL;
-  }
-  cnt = 0;
-  while (1)
-  {
-    if (GNUNET_YES !=
-        GNUNET_DISK_file_lock (fd, 0,
-                               sizeof (struct GNUNET_CRYPTO_EddsaPrivateKey),
-                               GNUNET_NO))
-    {
-      if (0 == ++cnt % 60)
-      {
-        ec = errno;
-        LOG (GNUNET_ERROR_TYPE_ERROR,
-             _("Could not acquire lock on file `%s': %s...\n"), filename,
-             STRERROR (ec));
-        LOG (GNUNET_ERROR_TYPE_ERROR,
-             _
-             ("This may be ok if someone is currently generating a private key.\n"));
-      }
-      short_wait ();
-      continue;
-    }
-    if (GNUNET_YES != GNUNET_DISK_file_test (filename))
-    {
-      /* eh, what!? File we opened is now gone!? */
-      LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_WARNING, "stat", filename);
-      if (GNUNET_YES !=
-          GNUNET_DISK_file_unlock (fd, 0,
-                                   sizeof (struct GNUNET_CRYPTO_EddsaPrivateKey)))
-        LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_WARNING, "fcntl", filename);
-      GNUNET_assert (GNUNET_OK == GNUNET_DISK_file_close (fd));
-
-      return NULL;
-    }
-    if (GNUNET_OK != GNUNET_DISK_file_size (filename, &fs, GNUNET_YES, GNUNET_YES))
-      fs = 0;
-    if (fs < sizeof (struct GNUNET_CRYPTO_EddsaPrivateKey))
-    {
-      /* maybe we got the read lock before the key generating
-       * process had a chance to get the write lock; give it up! */
-      if (GNUNET_YES !=
-          GNUNET_DISK_file_unlock (fd, 0,
-                                   sizeof (struct GNUNET_CRYPTO_EddsaPrivateKey)))
-        LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_WARNING, "fcntl", filename);
-      if (0 == ++cnt % 10)
-      {
-        LOG (GNUNET_ERROR_TYPE_ERROR,
-             _("When trying to read key file `%s' I found %u bytes but I need at least %u.\n"),
-             filename, (unsigned int) fs,
-             (unsigned int) sizeof (struct GNUNET_CRYPTO_EddsaPrivateKey));
-        LOG (GNUNET_ERROR_TYPE_ERROR,
-             _("This may be ok if someone is currently generating a key.\n"));
-      }
-      short_wait ();                /* wait a bit longer! */
-      continue;
-    }
-    break;
-  }
-  fs = sizeof (struct GNUNET_CRYPTO_EddsaPrivateKey);
-  priv = GNUNET_malloc (fs);
-  GNUNET_assert (fs == GNUNET_DISK_file_read (fd, priv, fs));
-  if (GNUNET_YES !=
-      GNUNET_DISK_file_unlock (fd, 0,
-                               sizeof (struct GNUNET_CRYPTO_EddsaPrivateKey)))
-    LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_WARNING, "fcntl", filename);
-  GNUNET_assert (GNUNET_YES == GNUNET_DISK_file_close (fd));
-  return priv;
-}
-
-
-/**
- * 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.
- * If the contents of the file
- * are invalid the old file is deleted and a fresh key is
- * created.
- *
- * @param filename name of file to use to store the key
- * @return new private key, NULL on error (for example,
- *   permission denied)
- */
-struct GNUNET_CRYPTO_EcdsaPrivateKey *
-GNUNET_CRYPTO_ecdsa_key_create_from_file (const char *filename)
-{
-  struct GNUNET_CRYPTO_EcdsaPrivateKey *priv;
-  struct GNUNET_DISK_FileHandle *fd;
-  unsigned int cnt;
-  int ec;
-  uint64_t fs;
-
-  if (GNUNET_SYSERR == GNUNET_DISK_directory_create_for_file (filename))
-    return NULL;
-  while (GNUNET_YES != GNUNET_DISK_file_test (filename))
-  {
-    fd = GNUNET_DISK_file_open (filename,
-                                GNUNET_DISK_OPEN_WRITE | GNUNET_DISK_OPEN_CREATE
-                                | GNUNET_DISK_OPEN_FAILIFEXISTS,
-                                GNUNET_DISK_PERM_USER_READ |
-                                GNUNET_DISK_PERM_USER_WRITE);
-    if (NULL == fd)
-    {
-      if (EEXIST == errno)
-      {
-        if (GNUNET_YES != GNUNET_DISK_file_test (filename))
-        {
-          /* must exist but not be accessible, fail for good! */
-          if (0 != ACCESS (filename, R_OK))
-            LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_ERROR, "access", filename);
-          else
-            GNUNET_break (0);   /* what is going on!? */
-          return NULL;
-        }
-        continue;
-      }
-      LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_ERROR, "open", filename);
-      return NULL;
-    }
-    cnt = 0;
-    while (GNUNET_YES !=
-           GNUNET_DISK_file_lock (fd, 0,
-                                  sizeof (struct GNUNET_CRYPTO_EcdsaPrivateKey),
-                                  GNUNET_YES))
-    {
-      short_wait ();
-      if (0 == ++cnt % 10)
-      {
-        ec = errno;
-        LOG (GNUNET_ERROR_TYPE_ERROR,
-             _("Could not acquire lock on file `%s': %s...\n"), filename,
-             STRERROR (ec));
-      }
-    }
-    LOG (GNUNET_ERROR_TYPE_INFO,
-         _("Creating a new private key.  This may take a while.\n"));
-    priv = GNUNET_CRYPTO_ecdsa_key_create ();
-    GNUNET_assert (NULL != priv);
-    GNUNET_assert (sizeof (*priv) ==
-                   GNUNET_DISK_file_write (fd, priv, sizeof (*priv)));
-    GNUNET_DISK_file_sync (fd);
-    if (GNUNET_YES !=
-        GNUNET_DISK_file_unlock (fd, 0,
-                                 sizeof (struct GNUNET_CRYPTO_EcdsaPrivateKey)))
-      LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_WARNING, "fcntl", filename);
-    GNUNET_assert (GNUNET_YES == GNUNET_DISK_file_close (fd));
-    return priv;
-  }
-  /* key file exists already, read it! */
-  fd = GNUNET_DISK_file_open (filename, GNUNET_DISK_OPEN_READ,
-                              GNUNET_DISK_PERM_NONE);
-  if (NULL == fd)
-  {
-    LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_ERROR, "open", filename);
-    return NULL;
-  }
-  cnt = 0;
-  while (1)
-  {
-    if (GNUNET_YES !=
-        GNUNET_DISK_file_lock (fd, 0,
-                               sizeof (struct GNUNET_CRYPTO_EcdsaPrivateKey),
-                               GNUNET_NO))
-    {
-      if (0 == ++cnt % 60)
-      {
-        ec = errno;
-        LOG (GNUNET_ERROR_TYPE_ERROR,
-             _("Could not acquire lock on file `%s': %s...\n"), filename,
-             STRERROR (ec));
-        LOG (GNUNET_ERROR_TYPE_ERROR,
-             _
-             ("This may be ok if someone is currently generating a private key.\n"));
-      }
-      short_wait ();
-      continue;
-    }
-    if (GNUNET_YES != GNUNET_DISK_file_test (filename))
-    {
-      /* eh, what!? File we opened is now gone!? */
-      LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_WARNING, "stat", filename);
-      if (GNUNET_YES !=
-          GNUNET_DISK_file_unlock (fd, 0,
-                                   sizeof (struct GNUNET_CRYPTO_EcdsaPrivateKey)))
-        LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_WARNING, "fcntl", filename);
-      GNUNET_assert (GNUNET_OK == GNUNET_DISK_file_close (fd));
-
-      return NULL;
-    }
-    if (GNUNET_OK != GNUNET_DISK_file_size (filename, &fs, GNUNET_YES, GNUNET_YES))
-      fs = 0;
-    if (fs < sizeof (struct GNUNET_CRYPTO_EcdsaPrivateKey))
-    {
-      /* maybe we got the read lock before the key generating
-       * process had a chance to get the write lock; give it up! */
-      if (GNUNET_YES !=
-          GNUNET_DISK_file_unlock (fd, 0,
-                                   sizeof (struct GNUNET_CRYPTO_EcdsaPrivateKey)))
-        LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_WARNING, "fcntl", filename);
-      if (0 == ++cnt % 10)
-      {
-        LOG (GNUNET_ERROR_TYPE_ERROR,
-             _("When trying to read key file `%s' I found %u bytes but I need at least %u.\n"),
-             filename, (unsigned int) fs,
-             (unsigned int) sizeof (struct GNUNET_CRYPTO_EcdsaPrivateKey));
-        LOG (GNUNET_ERROR_TYPE_ERROR,
-             _("This may be ok if someone is currently generating a key.\n"));
-      }
-      short_wait ();                /* wait a bit longer! */
-      continue;
-    }
-    break;
-  }
-  fs = sizeof (struct GNUNET_CRYPTO_EcdsaPrivateKey);
-  priv = GNUNET_malloc (fs);
-  GNUNET_assert (fs == GNUNET_DISK_file_read (fd, priv, fs));
-  if (GNUNET_YES !=
-      GNUNET_DISK_file_unlock (fd, 0,
-                               sizeof (struct GNUNET_CRYPTO_EcdsaPrivateKey)))
-    LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_WARNING, "fcntl", filename);
-  GNUNET_assert (GNUNET_YES == GNUNET_DISK_file_close (fd));
-  return priv;
-}
-
-
-/**
- * Create a new private key by reading our peer's key from
- * the file specified in the configuration.
- *
- * @param cfg the configuration to use
- * @return new private key, NULL on error (for example,
- *   permission denied)
- */
-struct GNUNET_CRYPTO_EddsaPrivateKey *
-GNUNET_CRYPTO_eddsa_key_create_from_configuration (const struct GNUNET_CONFIGURATION_Handle *cfg)
-{
-  struct GNUNET_CRYPTO_EddsaPrivateKey *priv;
-  char *fn;
-
-  if (GNUNET_OK !=
-      GNUNET_CONFIGURATION_get_value_filename (cfg, "PEER", "PRIVATE_KEY", &fn))
-    return NULL;
-  priv = GNUNET_CRYPTO_eddsa_key_create_from_file (fn);
-  GNUNET_free (fn);
-  return priv;
-}
-
-
-/**
- * Setup a key file for a peer given the name of the
- * configuration file (!).  This function is used so that
- * at a later point code can be certain that reading a
- * key is fast (for example in time-dependent testcases).
- *
- * @param cfg_name name of the configuration file to use
- */
-void
-GNUNET_CRYPTO_eddsa_setup_key (const char *cfg_name)
-{
-  struct GNUNET_CONFIGURATION_Handle *cfg;
-  struct GNUNET_CRYPTO_EddsaPrivateKey *priv;
-
-  cfg = GNUNET_CONFIGURATION_create ();
-  (void) GNUNET_CONFIGURATION_load (cfg, cfg_name);
-  priv = GNUNET_CRYPTO_eddsa_key_create_from_configuration (cfg);
-  if (NULL != priv)
-    GNUNET_free (priv);
-  GNUNET_CONFIGURATION_destroy (cfg);
-}
-
-
-/**
- * Retrieve the identity of the host's peer.
- *
- * @param cfg configuration to use
- * @param dst pointer to where to write the peer identity
- * @return #GNUNET_OK on success, #GNUNET_SYSERR if the identity
- *         could not be retrieved
- */
-int
-GNUNET_CRYPTO_get_peer_identity (const struct GNUNET_CONFIGURATION_Handle *cfg,
-                                 struct GNUNET_PeerIdentity *dst)
-{
-  struct GNUNET_CRYPTO_EddsaPrivateKey *priv;
-
-  if (NULL == (priv = GNUNET_CRYPTO_eddsa_key_create_from_configuration (cfg)))
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                _("Could not load peer's private key\n"));
-    return GNUNET_SYSERR;
-  }
-  GNUNET_CRYPTO_eddsa_key_get_public (priv, &dst->public_key);
-  GNUNET_free (priv);
-  return GNUNET_OK;
-}
-
-
-/**
  * Compare two Peer Identities.
  *
  * @param first first peer identity
diff --git a/src/util/crypto_ecc_setup.c b/src/util/crypto_ecc_setup.c
new file mode 100644
index 000000000..32e1acee3
--- /dev/null
+++ b/src/util/crypto_ecc_setup.c
@@ -0,0 +1,431 @@
+/*
+     This file is part of GNUnet.
+     Copyright (C) 2012, 2013, 2015 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 3, 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_ecc_setup.c
+ * @brief helper function for easy EdDSA key setup
+ * @author Christian Grothoff
+ */
+#include "platform.h"
+#include <gcrypt.h>
+#include "gnunet_util_lib.h"
+
+
+/**
+ * Wait for a short time (we're trying to lock a file or want
+ * to give another process a shot at finishing a disk write, etc.).
+ * Sleeps for 100ms (as that should be long enough for virtually all
+ * modern systems to context switch and allow another process to do
+ * some 'real' work).
+ */
+static void
+short_wait ()
+{
+  struct GNUNET_TIME_Relative timeout;
+
+  timeout = GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MILLISECONDS, 100);
+  (void) GNUNET_NETWORK_socket_select (NULL, NULL, NULL, timeout);
+}
+
+
+/**
+ * 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.
+ * If the contents of the file
+ * are invalid the old file is deleted and a fresh key is
+ * created.
+ *
+ * @param filename name of file to use to store the key
+ * @return new private key, NULL on error (for example,
+ *   permission denied)
+ */
+struct GNUNET_CRYPTO_EddsaPrivateKey *
+GNUNET_CRYPTO_eddsa_key_create_from_file (const char *filename)
+{
+  struct GNUNET_CRYPTO_EddsaPrivateKey *priv;
+  struct GNUNET_DISK_FileHandle *fd;
+  unsigned int cnt;
+  int ec;
+  uint64_t fs;
+
+  if (GNUNET_SYSERR == GNUNET_DISK_directory_create_for_file (filename))
+    return NULL;
+  while (GNUNET_YES != GNUNET_DISK_file_test (filename))
+  {
+    fd = GNUNET_DISK_file_open (filename,
+                                GNUNET_DISK_OPEN_WRITE | GNUNET_DISK_OPEN_CREATE
+                                | GNUNET_DISK_OPEN_FAILIFEXISTS,
+                                GNUNET_DISK_PERM_USER_READ |
+                                GNUNET_DISK_PERM_USER_WRITE);
+    if (NULL == fd)
+    {
+      if (EEXIST == errno)
+      {
+        if (GNUNET_YES != GNUNET_DISK_file_test (filename))
+        {
+          /* must exist but not be accessible, fail for good! */
+          if (0 != ACCESS (filename, R_OK))
+            LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_ERROR, "access", filename);
+          else
+            GNUNET_break (0);   /* what is going on!? */
+          return NULL;
+        }
+        continue;
+      }
+      LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_ERROR, "open", filename);
+      return NULL;
+    }
+    cnt = 0;
+    while (GNUNET_YES !=
+           GNUNET_DISK_file_lock (fd, 0,
+                                  sizeof (struct GNUNET_CRYPTO_EddsaPrivateKey),
+                                  GNUNET_YES))
+    {
+      short_wait ();
+      if (0 == ++cnt % 10)
+      {
+        ec = errno;
+        LOG (GNUNET_ERROR_TYPE_ERROR,
+             _("Could not acquire lock on file `%s': %s...\n"), filename,
+             STRERROR (ec));
+      }
+    }
+    LOG (GNUNET_ERROR_TYPE_INFO,
+         _("Creating a new private key.  This may take a while.\n"));
+    priv = GNUNET_CRYPTO_eddsa_key_create ();
+    GNUNET_assert (NULL != priv);
+    GNUNET_assert (sizeof (*priv) ==
+                   GNUNET_DISK_file_write (fd, priv, sizeof (*priv)));
+    GNUNET_DISK_file_sync (fd);
+    if (GNUNET_YES !=
+        GNUNET_DISK_file_unlock (fd, 0,
+                                 sizeof (struct GNUNET_CRYPTO_EddsaPrivateKey)))
+      LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_WARNING, "fcntl", filename);
+    GNUNET_assert (GNUNET_YES == GNUNET_DISK_file_close (fd));
+    return priv;
+  }
+  /* key file exists already, read it! */
+  fd = GNUNET_DISK_file_open (filename, GNUNET_DISK_OPEN_READ,
+                              GNUNET_DISK_PERM_NONE);
+  if (NULL == fd)
+  {
+    LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_ERROR, "open", filename);
+    return NULL;
+  }
+  cnt = 0;
+  while (1)
+  {
+    if (GNUNET_YES !=
+        GNUNET_DISK_file_lock (fd, 0,
+                               sizeof (struct GNUNET_CRYPTO_EddsaPrivateKey),
+                               GNUNET_NO))
+    {
+      if (0 == ++cnt % 60)
+      {
+        ec = errno;
+        LOG (GNUNET_ERROR_TYPE_ERROR,
+             _("Could not acquire lock on file `%s': %s...\n"), filename,
+             STRERROR (ec));
+        LOG (GNUNET_ERROR_TYPE_ERROR,
+             _
+             ("This may be ok if someone is currently generating a private key.\n"));
+      }
+      short_wait ();
+      continue;
+    }
+    if (GNUNET_YES != GNUNET_DISK_file_test (filename))
+    {
+      /* eh, what!? File we opened is now gone!? */
+      LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_WARNING, "stat", filename);
+      if (GNUNET_YES !=
+          GNUNET_DISK_file_unlock (fd, 0,
+                                   sizeof (struct GNUNET_CRYPTO_EddsaPrivateKey)))
+        LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_WARNING, "fcntl", filename);
+      GNUNET_assert (GNUNET_OK == GNUNET_DISK_file_close (fd));
+
+      return NULL;
+    }
+    if (GNUNET_OK != GNUNET_DISK_file_size (filename, &fs, GNUNET_YES, GNUNET_YES))
+      fs = 0;
+    if (fs < sizeof (struct GNUNET_CRYPTO_EddsaPrivateKey))
+    {
+      /* maybe we got the read lock before the key generating
+       * process had a chance to get the write lock; give it up! */
+      if (GNUNET_YES !=
+          GNUNET_DISK_file_unlock (fd, 0,
+                                   sizeof (struct GNUNET_CRYPTO_EddsaPrivateKey)))
+        LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_WARNING, "fcntl", filename);
+      if (0 == ++cnt % 10)
+      {
+        LOG (GNUNET_ERROR_TYPE_ERROR,
+             _("When trying to read key file `%s' I found %u bytes but I need at least %u.\n"),
+             filename, (unsigned int) fs,
+             (unsigned int) sizeof (struct GNUNET_CRYPTO_EddsaPrivateKey));
+        LOG (GNUNET_ERROR_TYPE_ERROR,
+             _("This may be ok if someone is currently generating a key.\n"));
+      }
+      short_wait ();                /* wait a bit longer! */
+      continue;
+    }
+    break;
+  }
+  fs = sizeof (struct GNUNET_CRYPTO_EddsaPrivateKey);
+  priv = GNUNET_malloc (fs);
+  GNUNET_assert (fs == GNUNET_DISK_file_read (fd, priv, fs));
+  if (GNUNET_YES !=
+      GNUNET_DISK_file_unlock (fd, 0,
+                               sizeof (struct GNUNET_CRYPTO_EddsaPrivateKey)))
+    LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_WARNING, "fcntl", filename);
+  GNUNET_assert (GNUNET_YES == GNUNET_DISK_file_close (fd));
+  return priv;
+}
+
+
+/**
+ * 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.
+ * If the contents of the file
+ * are invalid the old file is deleted and a fresh key is
+ * created.
+ *
+ * @param filename name of file to use to store the key
+ * @return new private key, NULL on error (for example,
+ *   permission denied)
+ */
+struct GNUNET_CRYPTO_EcdsaPrivateKey *
+GNUNET_CRYPTO_ecdsa_key_create_from_file (const char *filename)
+{
+  struct GNUNET_CRYPTO_EcdsaPrivateKey *priv;
+  struct GNUNET_DISK_FileHandle *fd;
+  unsigned int cnt;
+  int ec;
+  uint64_t fs;
+
+  if (GNUNET_SYSERR == GNUNET_DISK_directory_create_for_file (filename))
+    return NULL;
+  while (GNUNET_YES != GNUNET_DISK_file_test (filename))
+  {
+    fd = GNUNET_DISK_file_open (filename,
+                                GNUNET_DISK_OPEN_WRITE | GNUNET_DISK_OPEN_CREATE
+                                | GNUNET_DISK_OPEN_FAILIFEXISTS,
+                                GNUNET_DISK_PERM_USER_READ |
+                                GNUNET_DISK_PERM_USER_WRITE);
+    if (NULL == fd)
+    {
+      if (EEXIST == errno)
+      {
+        if (GNUNET_YES != GNUNET_DISK_file_test (filename))
+        {
+          /* must exist but not be accessible, fail for good! */
+          if (0 != ACCESS (filename, R_OK))
+            LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_ERROR, "access", filename);
+          else
+            GNUNET_break (0);   /* what is going on!? */
+          return NULL;
+        }
+        continue;
+      }
+      LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_ERROR, "open", filename);
+      return NULL;
+    }
+    cnt = 0;
+    while (GNUNET_YES !=
+           GNUNET_DISK_file_lock (fd, 0,
+                                  sizeof (struct GNUNET_CRYPTO_EcdsaPrivateKey),
+                                  GNUNET_YES))
+    {
+      short_wait ();
+      if (0 == ++cnt % 10)
+      {
+        ec = errno;
+        LOG (GNUNET_ERROR_TYPE_ERROR,
+             _("Could not acquire lock on file `%s': %s...\n"), filename,
+             STRERROR (ec));
+      }
+    }
+    LOG (GNUNET_ERROR_TYPE_INFO,
+         _("Creating a new private key.  This may take a while.\n"));
+    priv = GNUNET_CRYPTO_ecdsa_key_create ();
+    GNUNET_assert (NULL != priv);
+    GNUNET_assert (sizeof (*priv) ==
+                   GNUNET_DISK_file_write (fd, priv, sizeof (*priv)));
+    GNUNET_DISK_file_sync (fd);
+    if (GNUNET_YES !=
+        GNUNET_DISK_file_unlock (fd, 0,
+                                 sizeof (struct GNUNET_CRYPTO_EcdsaPrivateKey)))
+      LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_WARNING, "fcntl", filename);
+    GNUNET_assert (GNUNET_YES == GNUNET_DISK_file_close (fd));
+    return priv;
+  }
+  /* key file exists already, read it! */
+  fd = GNUNET_DISK_file_open (filename, GNUNET_DISK_OPEN_READ,
+                              GNUNET_DISK_PERM_NONE);
+  if (NULL == fd)
+  {
+    LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_ERROR, "open", filename);
+    return NULL;
+  }
+  cnt = 0;
+  while (1)
+  {
+    if (GNUNET_YES !=
+        GNUNET_DISK_file_lock (fd, 0,
+                               sizeof (struct GNUNET_CRYPTO_EcdsaPrivateKey),
+                               GNUNET_NO))
+    {
+      if (0 == ++cnt % 60)
+      {
+        ec = errno;
+        LOG (GNUNET_ERROR_TYPE_ERROR,
+             _("Could not acquire lock on file `%s': %s...\n"), filename,
+             STRERROR (ec));
+        LOG (GNUNET_ERROR_TYPE_ERROR,
+             _
+             ("This may be ok if someone is currently generating a private key.\n"));
+      }
+      short_wait ();
+      continue;
+    }
+    if (GNUNET_YES != GNUNET_DISK_file_test (filename))
+    {
+      /* eh, what!? File we opened is now gone!? */
+      LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_WARNING, "stat", filename);
+      if (GNUNET_YES !=
+          GNUNET_DISK_file_unlock (fd, 0,
+                                   sizeof (struct GNUNET_CRYPTO_EcdsaPrivateKey)))
+        LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_WARNING, "fcntl", filename);
+      GNUNET_assert (GNUNET_OK == GNUNET_DISK_file_close (fd));
+
+      return NULL;
+    }
+    if (GNUNET_OK != GNUNET_DISK_file_size (filename, &fs, GNUNET_YES, GNUNET_YES))
+      fs = 0;
+    if (fs < sizeof (struct GNUNET_CRYPTO_EcdsaPrivateKey))
+    {
+      /* maybe we got the read lock before the key generating
+       * process had a chance to get the write lock; give it up! */
+      if (GNUNET_YES !=
+          GNUNET_DISK_file_unlock (fd, 0,
+                                   sizeof (struct GNUNET_CRYPTO_EcdsaPrivateKey)))
+        LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_WARNING, "fcntl", filename);
+      if (0 == ++cnt % 10)
+      {
+        LOG (GNUNET_ERROR_TYPE_ERROR,
+             _("When trying to read key file `%s' I found %u bytes but I need at least %u.\n"),
+             filename, (unsigned int) fs,
+             (unsigned int) sizeof (struct GNUNET_CRYPTO_EcdsaPrivateKey));
+        LOG (GNUNET_ERROR_TYPE_ERROR,
+             _("This may be ok if someone is currently generating a key.\n"));
+      }
+      short_wait ();                /* wait a bit longer! */
+      continue;
+    }
+    break;
+  }
+  fs = sizeof (struct GNUNET_CRYPTO_EcdsaPrivateKey);
+  priv = GNUNET_malloc (fs);
+  GNUNET_assert (fs == GNUNET_DISK_file_read (fd, priv, fs));
+  if (GNUNET_YES !=
+      GNUNET_DISK_file_unlock (fd, 0,
+                               sizeof (struct GNUNET_CRYPTO_EcdsaPrivateKey)))
+    LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_WARNING, "fcntl", filename);
+  GNUNET_assert (GNUNET_YES == GNUNET_DISK_file_close (fd));
+  return priv;
+}
+
+
+/**
+ * Create a new private key by reading our peer's key from
+ * the file specified in the configuration.
+ *
+ * @param cfg the configuration to use
+ * @return new private key, NULL on error (for example,
+ *   permission denied)
+ */
+struct GNUNET_CRYPTO_EddsaPrivateKey *
+GNUNET_CRYPTO_eddsa_key_create_from_configuration (const struct GNUNET_CONFIGURATION_Handle *cfg)
+{
+  struct GNUNET_CRYPTO_EddsaPrivateKey *priv;
+  char *fn;
+
+  if (GNUNET_OK !=
+      GNUNET_CONFIGURATION_get_value_filename (cfg, "PEER", "PRIVATE_KEY", &fn))
+    return NULL;
+  priv = GNUNET_CRYPTO_eddsa_key_create_from_file (fn);
+  GNUNET_free (fn);
+  return priv;
+}
+
+
+/**
+ * Retrieve the identity of the host's peer.
+ *
+ * @param cfg configuration to use
+ * @param dst pointer to where to write the peer identity
+ * @return #GNUNET_OK on success, #GNUNET_SYSERR if the identity
+ *         could not be retrieved
+ */
+int
+GNUNET_CRYPTO_get_peer_identity (const struct GNUNET_CONFIGURATION_Handle *cfg,
+                                 struct GNUNET_PeerIdentity *dst)
+{
+  struct GNUNET_CRYPTO_EddsaPrivateKey *priv;
+
+  if (NULL == (priv = GNUNET_CRYPTO_eddsa_key_create_from_configuration (cfg)))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                _("Could not load peer's private key\n"));
+    return GNUNET_SYSERR;
+  }
+  GNUNET_CRYPTO_eddsa_key_get_public (priv, &dst->public_key);
+  GNUNET_free (priv);
+  return GNUNET_OK;
+}
+
+
+/**
+ * Setup a key file for a peer given the name of the
+ * configuration file (!).  This function is used so that
+ * at a later point code can be certain that reading a
+ * key is fast (for example in time-dependent testcases).
+ *
+ * @param cfg_name name of the configuration file to use
+ */
+void
+GNUNET_CRYPTO_eddsa_setup_key (const char *cfg_name)
+{
+  struct GNUNET_CONFIGURATION_Handle *cfg;
+  struct GNUNET_CRYPTO_EddsaPrivateKey *priv;
+
+  cfg = GNUNET_CONFIGURATION_create ();
+  (void) GNUNET_CONFIGURATION_load (cfg, cfg_name);
+  priv = GNUNET_CRYPTO_eddsa_key_create_from_configuration (cfg);
+  if (NULL != priv)
+    GNUNET_free (priv);
+  GNUNET_CONFIGURATION_destroy (cfg);
+}
+
+/* end of crypto_ecc_setup.c */
diff --git a/src/util/crypto_hash.c b/src/util/crypto_hash.c
index 64f55e14c..9456e343b 100644
--- a/src/util/crypto_hash.c
+++ b/src/util/crypto_hash.c
@@ -21,7 +21,7 @@
 
 /**
  * @file util/crypto_hash.c
- * @brief SHA-512 GNUNET_CRYPTO_hash related functions
+ * @brief SHA-512 #GNUNET_CRYPTO_hash() related functions
  * @author Christian Grothoff
  */
 
@@ -49,193 +49,6 @@ GNUNET_CRYPTO_hash (const void *block,
 }
 
 
-/**
- * Context used when hashing a file.
- */
-struct GNUNET_CRYPTO_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;
-
-  /**
-   * File descriptor.
-   */
-  struct GNUNET_DISK_FileHandle *fh;
-
-  /**
-   * Cummulated hash.
-   */
-  gcry_md_hd_t md;
-
-  /**
-   * Size of the file.
-   */
-  uint64_t fsize;
-
-  /**
-   * Current offset.
-   */
-  uint64_t offset;
-
-  /**
-   * Current task for hashing.
-   */
-  struct GNUNET_SCHEDULER_Task * task;
-
-  /**
-   * Priority we use.
-   */
-  enum GNUNET_SCHEDULER_Priority priority;
-
-  /**
-   * Blocksize.
-   */
-  size_t bsize;
-
-};
-
-
-/**
- * Report result of hash computation to callback
- * and free associated resources.
- */
-static void
-file_hash_finish (struct GNUNET_CRYPTO_FileHashContext *fhc,
-                  const struct GNUNET_HashCode * res)
-{
-  fhc->callback (fhc->callback_cls, res);
-  GNUNET_free (fhc->filename);
-  if (!GNUNET_DISK_handle_invalid (fhc->fh))
-    GNUNET_break (GNUNET_OK == GNUNET_DISK_file_close (fhc->fh));
-  gcry_md_close (fhc->md);
-  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 GNUNET_CRYPTO_FileHashContext *fhc = cls;
-  struct GNUNET_HashCode *res;
-  size_t delta;
-
-  fhc->task = NULL;
-  GNUNET_assert (fhc->offset <= fhc->fsize);
-  delta = fhc->bsize;
-  if (fhc->fsize - fhc->offset < delta)
-    delta = fhc->fsize - fhc->offset;
-  if (delta != GNUNET_DISK_file_read (fhc->fh, fhc->buffer, delta))
-  {
-    LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_WARNING, "read", fhc->filename);
-    file_hash_finish (fhc, NULL);
-    return;
-  }
-  gcry_md_write (fhc->md, fhc->buffer, delta);
-  fhc->offset += delta;
-  if (fhc->offset == fhc->fsize)
-  {
-    res = (struct GNUNET_HashCode *) gcry_md_read (fhc->md, GCRY_MD_SHA512);
-    file_hash_finish (fhc, res);
-    return;
-  }
-  fhc->task = GNUNET_SCHEDULER_add_with_priority (fhc->priority,
-                                                  &file_hash_task, fhc);
-}
-
-
-/**
- * Compute the hash of an entire file.
- *
- * @param priority scheduling priority to use
- * @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
- * @return NULL on (immediate) errror
- */
-struct GNUNET_CRYPTO_FileHashContext *
-GNUNET_CRYPTO_hash_file (enum GNUNET_SCHEDULER_Priority priority,
-                         const char *filename, size_t blocksize,
-                         GNUNET_CRYPTO_HashCompletedCallback callback,
-                         void *callback_cls)
-{
-  struct GNUNET_CRYPTO_FileHashContext *fhc;
-
-  GNUNET_assert (blocksize > 0);
-  fhc =
-      GNUNET_malloc (sizeof (struct GNUNET_CRYPTO_FileHashContext) + blocksize);
-  fhc->callback = callback;
-  fhc->callback_cls = callback_cls;
-  fhc->buffer = (unsigned char *) &fhc[1];
-  fhc->filename = GNUNET_strdup (filename);
-  if (GPG_ERR_NO_ERROR != gcry_md_open (&fhc->md, GCRY_MD_SHA512, 0))
-  {
-    GNUNET_break (0);
-    GNUNET_free (fhc);
-    return NULL;
-  }
-  fhc->bsize = blocksize;
-  if (GNUNET_OK != GNUNET_DISK_file_size (filename, &fhc->fsize, GNUNET_NO, GNUNET_YES))
-  {
-    GNUNET_free (fhc->filename);
-    GNUNET_free (fhc);
-    return NULL;
-  }
-  fhc->fh =
-      GNUNET_DISK_file_open (filename, GNUNET_DISK_OPEN_READ,
-                             GNUNET_DISK_PERM_NONE);
-  if (!fhc->fh)
-  {
-    GNUNET_free (fhc->filename);
-    GNUNET_free (fhc);
-    return NULL;
-  }
-  fhc->priority = priority;
-  fhc->task =
-      GNUNET_SCHEDULER_add_with_priority (priority, &file_hash_task, fhc);
-  return fhc;
-}
-
-
-/**
- * Cancel a file hashing operation.
- *
- * @param fhc operation to cancel (callback must not yet have been invoked)
- */
-void
-GNUNET_CRYPTO_hash_file_cancel (struct GNUNET_CRYPTO_FileHashContext *fhc)
-{
-  GNUNET_SCHEDULER_cancel (fhc->task);
-  GNUNET_free (fhc->filename);
-  GNUNET_break (GNUNET_OK == GNUNET_DISK_file_close (fhc->fh));
-  GNUNET_free (fhc);
-}
-
-
 /* ***************** binary-ASCII encoding *************** */
 
 
diff --git a/src/util/crypto_hash_file.c b/src/util/crypto_hash_file.c
new file mode 100644
index 000000000..2d15fac36
--- /dev/null
+++ b/src/util/crypto_hash_file.c
@@ -0,0 +1,215 @@
+/*
+     This file is part of GNUnet.
+     Copyright (C) 2001-2013 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 3, 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_hash_file.c
+ * @brief incremental hashing of files
+ * @author Christian Grothoff
+ */
+
+
+/**
+ * Context used when hashing a file.
+ */
+struct GNUNET_CRYPTO_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;
+
+  /**
+   * File descriptor.
+   */
+  struct GNUNET_DISK_FileHandle *fh;
+
+  /**
+   * Cummulated hash.
+   */
+  gcry_md_hd_t md;
+
+  /**
+   * Size of the file.
+   */
+  uint64_t fsize;
+
+  /**
+   * Current offset.
+   */
+  uint64_t offset;
+
+  /**
+   * Current task for hashing.
+   */
+  struct GNUNET_SCHEDULER_Task * task;
+
+  /**
+   * Priority we use.
+   */
+  enum GNUNET_SCHEDULER_Priority priority;
+
+  /**
+   * Blocksize.
+   */
+  size_t bsize;
+
+};
+
+
+/**
+ * Report result of hash computation to callback
+ * and free associated resources.
+ */
+static void
+file_hash_finish (struct GNUNET_CRYPTO_FileHashContext *fhc,
+                  const struct GNUNET_HashCode * res)
+{
+  fhc->callback (fhc->callback_cls, res);
+  GNUNET_free (fhc->filename);
+  if (!GNUNET_DISK_handle_invalid (fhc->fh))
+    GNUNET_break (GNUNET_OK == GNUNET_DISK_file_close (fhc->fh));
+  gcry_md_close (fhc->md);
+  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 GNUNET_CRYPTO_FileHashContext *fhc = cls;
+  struct GNUNET_HashCode *res;
+  size_t delta;
+
+  fhc->task = NULL;
+  GNUNET_assert (fhc->offset <= fhc->fsize);
+  delta = fhc->bsize;
+  if (fhc->fsize - fhc->offset < delta)
+    delta = fhc->fsize - fhc->offset;
+  if (delta != GNUNET_DISK_file_read (fhc->fh, fhc->buffer, delta))
+  {
+    LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_WARNING, "read", fhc->filename);
+    file_hash_finish (fhc, NULL);
+    return;
+  }
+  gcry_md_write (fhc->md, fhc->buffer, delta);
+  fhc->offset += delta;
+  if (fhc->offset == fhc->fsize)
+  {
+    res = (struct GNUNET_HashCode *) gcry_md_read (fhc->md, GCRY_MD_SHA512);
+    file_hash_finish (fhc, res);
+    return;
+  }
+  fhc->task = GNUNET_SCHEDULER_add_with_priority (fhc->priority,
+                                                  &file_hash_task, fhc);
+}
+
+
+/**
+ * Compute the hash of an entire file.
+ *
+ * @param priority scheduling priority to use
+ * @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
+ * @return NULL on (immediate) errror
+ */
+struct GNUNET_CRYPTO_FileHashContext *
+GNUNET_CRYPTO_hash_file (enum GNUNET_SCHEDULER_Priority priority,
+                         const char *filename, size_t blocksize,
+                         GNUNET_CRYPTO_HashCompletedCallback callback,
+                         void *callback_cls)
+{
+  struct GNUNET_CRYPTO_FileHashContext *fhc;
+
+  GNUNET_assert (blocksize > 0);
+  fhc =
+      GNUNET_malloc (sizeof (struct GNUNET_CRYPTO_FileHashContext) + blocksize);
+  fhc->callback = callback;
+  fhc->callback_cls = callback_cls;
+  fhc->buffer = (unsigned char *) &fhc[1];
+  fhc->filename = GNUNET_strdup (filename);
+  if (GPG_ERR_NO_ERROR != gcry_md_open (&fhc->md, GCRY_MD_SHA512, 0))
+  {
+    GNUNET_break (0);
+    GNUNET_free (fhc);
+    return NULL;
+  }
+  fhc->bsize = blocksize;
+  if (GNUNET_OK != GNUNET_DISK_file_size (filename, &fhc->fsize, GNUNET_NO, GNUNET_YES))
+  {
+    GNUNET_free (fhc->filename);
+    GNUNET_free (fhc);
+    return NULL;
+  }
+  fhc->fh =
+      GNUNET_DISK_file_open (filename, GNUNET_DISK_OPEN_READ,
+                             GNUNET_DISK_PERM_NONE);
+  if (!fhc->fh)
+  {
+    GNUNET_free (fhc->filename);
+    GNUNET_free (fhc);
+    return NULL;
+  }
+  fhc->priority = priority;
+  fhc->task =
+      GNUNET_SCHEDULER_add_with_priority (priority, &file_hash_task, fhc);
+  return fhc;
+}
+
+
+/**
+ * Cancel a file hashing operation.
+ *
+ * @param fhc operation to cancel (callback must not yet have been invoked)
+ */
+void
+GNUNET_CRYPTO_hash_file_cancel (struct GNUNET_CRYPTO_FileHashContext *fhc)
+{
+  GNUNET_SCHEDULER_cancel (fhc->task);
+  GNUNET_free (fhc->filename);
+  GNUNET_break (GNUNET_OK == GNUNET_DISK_file_close (fhc->fh));
+  GNUNET_free (fhc);
+}
+
+/* end of crypto_hash_file.c */
diff --git a/src/util/disk.c b/src/util/disk.c
index da78a1e1d..81413265e 100644
--- a/src/util/disk.c
+++ b/src/util/disk.c
@@ -1278,145 +1278,6 @@ GNUNET_DISK_directory_scan (const char *dir_name,
 
 
 /**
- * Opaque handle used for iterating over a directory.
- */
-struct GNUNET_DISK_DirectoryIterator
-{
-
-  /**
-   * 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_with_priority (iter->priority, &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 prio priority to use
- * @param dir_name the name of the directory
- * @param callback the method to call for each file
- * @param callback_cls closure for callback
- * @return GNUNET_YES if directory is not empty and 'callback'
- *         will be called later, GNUNET_NO otherwise, GNUNET_SYSERR on error.
- */
-int
-GNUNET_DISK_directory_iterator_start (enum GNUNET_SCHEDULER_Priority prio,
-                                      const char *dir_name,
-                                      GNUNET_DISK_DirectoryIteratorCallback
-                                      callback, void *callback_cls)
-{
-  struct GNUNET_DISK_DirectoryIterator *di;
-
-  di = GNUNET_new (struct GNUNET_DISK_DirectoryIterator);
-  di->callback = callback;
-  di->callback_cls = callback_cls;
-  di->directory = OPENDIR (dir_name);
-  if (di->directory == NULL)
-  {
-    GNUNET_free (di);
-    callback (callback_cls, NULL, NULL, NULL);
-    return GNUNET_SYSERR;
-  }
-  di->dirname = GNUNET_strdup (dir_name);
-  di->priority = prio;
-  return GNUNET_DISK_directory_iterator_next (di, GNUNET_NO);
-}
-
-
-/**
  * Function that removes the given directory by calling
  * "GNUNET_DISK_directory_remove".
  *
diff --git a/src/util/disk_iterator.c b/src/util/disk_iterator.c
new file mode 100644
index 000000000..118823df6
--- /dev/null
+++ b/src/util/disk_iterator.c
@@ -0,0 +1,166 @@
+/*
+     This file is part of GNUnet.
+     Copyright (C) 2001--2013 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 3, 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_iterator.c
+ * @brief asynchronous iteration over a directory
+ * @author Christian Grothoff
+ * @author Nils Durner
+ */
+
+
+/**
+ * Opaque handle used for iterating over a directory.
+ */
+struct GNUNET_DISK_DirectoryIterator
+{
+
+  /**
+   * Function to call on directory entries.
+   */
+  GNUNET_DISK_DirectoryIteratorCallback callback;
+
+  /**
+   * Closure for @e 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_with_priority (iter->priority, &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 prio priority to use
+ * @param dir_name the name of the directory
+ * @param callback the method to call for each file
+ * @param callback_cls closure for @a callback
+ * @return #GNUNET_YES if directory is not empty and @a callback
+ *         will be called later, #GNUNET_NO otherwise, #GNUNET_SYSERR on error.
+ */
+int
+GNUNET_DISK_directory_iterator_start (enum GNUNET_SCHEDULER_Priority prio,
+                                      const char *dir_name,
+                                      GNUNET_DISK_DirectoryIteratorCallback
+                                      callback, void *callback_cls)
+{
+  struct GNUNET_DISK_DirectoryIterator *di;
+
+  di = GNUNET_new (struct GNUNET_DISK_DirectoryIterator);
+  di->callback = callback;
+  di->callback_cls = callback_cls;
+  di->directory = OPENDIR (dir_name);
+  if (di->directory == NULL)
+  {
+    GNUNET_free (di);
+    callback (callback_cls, NULL, NULL, NULL);
+    return GNUNET_SYSERR;
+  }
+  di->dirname = GNUNET_strdup (dir_name);
+  di->priority = prio;
+  return GNUNET_DISK_directory_iterator_next (di, GNUNET_NO);
+}
+
+/* end of disk_iterator */