1 files changed, 689 insertions, 684 deletions

diff --git a/src/util/disk.c b/src/util/disk.c
index 8b474542b..32667d554 100644
--- a/src/util/disk.c
+++ b/src/util/disk.c
@@ -28,13 +28,13 @@
 #include "gnunet_strings_lib.h"
 #include "gnunet_disk_lib.h"
 
-#define LOG(kind, ...) GNUNET_log_from(kind, "util-disk", __VA_ARGS__)
+#define LOG(kind, ...) GNUNET_log_from (kind, "util-disk", __VA_ARGS__)
 
 #define LOG_STRERROR(kind, syscall) \
-  GNUNET_log_from_strerror(kind, "util-disk", syscall)
+  GNUNET_log_from_strerror (kind, "util-disk", syscall)
 
 #define LOG_STRERROR_FILE(kind, syscall, filename) \
-  GNUNET_log_from_strerror_file(kind, "util-disk", syscall, filename)
+  GNUNET_log_from_strerror_file (kind, "util-disk", syscall, filename)
 
 /**
  * Block size for IO for copying files.
@@ -65,7 +65,8 @@
 /**
  * Handle used to manage a pipe.
  */
-struct GNUNET_DISK_PipeHandle {
+struct GNUNET_DISK_PipeHandle
+{
   /**
    * File descriptors for the pipe.
    * One or both of them could be NULL.
@@ -78,7 +79,8 @@ struct GNUNET_DISK_PipeHandle {
  * Closure for the recursion to determine the file size
  * of a directory.
  */
-struct GetFileSizeData {
+struct GetFileSizeData
+{
   /**
    * Set to the total file size.
    */
@@ -104,7 +106,7 @@ struct GetFileSizeData {
  * @return file permissions, UNIX style
  */
 static int
-translate_unix_perms(enum GNUNET_DISK_AccessPermissions perm)
+translate_unix_perms (enum GNUNET_DISK_AccessPermissions perm)
 {
   int mode;
 
@@ -141,41 +143,41 @@ translate_unix_perms(enum GNUNET_DISK_AccessPermissions perm)
  * @return #GNUNET_SYSERR on serious errors, otherwise #GNUNET_OK
  */
 static int
-getSizeRec(void *cls, const char *fn)
+getSizeRec (void *cls, const char *fn)
 {
   struct GetFileSizeData *gfsd = cls;
 
 #if defined(HAVE_STAT64) && \
-  !(defined(_FILE_OFFSET_BITS) && _FILE_OFFSET_BITS == 64)
+  ! (defined(_FILE_OFFSET_BITS) && _FILE_OFFSET_BITS == 64)
   struct stat64 buf;
 
-  if (0 != stat64(fn, &buf))
-    {
-      LOG_STRERROR_FILE(GNUNET_ERROR_TYPE_DEBUG, "stat64", fn);
-      return GNUNET_SYSERR;
-    }
+  if (0 != stat64 (fn, &buf))
+  {
+    LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_DEBUG, "stat64", fn);
+    return GNUNET_SYSERR;
+  }
 #else
   struct stat buf;
 
-  if (0 != stat(fn, &buf))
-    {
-      LOG_STRERROR_FILE(GNUNET_ERROR_TYPE_DEBUG, "stat", fn);
-      return GNUNET_SYSERR;
-    }
+  if (0 != stat (fn, &buf))
+  {
+    LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_DEBUG, "stat", fn);
+    return GNUNET_SYSERR;
+  }
 #endif
-  if ((S_ISDIR(buf.st_mode)) && (gfsd->single_file_mode == GNUNET_YES))
-    {
-      errno = EISDIR;
-      return GNUNET_SYSERR;
-    }
-  if ((!S_ISLNK(buf.st_mode)) || (gfsd->include_sym_links == GNUNET_YES))
+  if ((S_ISDIR (buf.st_mode)) && (gfsd->single_file_mode == GNUNET_YES))
+  {
+    errno = EISDIR;
+    return GNUNET_SYSERR;
+  }
+  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;
-    }
+  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;
 }
 
@@ -187,9 +189,9 @@ getSizeRec(void *cls, const char *fn)
  * @return #GNUNET_YES if invalid, #GNUNET_NO if valid
  */
 int
-GNUNET_DISK_handle_invalid(const struct GNUNET_DISK_FileHandle *h)
+GNUNET_DISK_handle_invalid (const struct GNUNET_DISK_FileHandle *h)
 {
-  return ((!h) || (h->fd == -1)) ? GNUNET_YES : GNUNET_NO;
+  return ((! h) || (h->fd == -1)) ? GNUNET_YES : GNUNET_NO;
 }
 
 /**
@@ -200,11 +202,11 @@ GNUNET_DISK_handle_invalid(const struct GNUNET_DISK_FileHandle *h)
  * @return #GNUNET_OK on success, #GNUNET_SYSERR on error
  */
 int
-GNUNET_DISK_file_handle_size(struct GNUNET_DISK_FileHandle *fh, off_t *size)
+GNUNET_DISK_file_handle_size (struct GNUNET_DISK_FileHandle *fh, off_t *size)
 {
   struct stat sbuf;
 
-  if (0 != fstat(fh->fd, &sbuf))
+  if (0 != fstat (fh->fd, &sbuf))
     return GNUNET_SYSERR;
   *size = sbuf.st_size;
   return GNUNET_OK;
@@ -220,19 +222,19 @@ GNUNET_DISK_file_handle_size(struct GNUNET_DISK_FileHandle *fh, off_t *size)
  * @return the new position on success, #GNUNET_SYSERR otherwise
  */
 off_t
-GNUNET_DISK_file_seek(const struct GNUNET_DISK_FileHandle *h,
-                      off_t offset,
-                      enum GNUNET_DISK_Seek whence)
+GNUNET_DISK_file_seek (const struct GNUNET_DISK_FileHandle *h,
+                       off_t offset,
+                       enum GNUNET_DISK_Seek whence)
 {
   if (h == NULL)
-    {
-      errno = EINVAL;
-      return GNUNET_SYSERR;
-    }
+  {
+    errno = EINVAL;
+    return GNUNET_SYSERR;
+  }
 
   static int t[] = { SEEK_SET, SEEK_CUR, SEEK_END };
 
-  return lseek(h->fd, offset, t[whence]);
+  return lseek (h->fd, offset, t[whence]);
 }
 
 
@@ -251,19 +253,19 @@ GNUNET_DISK_file_seek(const struct GNUNET_DISK_FileHandle *h,
  * @return #GNUNET_SYSERR on error, #GNUNET_OK on success
  */
 int
-GNUNET_DISK_file_size(const char *filename,
-                      uint64_t *size,
-                      int include_symbolic_links,
-                      int single_file_mode)
+GNUNET_DISK_file_size (const char *filename,
+                       uint64_t *size,
+                       int include_symbolic_links,
+                       int single_file_mode)
 {
   struct GetFileSizeData gfsd;
   int ret;
 
-  GNUNET_assert(size != NULL);
+  GNUNET_assert (size != NULL);
   gfsd.total = 0;
   gfsd.include_sym_links = include_symbolic_links;
   gfsd.single_file_mode = single_file_mode;
-  ret = getSizeRec(&gfsd, filename);
+  ret = getSizeRec (&gfsd, filename);
   *size = gfsd.total;
   return ret;
 }
@@ -285,19 +287,19 @@ GNUNET_DISK_file_size(const char *filename,
  * @return #GNUNET_OK on success
  */
 int
-GNUNET_DISK_file_get_identifiers(const char *filename,
-                                 uint64_t *dev,
-                                 uint64_t *ino)
+GNUNET_DISK_file_get_identifiers (const char *filename,
+                                  uint64_t *dev,
+                                  uint64_t *ino)
 {
 #if HAVE_STAT
   {
     struct stat sbuf;
 
-    if (0 != stat(filename, &sbuf))
-      {
-        return GNUNET_SYSERR;
-      }
-    *ino = (uint64_t)sbuf.st_ino;
+    if (0 != stat (filename, &sbuf))
+    {
+      return GNUNET_SYSERR;
+    }
+    *ino = (uint64_t) sbuf.st_ino;
   }
 #else
   *ino = 0;
@@ -306,22 +308,22 @@ GNUNET_DISK_file_get_identifiers(const char *filename,
   {
     struct statvfs fbuf;
 
-    if (0 != statvfs(filename, &fbuf))
-      {
-        return GNUNET_SYSERR;
-      }
-    *dev = (uint64_t)fbuf.f_fsid;
+    if (0 != statvfs (filename, &fbuf))
+    {
+      return GNUNET_SYSERR;
+    }
+    *dev = (uint64_t) fbuf.f_fsid;
   }
 #elif HAVE_STATFS
   {
     struct statfs fbuf;
 
-    if (0 != statfs(filename, &fbuf))
-      {
-        return GNUNET_SYSERR;
-      }
+    if (0 != statfs (filename, &fbuf))
+    {
+      return GNUNET_SYSERR;
+    }
     *dev =
-      ((uint64_t)fbuf.f_fsid.val[0]) << 32 || ((uint64_t)fbuf.f_fsid.val[1]);
+      ((uint64_t) fbuf.f_fsid.val[0]) << 32 || ((uint64_t) fbuf.f_fsid.val[1]);
   }
 #else
   *dev = 0;
@@ -337,28 +339,28 @@ GNUNET_DISK_file_get_identifiers(const char *filename,
  * @return name ready for passing to 'mktemp' or 'mkdtemp', NULL on error
  */
 static char *
-mktemp_name(const char *t)
+mktemp_name (const char *t)
 {
   const char *tmpdir;
   char *tmpl;
   char *fn;
 
   if ((t[0] != '/') && (t[0] != '\\'))
-    {
-      /* FIXME: This uses system codepage on W32, not UTF-8 */
-      tmpdir = getenv("TMPDIR");
-      if (NULL == tmpdir)
-        tmpdir = getenv("TMP");
-      if (NULL == tmpdir)
-        tmpdir = getenv("TEMP");
-      if (NULL == tmpdir)
-        tmpdir = "/tmp";
-      GNUNET_asprintf(&tmpl, "%s/%s%s", tmpdir, t, "XXXXXX");
-    }
+  {
+    /* FIXME: This uses system codepage on W32, not UTF-8 */
+    tmpdir = getenv ("TMPDIR");
+    if (NULL == tmpdir)
+      tmpdir = getenv ("TMP");
+    if (NULL == tmpdir)
+      tmpdir = getenv ("TEMP");
+    if (NULL == tmpdir)
+      tmpdir = "/tmp";
+    GNUNET_asprintf (&tmpl, "%s/%s%s", tmpdir, t, "XXXXXX");
+  }
   else
-    {
-      GNUNET_asprintf(&tmpl, "%s%s", t, "XXXXXX");
-    }
+  {
+    GNUNET_asprintf (&tmpl, "%s%s", t, "XXXXXX");
+  }
   fn = tmpl;
   return fn;
 }
@@ -373,9 +375,9 @@ mktemp_name(const char *t)
  * @param require_gid_match #GNUNET_YES means 770 unless @a require_uid_match is set
  */
 void
-GNUNET_DISK_fix_permissions(const char *fn,
-                            int require_uid_match,
-                            int require_gid_match)
+GNUNET_DISK_fix_permissions (const char *fn,
+                             int require_uid_match,
+                             int require_gid_match)
 {
   mode_t mode;
 
@@ -384,10 +386,10 @@ GNUNET_DISK_fix_permissions(const char *fn,
   else if (GNUNET_YES == require_gid_match)
     mode = S_IRUSR | S_IWUSR | S_IXUSR | S_IRGRP | S_IWGRP | S_IXGRP;
   else
-    mode = S_IRUSR | S_IWUSR | S_IXUSR | S_IRGRP | S_IWGRP | S_IXGRP | S_IROTH |
-           S_IWOTH | S_IXOTH;
-  if (0 != chmod(fn, mode))
-    GNUNET_log_strerror_file(GNUNET_ERROR_TYPE_WARNING, "chmod", fn);
+    mode = S_IRUSR | S_IWUSR | S_IXUSR | S_IRGRP | S_IWGRP | S_IXGRP | S_IROTH
+           | S_IWOTH | S_IXOTH;
+  if (0 != chmod (fn, mode))
+    GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING, "chmod", fn);
 }
 
 
@@ -403,21 +405,21 @@ GNUNET_DISK_fix_permissions(const char *fn,
  *         file on disk in directory for temporary files
  */
 char *
-GNUNET_DISK_mkdtemp(const char *t)
+GNUNET_DISK_mkdtemp (const char *t)
 {
   char *fn;
   mode_t omask;
 
-  omask = umask(S_IWGRP | S_IWOTH | S_IRGRP | S_IROTH);
-  fn = mktemp_name(t);
-  if (fn != mkdtemp(fn))
-    {
-      LOG_STRERROR_FILE(GNUNET_ERROR_TYPE_ERROR, "mkdtemp", fn);
-      GNUNET_free(fn);
-      umask(omask);
-      return NULL;
-    }
-  umask(omask);
+  omask = umask (S_IWGRP | S_IWOTH | S_IRGRP | S_IROTH);
+  fn = mktemp_name (t);
+  if (fn != mkdtemp (fn))
+  {
+    LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_ERROR, "mkdtemp", fn);
+    GNUNET_free (fn);
+    umask (omask);
+    return NULL;
+  }
+  umask (omask);
   return fn;
 }
 
@@ -430,23 +432,23 @@ GNUNET_DISK_mkdtemp(const char *t)
  * @param fil name of the file to back up
  */
 void
-GNUNET_DISK_file_backup(const char *fil)
+GNUNET_DISK_file_backup (const char *fil)
 {
   size_t slen;
   char *target;
   unsigned int num;
 
-  slen = strlen(fil) + 20;
-  target = GNUNET_malloc(slen);
+  slen = strlen (fil) + 20;
+  target = GNUNET_malloc (slen);
   num = 0;
   do
-    {
-      GNUNET_snprintf(target, slen, "%s.%u~", fil, num++);
-    }
-  while (0 == access(target, F_OK));
-  if (0 != rename(fil, target))
-    GNUNET_log_strerror_file(GNUNET_ERROR_TYPE_ERROR, "rename", fil);
-  GNUNET_free(target);
+  {
+    GNUNET_snprintf (target, slen, "%s.%u~", fil, num++);
+  }
+  while (0 == access (target, F_OK));
+  if (0 != rename (fil, target))
+    GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_ERROR, "rename", fil);
+  GNUNET_free (target);
 }
 
 
@@ -462,24 +464,24 @@ GNUNET_DISK_file_backup(const char *fil)
  *         file on disk in directory for temporary files
  */
 char *
-GNUNET_DISK_mktemp(const char *t)
+GNUNET_DISK_mktemp (const char *t)
 {
   int fd;
   char *fn;
   mode_t omask;
 
-  omask = umask(S_IWGRP | S_IWOTH | S_IRGRP | S_IROTH);
-  fn = mktemp_name(t);
-  if (-1 == (fd = mkstemp(fn)))
-    {
-      LOG_STRERROR_FILE(GNUNET_ERROR_TYPE_ERROR, "mkstemp", fn);
-      GNUNET_free(fn);
-      umask(omask);
-      return NULL;
-    }
-  umask(omask);
-  if (0 != close(fd))
-    LOG_STRERROR_FILE(GNUNET_ERROR_TYPE_WARNING, "close", fn);
+  omask = umask (S_IWGRP | S_IWOTH | S_IRGRP | S_IROTH);
+  fn = mktemp_name (t);
+  if (-1 == (fd = mkstemp (fn)))
+  {
+    LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_ERROR, "mkstemp", fn);
+    GNUNET_free (fn);
+    umask (omask);
+    return NULL;
+  }
+  umask (omask);
+  if (0 != close (fd))
+    LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_WARNING, "close", fn);
   return fn;
 }
 
@@ -497,34 +499,34 @@ GNUNET_DISK_mktemp(const char *t)
  *           does not exist or stat'ed
  */
 int
-GNUNET_DISK_directory_test(const char *fil, int is_readable)
+GNUNET_DISK_directory_test (const char *fil, int is_readable)
 {
   struct stat filestat;
   int ret;
 
-  ret = stat(fil, &filestat);
+  ret = stat (fil, &filestat);
   if (ret != 0)
-    {
-      if (errno != ENOENT)
-        LOG_STRERROR_FILE(GNUNET_ERROR_TYPE_WARNING, "stat", fil);
-      return GNUNET_SYSERR;
-    }
-  if (!S_ISDIR(filestat.st_mode))
-    {
-      LOG(GNUNET_ERROR_TYPE_INFO,
-          "A file already exits with the same name %s\n",
-          fil);
-      return GNUNET_NO;
-    }
+  {
+    if (errno != ENOENT)
+      LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_WARNING, "stat", fil);
+    return GNUNET_SYSERR;
+  }
+  if (! S_ISDIR (filestat.st_mode))
+  {
+    LOG (GNUNET_ERROR_TYPE_INFO,
+         "A file already exits with the same name %s\n",
+         fil);
+    return GNUNET_NO;
+  }
   if (GNUNET_YES == is_readable)
-    ret = access(fil, R_OK | X_OK);
+    ret = access (fil, R_OK | X_OK);
   else
-    ret = access(fil, X_OK);
+    ret = access (fil, X_OK);
   if (ret < 0)
-    {
-      LOG_STRERROR_FILE(GNUNET_ERROR_TYPE_WARNING, "access", fil);
-      return GNUNET_NO;
-    }
+  {
+    LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_WARNING, "access", fil);
+    return GNUNET_NO;
+  }
   return GNUNET_YES;
 }
 
@@ -538,40 +540,40 @@ GNUNET_DISK_directory_test(const char *fil, int is_readable)
  * else (will print an error message in that case, too).
  */
 int
-GNUNET_DISK_file_test(const char *fil)
+GNUNET_DISK_file_test (const char *fil)
 {
   struct stat filestat;
   int ret;
   char *rdir;
 
-  rdir = GNUNET_STRINGS_filename_expand(fil);
+  rdir = GNUNET_STRINGS_filename_expand (fil);
   if (rdir == NULL)
     return GNUNET_SYSERR;
 
-  ret = stat(rdir, &filestat);
+  ret = stat (rdir, &filestat);
   if (ret != 0)
+  {
+    if (errno != ENOENT)
     {
-      if (errno != ENOENT)
-        {
-          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, F_OK) < 0)
-    {
-      LOG_STRERROR_FILE(GNUNET_ERROR_TYPE_WARNING, "access", rdir);
-      GNUNET_free(rdir);
+      LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_WARNING, "stat", rdir);
+      GNUNET_free (rdir);
       return GNUNET_SYSERR;
     }
-  GNUNET_free(rdir);
+    GNUNET_free (rdir);
+    return GNUNET_NO;
+  }
+  if (! S_ISREG (filestat.st_mode))
+  {
+    GNUNET_free (rdir);
+    return GNUNET_NO;
+  }
+  if (access (rdir, F_OK) < 0)
+  {
+    LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_WARNING, "access", rdir);
+    GNUNET_free (rdir);
+    return GNUNET_SYSERR;
+  }
+  GNUNET_free (rdir);
   return GNUNET_YES;
 }
 
@@ -583,7 +585,7 @@ GNUNET_DISK_file_test(const char *fil)
  * @return #GNUNET_OK on success, #GNUNET_SYSERR on failure
  */
 int
-GNUNET_DISK_directory_create(const char *dir)
+GNUNET_DISK_directory_create (const char *dir)
 {
   char *rdir;
   unsigned int len;
@@ -591,14 +593,14 @@ GNUNET_DISK_directory_create(const char *dir)
   unsigned int pos2;
   int ret = GNUNET_OK;
 
-  rdir = GNUNET_STRINGS_filename_expand(dir);
+  rdir = GNUNET_STRINGS_filename_expand (dir);
   if (rdir == NULL)
-    {
-      GNUNET_break(0);
-      return GNUNET_SYSERR;
-    }
+  {
+    GNUNET_break (0);
+    return GNUNET_SYSERR;
+  }
 
-  len = strlen(rdir);
+  len = strlen (rdir);
 
   pos = 1; /* skip heading '/' */
 
@@ -606,64 +608,64 @@ GNUNET_DISK_directory_create(const char *dir)
   pos2 = len;
   rdir[len] = DIR_SEPARATOR;
   while (pos <= pos2)
+  {
+    if (DIR_SEPARATOR == rdir[pos2])
     {
-      if (DIR_SEPARATOR == rdir[pos2])
-        {
-          rdir[pos2] = '\0';
-          ret = GNUNET_DISK_directory_test(rdir, GNUNET_NO);
-          if (GNUNET_NO == ret)
-            {
-              GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
-                         "Creating directory `%s' failed",
-                         rdir);
-              GNUNET_free(rdir);
-              return GNUNET_SYSERR;
-            }
-          rdir[pos2] = DIR_SEPARATOR;
-          if (GNUNET_YES == ret)
-            {
-              pos2++;
-              break;
-            }
-        }
-      pos2--;
+      rdir[pos2] = '\0';
+      ret = GNUNET_DISK_directory_test (rdir, GNUNET_NO);
+      if (GNUNET_NO == ret)
+      {
+        GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                    "Creating directory `%s' failed",
+                    rdir);
+        GNUNET_free (rdir);
+        return GNUNET_SYSERR;
+      }
+      rdir[pos2] = DIR_SEPARATOR;
+      if (GNUNET_YES == ret)
+      {
+        pos2++;
+        break;
+      }
     }
+    pos2--;
+  }
   rdir[len] = '\0';
   if (pos < pos2)
     pos = pos2;
   /* Start creating directories */
   while (pos <= len)
+  {
+    if ((rdir[pos] == DIR_SEPARATOR) || (pos == len))
     {
-      if ((rdir[pos] == DIR_SEPARATOR) || (pos == len))
+      rdir[pos] = '\0';
+      ret = GNUNET_DISK_directory_test (rdir, GNUNET_NO);
+      if (GNUNET_NO == ret)
+      {
+        GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                    "Creating directory `%s' failed",
+                    rdir);
+        GNUNET_free (rdir);
+        return GNUNET_SYSERR;
+      }
+      if (GNUNET_SYSERR == ret)
+      {
+        ret = mkdir (rdir,
+                     S_IRUSR | S_IWUSR | S_IXUSR | S_IRGRP | S_IXGRP | S_IROTH
+                     | S_IXOTH);    /* 755 */
+
+        if ((ret != 0) && (errno != EEXIST))
         {
-          rdir[pos] = '\0';
-          ret = GNUNET_DISK_directory_test(rdir, GNUNET_NO);
-          if (GNUNET_NO == ret)
-            {
-              GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
-                         "Creating directory `%s' failed",
-                         rdir);
-              GNUNET_free(rdir);
-              return GNUNET_SYSERR;
-            }
-          if (GNUNET_SYSERR == ret)
-            {
-              ret = mkdir(rdir,
-                          S_IRUSR | S_IWUSR | S_IXUSR | S_IRGRP | S_IXGRP | S_IROTH |
-                          S_IXOTH); /* 755 */
-
-              if ((ret != 0) && (errno != EEXIST))
-                {
-                  LOG_STRERROR_FILE(GNUNET_ERROR_TYPE_ERROR, "mkdir", rdir);
-                  GNUNET_free(rdir);
-                  return GNUNET_SYSERR;
-                }
-            }
-          rdir[pos] = DIR_SEPARATOR;
+          LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_ERROR, "mkdir", rdir);
+          GNUNET_free (rdir);
+          return GNUNET_SYSERR;
         }
-      pos++;
+      }
+      rdir[pos] = DIR_SEPARATOR;
     }
-  GNUNET_free(rdir);
+    pos++;
+  }
+  GNUNET_free (rdir);
   return GNUNET_OK;
 }
 
@@ -678,40 +680,40 @@ GNUNET_DISK_directory_create(const char *dir)
  *          exists but is not writeable for us
  */
 int
-GNUNET_DISK_directory_create_for_file(const char *filename)
+GNUNET_DISK_directory_create_for_file (const char *filename)
 {
   char *rdir;
   size_t len;
   int ret;
   int eno;
 
-  rdir = GNUNET_STRINGS_filename_expand(filename);
+  rdir = GNUNET_STRINGS_filename_expand (filename);
   if (NULL == rdir)
-    {
-      errno = EINVAL;
-      return GNUNET_SYSERR;
-    }
-  if (0 == access(rdir, W_OK))
-    {
-      GNUNET_free(rdir);
-      return GNUNET_OK;
-    }
+  {
+    errno = EINVAL;
+    return GNUNET_SYSERR;
+  }
+  if (0 == access (rdir, W_OK))
+  {
+    GNUNET_free (rdir);
+    return GNUNET_OK;
+  }
 
-  len = strlen(rdir);
+  len = strlen (rdir);
   while ((len > 0) && (rdir[len] != DIR_SEPARATOR))
     len--;
   rdir[len] = '\0';
   /* The empty path is invalid and in this case refers to / */
   if (0 == len)
-    {
-      GNUNET_free(rdir);
-      rdir = GNUNET_strdup("/");
-    }
-  ret = GNUNET_DISK_directory_create(rdir);
-  if ((GNUNET_OK == ret) && (0 != access(rdir, W_OK)))
+  {
+    GNUNET_free (rdir);
+    rdir = GNUNET_strdup ("/");
+  }
+  ret = GNUNET_DISK_directory_create (rdir);
+  if ((GNUNET_OK == ret) && (0 != access (rdir, W_OK)))
     ret = GNUNET_NO;
   eno = errno;
-  GNUNET_free(rdir);
+  GNUNET_free (rdir);
   errno = eno;
   return ret;
 }
@@ -726,17 +728,17 @@ GNUNET_DISK_directory_create_for_file(const char *filename)
  * @return the number of bytes read on success, #GNUNET_SYSERR on failure
  */
 ssize_t
-GNUNET_DISK_file_read(const struct GNUNET_DISK_FileHandle *h,
-                      void *result,
-                      size_t len)
+GNUNET_DISK_file_read (const struct GNUNET_DISK_FileHandle *h,
+                       void *result,
+                       size_t len)
 {
   if (NULL == h)
-    {
-      errno = EINVAL;
-      return GNUNET_SYSERR;
-    }
+  {
+    errno = EINVAL;
+    return GNUNET_SYSERR;
+  }
 
-  return read(h->fd, result, len);
+  return read (h->fd, result, len);
 }
 
 
@@ -751,30 +753,30 @@ GNUNET_DISK_file_read(const struct GNUNET_DISK_FileHandle *h,
  * @return the number of bytes read on success, #GNUNET_SYSERR on failure
  */
 ssize_t
-GNUNET_DISK_file_read_non_blocking(const struct GNUNET_DISK_FileHandle *h,
-                                   void *result,
-                                   size_t len)
+GNUNET_DISK_file_read_non_blocking (const struct GNUNET_DISK_FileHandle *h,
+                                    void *result,
+                                    size_t len)
 {
   if (NULL == h)
-    {
-      errno = EINVAL;
-      return GNUNET_SYSERR;
-    }
+  {
+    errno = EINVAL;
+    return GNUNET_SYSERR;
+  }
 
   int flags;
   ssize_t ret;
 
   /* set to non-blocking, read, then set back */
-  flags = fcntl(h->fd, F_GETFL);
+  flags = fcntl (h->fd, F_GETFL);
   if (0 == (flags & O_NONBLOCK))
-    (void)fcntl(h->fd, F_SETFL, flags | O_NONBLOCK);
-  ret = read(h->fd, result, len);
+    (void) fcntl (h->fd, F_SETFL, flags | O_NONBLOCK);
+  ret = read (h->fd, result, len);
   if (0 == (flags & O_NONBLOCK))
-    {
-      int eno = errno;
-      (void)fcntl(h->fd, F_SETFL, flags);
-      errno = eno;
-    }
+  {
+    int eno = errno;
+    (void) fcntl (h->fd, F_SETFL, flags);
+    errno = eno;
+  }
   return ret;
 }
 
@@ -788,18 +790,18 @@ GNUNET_DISK_file_read_non_blocking(const struct GNUNET_DISK_FileHandle *h,
  * @return number of bytes read, #GNUNET_SYSERR on failure
  */
 ssize_t
-GNUNET_DISK_fn_read(const char *fn, void *result, size_t len)
+GNUNET_DISK_fn_read (const char *fn, void *result, size_t len)
 {
   struct GNUNET_DISK_FileHandle *fh;
   ssize_t ret;
   int eno;
 
-  fh = GNUNET_DISK_file_open(fn, GNUNET_DISK_OPEN_READ, GNUNET_DISK_PERM_NONE);
+  fh = GNUNET_DISK_file_open (fn, GNUNET_DISK_OPEN_READ, GNUNET_DISK_PERM_NONE);
   if (NULL == fh)
     return GNUNET_SYSERR;
-  ret = GNUNET_DISK_file_read(fh, result, len);
+  ret = GNUNET_DISK_file_read (fh, result, len);
   eno = errno;
-  GNUNET_assert(GNUNET_OK == GNUNET_DISK_file_close(fh));
+  GNUNET_assert (GNUNET_OK == GNUNET_DISK_file_close (fh));
   errno = eno;
   return ret;
 }
@@ -814,18 +816,18 @@ GNUNET_DISK_fn_read(const char *fn, void *result, size_t len)
  * @return number of bytes written on success, #GNUNET_SYSERR on error
  */
 ssize_t
-GNUNET_DISK_file_write(const struct GNUNET_DISK_FileHandle *h,
-                       const void *buffer,
-                       size_t n)
+GNUNET_DISK_file_write (const struct GNUNET_DISK_FileHandle *h,
+                        const void *buffer,
+                        size_t n)
 {
   if (NULL == h)
-    {
-      errno = EINVAL;
-      return GNUNET_SYSERR;
-    }
+  {
+    errno = EINVAL;
+    return GNUNET_SYSERR;
+  }
 
 
-  return write(h->fd, buffer, n);
+  return write (h->fd, buffer, n);
 }
 
 
@@ -838,27 +840,27 @@ GNUNET_DISK_file_write(const struct GNUNET_DISK_FileHandle *h,
  * @return number of bytes written on success, #GNUNET_SYSERR on error
  */
 ssize_t
-GNUNET_DISK_file_write_blocking(const struct GNUNET_DISK_FileHandle *h,
-                                const void *buffer,
-                                size_t n)
+GNUNET_DISK_file_write_blocking (const struct GNUNET_DISK_FileHandle *h,
+                                 const void *buffer,
+                                 size_t n)
 {
   if (NULL == h)
-    {
-      errno = EINVAL;
-      return GNUNET_SYSERR;
-    }
+  {
+    errno = EINVAL;
+    return GNUNET_SYSERR;
+  }
 
 
   int flags;
   ssize_t ret;
 
   /* set to blocking, write, then set back */
-  flags = fcntl(h->fd, F_GETFL);
+  flags = fcntl (h->fd, F_GETFL);
   if (0 != (flags & O_NONBLOCK))
-    (void)fcntl(h->fd, F_SETFL, flags - O_NONBLOCK);
-  ret = write(h->fd, buffer, n);
+    (void) fcntl (h->fd, F_SETFL, flags - O_NONBLOCK);
+  ret = write (h->fd, buffer, n);
   if (0 == (flags & O_NONBLOCK))
-    (void)fcntl(h->fd, F_SETFL, flags);
+    (void) fcntl (h->fd, F_SETFL, flags);
   return ret;
 }
 
@@ -874,23 +876,23 @@ GNUNET_DISK_file_write_blocking(const struct GNUNET_DISK_FileHandle *h,
  * @return number of bytes written on success, #GNUNET_SYSERR on error
  */
 ssize_t
-GNUNET_DISK_fn_write(const char *fn,
-                     const void *buffer,
-                     size_t n,
-                     enum GNUNET_DISK_AccessPermissions mode)
+GNUNET_DISK_fn_write (const char *fn,
+                      const void *buffer,
+                      size_t n,
+                      enum GNUNET_DISK_AccessPermissions mode)
 {
   struct GNUNET_DISK_FileHandle *fh;
   ssize_t ret;
 
   fh =
-    GNUNET_DISK_file_open(fn,
-                          GNUNET_DISK_OPEN_WRITE | GNUNET_DISK_OPEN_TRUNCATE |
-                          GNUNET_DISK_OPEN_CREATE,
-                          mode);
-  if (!fh)
+    GNUNET_DISK_file_open (fn,
+                           GNUNET_DISK_OPEN_WRITE | GNUNET_DISK_OPEN_TRUNCATE
+                           | GNUNET_DISK_OPEN_CREATE,
+                           mode);
+  if (! fh)
     return GNUNET_SYSERR;
-  ret = GNUNET_DISK_file_write(fh, buffer, n);
-  GNUNET_assert(GNUNET_OK == GNUNET_DISK_file_close(fh));
+  ret = GNUNET_DISK_file_write (fh, buffer, n);
+  GNUNET_assert (GNUNET_OK == GNUNET_DISK_file_close (fh));
   return ret;
 }
 
@@ -906,9 +908,9 @@ GNUNET_DISK_fn_write(const char *fn,
  *         ieration aborted by callback returning #GNUNET_SYSERR
  */
 int
-GNUNET_DISK_directory_scan(const char *dir_name,
-                           GNUNET_FileNameCallback callback,
-                           void *callback_cls)
+GNUNET_DISK_directory_scan (const char *dir_name,
+                            GNUNET_FileNameCallback callback,
+                            void *callback_cls)
 {
   DIR *dinfo;
   struct dirent *finfo;
@@ -920,80 +922,80 @@ GNUNET_DISK_directory_scan(const char *dir_name,
   unsigned int name_len;
   unsigned int n_size;
 
-  GNUNET_assert(NULL != dir_name);
-  dname = GNUNET_STRINGS_filename_expand(dir_name);
+  GNUNET_assert (NULL != dir_name);
+  dname = GNUNET_STRINGS_filename_expand (dir_name);
   if (NULL == dname)
     return GNUNET_SYSERR;
-  while ((strlen(dname) > 0) && (dname[strlen(dname) - 1] == DIR_SEPARATOR))
-    dname[strlen(dname) - 1] = '\0';
-  if (0 != stat(dname, &istat))
-    {
-      LOG_STRERROR_FILE(GNUNET_ERROR_TYPE_WARNING, "stat", dname);
-      GNUNET_free(dname);
-      return GNUNET_SYSERR;
-    }
-  if (!S_ISDIR(istat.st_mode))
-    {
-      LOG(GNUNET_ERROR_TYPE_WARNING,
-          _("Expected `%s' to be a directory!\n"),
-          dir_name);
-      GNUNET_free(dname);
-      return GNUNET_SYSERR;
-    }
+  while ((strlen (dname) > 0) && (dname[strlen (dname) - 1] == DIR_SEPARATOR))
+    dname[strlen (dname) - 1] = '\0';
+  if (0 != stat (dname, &istat))
+  {
+    LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_WARNING, "stat", dname);
+    GNUNET_free (dname);
+    return GNUNET_SYSERR;
+  }
+  if (! S_ISDIR (istat.st_mode))
+  {
+    LOG (GNUNET_ERROR_TYPE_WARNING,
+         _ ("Expected `%s' to be a directory!\n"),
+         dir_name);
+    GNUNET_free (dname);
+    return GNUNET_SYSERR;
+  }
   errno = 0;
-  dinfo = opendir(dname);
+  dinfo = opendir (dname);
   if ((EACCES == errno) || (NULL == dinfo))
-    {
-      LOG_STRERROR_FILE(GNUNET_ERROR_TYPE_WARNING, "opendir", dname);
-      if (NULL != dinfo)
-        closedir(dinfo);
-      GNUNET_free(dname);
-      return GNUNET_SYSERR;
-    }
+  {
+    LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_WARNING, "opendir", dname);
+    if (NULL != dinfo)
+      closedir (dinfo);
+    GNUNET_free (dname);
+    return GNUNET_SYSERR;
+  }
   name_len = 256;
-  n_size = strlen(dname) + name_len + strlen(DIR_SEPARATOR_STR) + 1;
-  name = GNUNET_malloc(n_size);
-  while (NULL != (finfo = readdir(dinfo)))
+  n_size = strlen (dname) + name_len + strlen (DIR_SEPARATOR_STR) + 1;
+  name = GNUNET_malloc (n_size);
+  while (NULL != (finfo = readdir (dinfo)))
+  {
+    if ((0 == strcmp (finfo->d_name, ".")) ||
+        (0 == strcmp (finfo->d_name, "..")))
+      continue;
+    if (NULL != callback)
     {
-      if ((0 == strcmp(finfo->d_name, ".")) ||
-          (0 == strcmp(finfo->d_name, "..")))
-        continue;
-      if (NULL != callback)
-        {
-          if (name_len < strlen(finfo->d_name))
-            {
-              GNUNET_free(name);
-              name_len = strlen(finfo->d_name);
-              n_size = strlen(dname) + name_len + strlen(DIR_SEPARATOR_STR) + 1;
-              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,
-                          (0 == strcmp(dname, DIR_SEPARATOR_STR))
-                          ? ""
-                          : DIR_SEPARATOR_STR,
-                          finfo->d_name);
-          ret = callback(callback_cls, name);
-          if (GNUNET_OK != ret)
-            {
-              closedir(dinfo);
-              GNUNET_free(name);
-              GNUNET_free(dname);
-              if (GNUNET_NO == ret)
-                return count;
-              return GNUNET_SYSERR;
-            }
-        }
-      count++;
+      if (name_len < strlen (finfo->d_name))
+      {
+        GNUNET_free (name);
+        name_len = strlen (finfo->d_name);
+        n_size = strlen (dname) + name_len + strlen (DIR_SEPARATOR_STR) + 1;
+        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,
+                       (0 == strcmp (dname, DIR_SEPARATOR_STR))
+                       ? ""
+                       : DIR_SEPARATOR_STR,
+                       finfo->d_name);
+      ret = callback (callback_cls, name);
+      if (GNUNET_OK != ret)
+      {
+        closedir (dinfo);
+        GNUNET_free (name);
+        GNUNET_free (dname);
+        if (GNUNET_NO == ret)
+          return count;
+        return GNUNET_SYSERR;
+      }
     }
-  closedir(dinfo);
-  GNUNET_free(name);
-  GNUNET_free(dname);
+    count++;
+  }
+  closedir (dinfo);
+  GNUNET_free (name);
+  GNUNET_free (dname);
   return count;
 }
 
@@ -1007,10 +1009,10 @@ GNUNET_DISK_directory_scan(const char *dir_name,
  * @return #GNUNET_OK
  */
 static int
-remove_helper(void *unused, const char *fn)
+remove_helper (void *unused, const char *fn)
 {
-  (void)unused;
-  (void)GNUNET_DISK_directory_remove(fn);
+  (void) unused;
+  (void) GNUNET_DISK_directory_remove (fn);
   return GNUNET_OK;
 }
 
@@ -1023,37 +1025,37 @@ remove_helper(void *unused, const char *fn)
  * @return #GNUNET_OK on success, #GNUNET_SYSERR on error
  */
 int
-GNUNET_DISK_directory_remove(const char *filename)
+GNUNET_DISK_directory_remove (const char *filename)
 {
   struct stat istat;
 
   if (NULL == filename)
-    {
-      GNUNET_break(0);
-      return GNUNET_SYSERR;
-    }
-  if (0 != lstat(filename, &istat))
+  {
+    GNUNET_break (0);
+    return GNUNET_SYSERR;
+  }
+  if (0 != lstat (filename, &istat))
     return GNUNET_NO; /* file may not exist... */
-  (void)chmod(filename, S_IWUSR | S_IRUSR | S_IXUSR);
-  if (0 == unlink(filename))
+  (void) chmod (filename, S_IWUSR | S_IRUSR | S_IXUSR);
+  if (0 == unlink (filename))
     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_YES)))
-    {
-      LOG_STRERROR_FILE(GNUNET_ERROR_TYPE_WARNING, "rmdir", filename);
-      return GNUNET_SYSERR;
-    }
+      (GNUNET_YES != GNUNET_DISK_directory_test (filename, GNUNET_YES)))
+  {
+    LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_WARNING, "rmdir", filename);
+    return GNUNET_SYSERR;
+  }
   if (GNUNET_SYSERR ==
-      GNUNET_DISK_directory_scan(filename, &remove_helper, NULL))
+      GNUNET_DISK_directory_scan (filename, &remove_helper, NULL))
     return GNUNET_SYSERR;
-  if (0 != rmdir(filename))
-    {
-      LOG_STRERROR_FILE(GNUNET_ERROR_TYPE_WARNING, "rmdir", filename);
-      return GNUNET_SYSERR;
-    }
+  if (0 != rmdir (filename))
+  {
+    LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_WARNING, "rmdir", filename);
+    return GNUNET_SYSERR;
+  }
   return GNUNET_OK;
 }
 
@@ -1066,7 +1068,7 @@ GNUNET_DISK_directory_remove(const char *filename)
  * @return #GNUNET_OK on success, #GNUNET_SYSERR on error
  */
 int
-GNUNET_DISK_file_copy(const char *src, const char *dst)
+GNUNET_DISK_file_copy (const char *src, const char *dst)
 {
   char *buf;
   uint64_t pos;
@@ -1076,55 +1078,55 @@ GNUNET_DISK_file_copy(const char *src, const char *dst)
   struct GNUNET_DISK_FileHandle *in;
   struct GNUNET_DISK_FileHandle *out;
 
-  if (GNUNET_OK != GNUNET_DISK_file_size(src, &size, GNUNET_YES, GNUNET_YES))
-    {
-      GNUNET_log_strerror_file(GNUNET_ERROR_TYPE_ERROR, "stat", src);
-      return GNUNET_SYSERR;
-    }
+  if (GNUNET_OK != GNUNET_DISK_file_size (src, &size, GNUNET_YES, GNUNET_YES))
+  {
+    GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_ERROR, "stat", src);
+    return GNUNET_SYSERR;
+  }
   pos = 0;
   in =
-    GNUNET_DISK_file_open(src, GNUNET_DISK_OPEN_READ, GNUNET_DISK_PERM_NONE);
-  if (!in)
-    {
-      GNUNET_log_strerror_file(GNUNET_ERROR_TYPE_ERROR, "open", src);
-      return GNUNET_SYSERR;
-    }
+    GNUNET_DISK_file_open (src, GNUNET_DISK_OPEN_READ, GNUNET_DISK_PERM_NONE);
+  if (! in)
+  {
+    GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_ERROR, "open", src);
+    return GNUNET_SYSERR;
+  }
   out =
-    GNUNET_DISK_file_open(dst,
-                          GNUNET_DISK_OPEN_WRITE | GNUNET_DISK_OPEN_CREATE |
-                          GNUNET_DISK_OPEN_FAILIFEXISTS,
-                          GNUNET_DISK_PERM_USER_READ |
-                          GNUNET_DISK_PERM_USER_WRITE |
-                          GNUNET_DISK_PERM_GROUP_READ |
-                          GNUNET_DISK_PERM_GROUP_WRITE);
-  if (!out)
-    {
-      GNUNET_log_strerror_file(GNUNET_ERROR_TYPE_ERROR, "open", dst);
-      GNUNET_DISK_file_close(in);
-      return GNUNET_SYSERR;
-    }
-  buf = GNUNET_malloc(COPY_BLK_SIZE);
+    GNUNET_DISK_file_open (dst,
+                           GNUNET_DISK_OPEN_WRITE | GNUNET_DISK_OPEN_CREATE
+                           | GNUNET_DISK_OPEN_FAILIFEXISTS,
+                           GNUNET_DISK_PERM_USER_READ
+                           | GNUNET_DISK_PERM_USER_WRITE
+                           | GNUNET_DISK_PERM_GROUP_READ
+                           | GNUNET_DISK_PERM_GROUP_WRITE);
+  if (! out)
+  {
+    GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_ERROR, "open", dst);
+    GNUNET_DISK_file_close (in);
+    return GNUNET_SYSERR;
+  }
+  buf = GNUNET_malloc (COPY_BLK_SIZE);
   while (pos < size)
-    {
-      len = COPY_BLK_SIZE;
-      if (len > size - pos)
-        len = size - pos;
-      sret = GNUNET_DISK_file_read(in, buf, len);
-      if ((sret < 0) || (len != (size_t)sret))
-        goto FAIL;
-      sret = GNUNET_DISK_file_write(out, buf, len);
-      if ((sret < 0) || (len != (size_t)sret))
-        goto FAIL;
-      pos += len;
-    }
-  GNUNET_free(buf);
-  GNUNET_DISK_file_close(in);
-  GNUNET_DISK_file_close(out);
+  {
+    len = COPY_BLK_SIZE;
+    if (len > size - pos)
+      len = size - pos;
+    sret = GNUNET_DISK_file_read (in, buf, len);
+    if ((sret < 0) || (len != (size_t) sret))
+      goto FAIL;
+    sret = GNUNET_DISK_file_write (out, buf, len);
+    if ((sret < 0) || (len != (size_t) sret))
+      goto FAIL;
+    pos += len;
+  }
+  GNUNET_free (buf);
+  GNUNET_DISK_file_close (in);
+  GNUNET_DISK_file_close (out);
   return GNUNET_OK;
 FAIL:
-  GNUNET_free(buf);
-  GNUNET_DISK_file_close(in);
-  GNUNET_DISK_file_close(out);
+  GNUNET_free (buf);
+  GNUNET_DISK_file_close (in);
+  GNUNET_DISK_file_close (out);
   return GNUNET_SYSERR;
 }
 
@@ -1134,21 +1136,23 @@ FAIL:
  * @param fn the filename to canonicalize
  */
 void
-GNUNET_DISK_filename_canonicalize(char *fn)
+GNUNET_DISK_filename_canonicalize (char *fn)
 {
   char *idx;
   char c;
 
   for (idx = fn; *idx; idx++)
-    {
-      c = *idx;
+  {
+    c = *idx;
 
-      if (c == '/' || c == '\\' || c == ':' || c == '*' || c == '?' || c == '"' ||
-          c == '<' || c == '>' || c == '|')
-        {
-          *idx = '_';
-        }
+    if ((c == '/') ||(c == '\\') ||(c == ':') ||(c == '*') ||(c == '?') ||(c ==
+                                                                           '"')
+        ||
+        (c == '<') ||(c == '>') ||(c == '|') )
+    {
+      *idx = '_';
     }
+  }
 }
 
 
@@ -1160,24 +1164,24 @@ GNUNET_DISK_filename_canonicalize(char *fn)
  * @return #GNUNET_OK on success, #GNUNET_SYSERR on failure
  */
 int
-GNUNET_DISK_file_change_owner(const char *filename, const char *user)
+GNUNET_DISK_file_change_owner (const char *filename, const char *user)
 {
   struct passwd *pws;
 
-  pws = getpwnam(user);
+  pws = getpwnam (user);
   if (NULL == pws)
-    {
-      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))
-    {
-      LOG_STRERROR_FILE(GNUNET_ERROR_TYPE_WARNING, "chown", filename);
-      return GNUNET_SYSERR;
-    }
+  {
+    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))
+  {
+    LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_WARNING, "chown", filename);
+    return GNUNET_SYSERR;
+  }
   return GNUNET_OK;
 }
 
@@ -1192,26 +1196,26 @@ GNUNET_DISK_file_change_owner(const char *filename, const char *user)
  * @return #GNUNET_OK on success, #GNUNET_SYSERR on error
  */
 int
-GNUNET_DISK_file_lock(struct GNUNET_DISK_FileHandle *fh,
-                      off_t lock_start,
-                      off_t lock_end,
-                      int excl)
+GNUNET_DISK_file_lock (struct GNUNET_DISK_FileHandle *fh,
+                       off_t lock_start,
+                       off_t lock_end,
+                       int excl)
 {
   if (fh == NULL)
-    {
-      errno = EINVAL;
-      return GNUNET_SYSERR;
-    }
+  {
+    errno = EINVAL;
+    return GNUNET_SYSERR;
+  }
 
   struct flock fl;
 
-  memset(&fl, 0, sizeof(struct flock));
+  memset (&fl, 0, sizeof(struct flock));
   fl.l_type = excl ? F_WRLCK : F_RDLCK;
   fl.l_whence = SEEK_SET;
   fl.l_start = lock_start;
   fl.l_len = lock_end;
 
-  return fcntl(fh->fd, F_SETLK, &fl) != 0 ? GNUNET_SYSERR : GNUNET_OK;
+  return fcntl (fh->fd, F_SETLK, &fl) != 0 ? GNUNET_SYSERR : GNUNET_OK;
 }
 
 
@@ -1224,25 +1228,25 @@ GNUNET_DISK_file_lock(struct GNUNET_DISK_FileHandle *fh,
  * @return #GNUNET_OK on success, #GNUNET_SYSERR on error
  */
 int
-GNUNET_DISK_file_unlock(struct GNUNET_DISK_FileHandle *fh,
-                        off_t unlock_start,
-                        off_t unlock_end)
+GNUNET_DISK_file_unlock (struct GNUNET_DISK_FileHandle *fh,
+                         off_t unlock_start,
+                         off_t unlock_end)
 {
   if (fh == NULL)
-    {
-      errno = EINVAL;
-      return GNUNET_SYSERR;
-    }
+  {
+    errno = EINVAL;
+    return GNUNET_SYSERR;
+  }
 
   struct flock fl;
 
-  memset(&fl, 0, sizeof(struct flock));
+  memset (&fl, 0, sizeof(struct flock));
   fl.l_type = F_UNLCK;
   fl.l_whence = SEEK_SET;
   fl.l_start = unlock_start;
   fl.l_len = unlock_end;
 
-  return fcntl(fh->fd, F_SETLK, &fl) != 0 ? GNUNET_SYSERR : GNUNET_OK;
+  return fcntl (fh->fd, F_SETLK, &fl) != 0 ? GNUNET_SYSERR : GNUNET_OK;
 }
 
 
@@ -1259,9 +1263,9 @@ GNUNET_DISK_file_unlock(struct GNUNET_DISK_FileHandle *fh,
  * @return IO handle on success, NULL on error
  */
 struct GNUNET_DISK_FileHandle *
-GNUNET_DISK_file_open(const char *fn,
-                      enum GNUNET_DISK_OpenFlags flags,
-                      enum GNUNET_DISK_AccessPermissions perm)
+GNUNET_DISK_file_open (const char *fn,
+                       enum GNUNET_DISK_OpenFlags flags,
+                       enum GNUNET_DISK_AccessPermissions perm)
 {
   char *expfn;
   struct GNUNET_DISK_FileHandle *ret;
@@ -1270,7 +1274,7 @@ GNUNET_DISK_file_open(const char *fn,
   int mode;
   int fd;
 
-  expfn = GNUNET_STRINGS_filename_expand(fn);
+  expfn = GNUNET_STRINGS_filename_expand (fn);
   if (NULL == expfn)
     return NULL;
 
@@ -1282,49 +1286,49 @@ GNUNET_DISK_file_open(const char *fn,
   else if (flags & GNUNET_DISK_OPEN_WRITE)
     oflags = O_WRONLY;
   else
-    {
-      GNUNET_break(0);
-      GNUNET_free(expfn);
-      return NULL;
-    }
+  {
+    GNUNET_break (0);
+    GNUNET_free (expfn);
+    return NULL;
+  }
   if (flags & GNUNET_DISK_OPEN_FAILIFEXISTS)
     oflags |= (O_CREAT | O_EXCL);
   if (flags & GNUNET_DISK_OPEN_TRUNCATE)
     oflags |= O_TRUNC;
   if (flags & GNUNET_DISK_OPEN_APPEND)
     oflags |= O_APPEND;
-  if (GNUNET_NO == GNUNET_DISK_file_test(fn))
+  if (GNUNET_NO == GNUNET_DISK_file_test (fn))
+  {
+    if (flags & GNUNET_DISK_OPEN_CREATE)
     {
-      if (flags & GNUNET_DISK_OPEN_CREATE)
-        {
-          (void)GNUNET_DISK_directory_create_for_file(expfn);
-          oflags |= O_CREAT;
-          mode = translate_unix_perms(perm);
-        }
+      (void) GNUNET_DISK_directory_create_for_file (expfn);
+      oflags |= O_CREAT;
+      mode = translate_unix_perms (perm);
     }
+  }
 
-  fd = open(expfn,
-            oflags
+  fd = open (expfn,
+             oflags
 #if O_CLOEXEC
-            | O_CLOEXEC
+             | O_CLOEXEC
 #endif
-            | O_LARGEFILE,
-            mode);
+             | O_LARGEFILE,
+             mode);
   if (fd == -1)
-    {
-      if (0 == (flags & GNUNET_DISK_OPEN_FAILIFEXISTS))
-        LOG_STRERROR_FILE(GNUNET_ERROR_TYPE_WARNING, "open", expfn);
-      else
-        LOG_STRERROR_FILE(GNUNET_ERROR_TYPE_DEBUG, "open", expfn);
-      GNUNET_free(expfn);
-      return NULL;
-    }
+  {
+    if (0 == (flags & GNUNET_DISK_OPEN_FAILIFEXISTS))
+      LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_WARNING, "open", expfn);
+    else
+      LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_DEBUG, "open", expfn);
+    GNUNET_free (expfn);
+    return NULL;
+  }
 
-  ret = GNUNET_new(struct GNUNET_DISK_FileHandle);
+  ret = GNUNET_new (struct GNUNET_DISK_FileHandle);
 
   ret->fd = fd;
 
-  GNUNET_free(expfn);
+  GNUNET_free (expfn);
   return ret;
 }
 
@@ -1336,25 +1340,25 @@ GNUNET_DISK_file_open(const char *fn,
  * @return #GNUNET_OK on success, #GNUNET_SYSERR otherwise
  */
 int
-GNUNET_DISK_file_close(struct GNUNET_DISK_FileHandle *h)
+GNUNET_DISK_file_close (struct GNUNET_DISK_FileHandle *h)
 {
   int ret;
 
   if (h == NULL)
-    {
-      errno = EINVAL;
-      return GNUNET_SYSERR;
-    }
+  {
+    errno = EINVAL;
+    return GNUNET_SYSERR;
+  }
 
   ret = GNUNET_OK;
 
-  if (close(h->fd) != 0)
-    {
-      LOG_STRERROR(GNUNET_ERROR_TYPE_WARNING, "close");
-      ret = GNUNET_SYSERR;
-    }
+  if (close (h->fd) != 0)
+  {
+    LOG_STRERROR (GNUNET_ERROR_TYPE_WARNING, "close");
+    ret = GNUNET_SYSERR;
+  }
 
-  GNUNET_free(h);
+  GNUNET_free (h);
   return ret;
 }
 
@@ -1366,14 +1370,14 @@ GNUNET_DISK_file_close(struct GNUNET_DISK_FileHandle *h)
  * @return file handle corresponding to the descriptor, NULL on error
  */
 struct GNUNET_DISK_FileHandle *
-GNUNET_DISK_get_handle_from_int_fd(int fno)
+GNUNET_DISK_get_handle_from_int_fd (int fno)
 {
   struct GNUNET_DISK_FileHandle *fh;
 
-  if ((((off_t)-1) == lseek(fno, 0, SEEK_CUR)) && (EBADF == errno))
+  if ((((off_t) -1) == lseek (fno, 0, SEEK_CUR)) && (EBADF == errno))
     return NULL; /* invalid FD */
 
-  fh = GNUNET_new(struct GNUNET_DISK_FileHandle);
+  fh = GNUNET_new (struct GNUNET_DISK_FileHandle);
 
   fh->fd = fno;
 
@@ -1388,22 +1392,23 @@ GNUNET_DISK_get_handle_from_int_fd(int fno)
  * @return file handle corresponding to the descriptor
  */
 struct GNUNET_DISK_FileHandle *
-GNUNET_DISK_get_handle_from_native(FILE *fd)
+GNUNET_DISK_get_handle_from_native (FILE *fd)
 {
   int fno;
 
-  fno = fileno(fd);
+  fno = fileno (fd);
   if (-1 == fno)
     return NULL;
 
-  return GNUNET_DISK_get_handle_from_int_fd(fno);
+  return GNUNET_DISK_get_handle_from_int_fd (fno);
 }
 
 
 /**
  * Handle for a memory-mapping operation.
  */
-struct GNUNET_DISK_MapHandle {
+struct GNUNET_DISK_MapHandle
+{
   /**
    * Address where the map is in memory.
    */
@@ -1417,7 +1422,7 @@ struct GNUNET_DISK_MapHandle {
 
 
 #ifndef MAP_FAILED
-#define MAP_FAILED ((void *)-1)
+#define MAP_FAILED ((void *) -1)
 #endif
 
 /**
@@ -1430,16 +1435,16 @@ struct GNUNET_DISK_MapHandle {
  * @return pointer to the mapped memory region, NULL on failure
  */
 void *
-GNUNET_DISK_file_map(const struct GNUNET_DISK_FileHandle *h,
-                     struct GNUNET_DISK_MapHandle **m,
-                     enum GNUNET_DISK_MapType access,
-                     size_t len)
+GNUNET_DISK_file_map (const struct GNUNET_DISK_FileHandle *h,
+                      struct GNUNET_DISK_MapHandle **m,
+                      enum GNUNET_DISK_MapType access,
+                      size_t len)
 {
   if (NULL == h)
-    {
-      errno = EINVAL;
-      return NULL;
-    }
+  {
+    errno = EINVAL;
+    return NULL;
+  }
 
   int prot;
 
@@ -1448,14 +1453,14 @@ GNUNET_DISK_file_map(const struct GNUNET_DISK_FileHandle *h,
     prot = PROT_READ;
   if (access & GNUNET_DISK_MAP_TYPE_WRITE)
     prot |= PROT_WRITE;
-  *m = GNUNET_new(struct GNUNET_DISK_MapHandle);
-  (*m)->addr = mmap(NULL, len, prot, MAP_SHARED, h->fd, 0);
-  GNUNET_assert(NULL != (*m)->addr);
+  *m = GNUNET_new (struct GNUNET_DISK_MapHandle);
+  (*m)->addr = mmap (NULL, len, prot, MAP_SHARED, h->fd, 0);
+  GNUNET_assert (NULL != (*m)->addr);
   if (MAP_FAILED == (*m)->addr)
-    {
-      GNUNET_free(*m);
-      return NULL;
-    }
+  {
+    GNUNET_free (*m);
+    return NULL;
+  }
   (*m)->len = len;
   return (*m)->addr;
 }
@@ -1466,19 +1471,19 @@ GNUNET_DISK_file_map(const struct GNUNET_DISK_FileHandle *h,
  * @return GNUNET_OK on success, GNUNET_SYSERR otherwise
  */
 int
-GNUNET_DISK_file_unmap(struct GNUNET_DISK_MapHandle *h)
+GNUNET_DISK_file_unmap (struct GNUNET_DISK_MapHandle *h)
 {
   int ret;
 
   if (h == NULL)
-    {
-      errno = EINVAL;
-      return GNUNET_SYSERR;
-    }
+  {
+    errno = EINVAL;
+    return GNUNET_SYSERR;
+  }
 
-  ret = munmap(h->addr, h->len) != -1 ? GNUNET_OK : GNUNET_SYSERR;
+  ret = munmap (h->addr, h->len) != -1 ? GNUNET_OK : GNUNET_SYSERR;
 
-  GNUNET_free(h);
+  GNUNET_free (h);
   return ret;
 }
 
@@ -1489,18 +1494,18 @@ GNUNET_DISK_file_unmap(struct GNUNET_DISK_MapHandle *h)
  * @return GNUNET_OK on success, GNUNET_SYSERR otherwise
  */
 int
-GNUNET_DISK_file_sync(const struct GNUNET_DISK_FileHandle *h)
+GNUNET_DISK_file_sync (const struct GNUNET_DISK_FileHandle *h)
 {
   if (h == NULL)
-    {
-      errno = EINVAL;
-      return GNUNET_SYSERR;
-    }
+  {
+    errno = EINVAL;
+    return GNUNET_SYSERR;
+  }
 
 #if defined(FREEBSD) || defined(OPENBSD) || defined(DARWIN)
-  return fsync(h->fd) == -1 ? GNUNET_SYSERR : GNUNET_OK;
+  return fsync (h->fd) == -1 ? GNUNET_SYSERR : GNUNET_OK;
 #else
-  return fdatasync(h->fd) == -1 ? GNUNET_SYSERR : GNUNET_OK;
+  return fdatasync (h->fd) == -1 ? GNUNET_SYSERR : GNUNET_OK;
 #endif
 }
 
@@ -1515,26 +1520,26 @@ GNUNET_DISK_file_sync(const struct GNUNET_DISK_FileHandle *h)
  * @return handle to the new pipe, NULL on error
  */
 struct GNUNET_DISK_PipeHandle *
-GNUNET_DISK_pipe(int blocking_read,
-                 int blocking_write,
-                 int inherit_read,
-                 int inherit_write)
+GNUNET_DISK_pipe (int blocking_read,
+                  int blocking_write,
+                  int inherit_read,
+                  int inherit_write)
 {
   int fd[2];
   int ret;
   int eno;
 
-  (void)inherit_read;
-  (void)inherit_write;
-  ret = pipe(fd);
+  (void) inherit_read;
+  (void) inherit_write;
+  ret = pipe (fd);
   if (ret == -1)
-    {
-      eno = errno;
-      LOG_STRERROR(GNUNET_ERROR_TYPE_ERROR, "pipe");
-      errno = eno;
-      return NULL;
-    }
-  return GNUNET_DISK_pipe_from_fd(blocking_read, blocking_write, fd);
+  {
+    eno = errno;
+    LOG_STRERROR (GNUNET_ERROR_TYPE_ERROR, "pipe");
+    errno = eno;
+    return NULL;
+  }
+  return GNUNET_DISK_pipe_from_fd (blocking_read, blocking_write, fd);
 }
 
 
@@ -1549,11 +1554,11 @@ GNUNET_DISK_pipe(int blocking_read,
  * @return handle to the new pipe, NULL on error
  */
 struct GNUNET_DISK_PipeHandle *
-GNUNET_DISK_pipe_from_fd(int blocking_read, int blocking_write, int fd[2])
+GNUNET_DISK_pipe_from_fd (int blocking_read, int blocking_write, int fd[2])
 {
   struct GNUNET_DISK_PipeHandle *p;
 
-  p = GNUNET_new(struct GNUNET_DISK_PipeHandle);
+  p = GNUNET_new (struct GNUNET_DISK_PipeHandle);
 
   int ret;
   int flags;
@@ -1561,64 +1566,64 @@ GNUNET_DISK_pipe_from_fd(int blocking_read, int blocking_write, int fd[2])
 
   ret = 0;
   if (fd[0] >= 0)
+  {
+    p->fd[0] = GNUNET_new (struct GNUNET_DISK_FileHandle);
+    p->fd[0]->fd = fd[0];
+    if (! blocking_read)
     {
-      p->fd[0] = GNUNET_new(struct GNUNET_DISK_FileHandle);
-      p->fd[0]->fd = fd[0];
-      if (!blocking_read)
-        {
-          flags = fcntl(fd[0], F_GETFL);
-          flags |= O_NONBLOCK;
-          if (0 > fcntl(fd[0], F_SETFL, flags))
-            {
-              ret = -1;
-              eno = errno;
-            }
-        }
-      flags = fcntl(fd[0], F_GETFD);
-      flags |= FD_CLOEXEC;
-      if (0 > fcntl(fd[0], F_SETFD, flags))
-        {
-          ret = -1;
-          eno = errno;
-        }
+      flags = fcntl (fd[0], F_GETFL);
+      flags |= O_NONBLOCK;
+      if (0 > fcntl (fd[0], F_SETFL, flags))
+      {
+        ret = -1;
+        eno = errno;
+      }
+    }
+    flags = fcntl (fd[0], F_GETFD);
+    flags |= FD_CLOEXEC;
+    if (0 > fcntl (fd[0], F_SETFD, flags))
+    {
+      ret = -1;
+      eno = errno;
     }
+  }
 
   if (fd[1] >= 0)
+  {
+    p->fd[1] = GNUNET_new (struct GNUNET_DISK_FileHandle);
+    p->fd[1]->fd = fd[1];
+    if (! blocking_write)
     {
-      p->fd[1] = GNUNET_new(struct GNUNET_DISK_FileHandle);
-      p->fd[1]->fd = fd[1];
-      if (!blocking_write)
-        {
-          flags = fcntl(fd[1], F_GETFL);
-          flags |= O_NONBLOCK;
-          if (0 > fcntl(fd[1], F_SETFL, flags))
-            {
-              ret = -1;
-              eno = errno;
-            }
-        }
-      flags = fcntl(fd[1], F_GETFD);
-      flags |= FD_CLOEXEC;
-      if (0 > fcntl(fd[1], F_SETFD, flags))
-        {
-          ret = -1;
-          eno = errno;
-        }
+      flags = fcntl (fd[1], F_GETFL);
+      flags |= O_NONBLOCK;
+      if (0 > fcntl (fd[1], F_SETFL, flags))
+      {
+        ret = -1;
+        eno = errno;
+      }
     }
-  if (ret == -1)
+    flags = fcntl (fd[1], F_GETFD);
+    flags |= FD_CLOEXEC;
+    if (0 > fcntl (fd[1], F_SETFD, flags))
     {
-      errno = eno;
-      LOG_STRERROR(GNUNET_ERROR_TYPE_ERROR, "fcntl");
-      if (p->fd[0]->fd >= 0)
-        GNUNET_break(0 == close(p->fd[0]->fd));
-      if (p->fd[1]->fd >= 0)
-        GNUNET_break(0 == close(p->fd[1]->fd));
-      GNUNET_free_non_null(p->fd[0]);
-      GNUNET_free_non_null(p->fd[1]);
-      GNUNET_free(p);
-      errno = eno;
-      return NULL;
+      ret = -1;
+      eno = errno;
     }
+  }
+  if (ret == -1)
+  {
+    errno = eno;
+    LOG_STRERROR (GNUNET_ERROR_TYPE_ERROR, "fcntl");
+    if (p->fd[0]->fd >= 0)
+      GNUNET_break (0 == close (p->fd[0]->fd));
+    if (p->fd[1]->fd >= 0)
+      GNUNET_break (0 == close (p->fd[1]->fd));
+    GNUNET_free_non_null (p->fd[0]);
+    GNUNET_free_non_null (p->fd[1]);
+    GNUNET_free (p);
+    errno = eno;
+    return NULL;
+  }
 
   return p;
 }
@@ -1632,27 +1637,27 @@ GNUNET_DISK_pipe_from_fd(int blocking_read, int blocking_write, int fd[2])
  * @return GNUNET_OK on success, GNUNET_SYSERR otherwise
  */
 int
-GNUNET_DISK_pipe_close_end(struct GNUNET_DISK_PipeHandle *p,
-                           enum GNUNET_DISK_PipeEnd end)
+GNUNET_DISK_pipe_close_end (struct GNUNET_DISK_PipeHandle *p,
+                            enum GNUNET_DISK_PipeEnd end)
 {
   int ret = GNUNET_OK;
 
   if (end == GNUNET_DISK_PIPE_END_READ)
+  {
+    if (p->fd[0])
     {
-      if (p->fd[0])
-        {
-          ret = GNUNET_DISK_file_close(p->fd[0]);
-          p->fd[0] = NULL;
-        }
+      ret = GNUNET_DISK_file_close (p->fd[0]);
+      p->fd[0] = NULL;
     }
+  }
   else if (end == GNUNET_DISK_PIPE_END_WRITE)
+  {
+    if (p->fd[1])
     {
-      if (p->fd[1])
-        {
-          ret = GNUNET_DISK_file_close(p->fd[1]);
-          p->fd[1] = NULL;
-        }
+      ret = GNUNET_DISK_file_close (p->fd[1]);
+      p->fd[1] = NULL;
     }
+  }
 
   return ret;
 }
@@ -1670,27 +1675,27 @@ GNUNET_DISK_pipe_close_end(struct GNUNET_DISK_PipeHandle *p,
  * (or if that end is not present or is closed).
  */
 struct GNUNET_DISK_FileHandle *
-GNUNET_DISK_pipe_detach_end(struct GNUNET_DISK_PipeHandle *p,
-                            enum GNUNET_DISK_PipeEnd end)
+GNUNET_DISK_pipe_detach_end (struct GNUNET_DISK_PipeHandle *p,
+                             enum GNUNET_DISK_PipeEnd end)
 {
   struct GNUNET_DISK_FileHandle *ret = NULL;
 
   if (end == GNUNET_DISK_PIPE_END_READ)
+  {
+    if (p->fd[0])
     {
-      if (p->fd[0])
-        {
-          ret = p->fd[0];
-          p->fd[0] = NULL;
-        }
+      ret = p->fd[0];
+      p->fd[0] = NULL;
     }
+  }
   else if (end == GNUNET_DISK_PIPE_END_WRITE)
+  {
+    if (p->fd[1])
     {
-      if (p->fd[1])
-        {
-          ret = p->fd[1];
-          p->fd[1] = NULL;
-        }
+      ret = p->fd[1];
+      p->fd[1] = NULL;
     }
+  }
 
   return ret;
 }
@@ -1703,7 +1708,7 @@ GNUNET_DISK_pipe_detach_end(struct GNUNET_DISK_PipeHandle *p,
  * @return GNUNET_OK on success, GNUNET_SYSERR otherwise
  */
 int
-GNUNET_DISK_pipe_close(struct GNUNET_DISK_PipeHandle *p)
+GNUNET_DISK_pipe_close (struct GNUNET_DISK_PipeHandle *p)
 {
   int ret = GNUNET_OK;
 
@@ -1712,22 +1717,22 @@ GNUNET_DISK_pipe_close(struct GNUNET_DISK_PipeHandle *p)
   int read_end_close_errno;
   int write_end_close_errno;
 
-  read_end_close = GNUNET_DISK_pipe_close_end(p, GNUNET_DISK_PIPE_END_READ);
+  read_end_close = GNUNET_DISK_pipe_close_end (p, GNUNET_DISK_PIPE_END_READ);
   read_end_close_errno = errno;
-  write_end_close = GNUNET_DISK_pipe_close_end(p, GNUNET_DISK_PIPE_END_WRITE);
+  write_end_close = GNUNET_DISK_pipe_close_end (p, GNUNET_DISK_PIPE_END_WRITE);
   write_end_close_errno = errno;
-  GNUNET_free(p);
+  GNUNET_free (p);
 
   if (GNUNET_OK != read_end_close)
-    {
-      errno = read_end_close_errno;
-      ret = read_end_close;
-    }
+  {
+    errno = read_end_close_errno;
+    ret = read_end_close;
+  }
   else if (GNUNET_OK != write_end_close)
-    {
-      errno = write_end_close_errno;
-      ret = write_end_close;
-    }
+  {
+    errno = write_end_close_errno;
+    ret = write_end_close;
+  }
 
   return ret;
 }
@@ -1741,19 +1746,19 @@ GNUNET_DISK_pipe_close(struct GNUNET_DISK_PipeHandle *p)
  * @return handle for the respective end
  */
 const struct GNUNET_DISK_FileHandle *
-GNUNET_DISK_pipe_handle(const struct GNUNET_DISK_PipeHandle *p,
-                        enum GNUNET_DISK_PipeEnd n)
+GNUNET_DISK_pipe_handle (const struct GNUNET_DISK_PipeHandle *p,
+                         enum GNUNET_DISK_PipeEnd n)
 {
   switch (n)
-    {
-    case GNUNET_DISK_PIPE_END_READ:
-    case GNUNET_DISK_PIPE_END_WRITE:
-      return p->fd[n];
+  {
+  case GNUNET_DISK_PIPE_END_READ:
+  case GNUNET_DISK_PIPE_END_WRITE:
+    return p->fd[n];
 
-    default:
-      GNUNET_break(0);
-      return NULL;
-    }
+  default:
+    GNUNET_break (0);
+    return NULL;
+  }
 }
 
 
@@ -1766,16 +1771,16 @@ GNUNET_DISK_pipe_handle(const struct GNUNET_DISK_PipeHandle *p,
  * @return #GNUNET_OK on success, #GNUNET_SYSERR otherwise
  */
 int
-GNUNET_DISK_internal_file_handle_(const struct GNUNET_DISK_FileHandle *fh,
-                                  void *dst,
-                                  size_t dst_len)
+GNUNET_DISK_internal_file_handle_ (const struct GNUNET_DISK_FileHandle *fh,
+                                   void *dst,
+                                   size_t dst_len)
 {
   if (NULL == fh)
     return GNUNET_SYSERR;
 
   if (dst_len < sizeof(int))
     return GNUNET_SYSERR;
-  *((int *)dst) = fh->fd;
+  *((int *) dst) = fh->fd;
 
   return GNUNET_OK;
 }
@@ -1789,24 +1794,24 @@ GNUNET_DISK_internal_file_handle_(const struct GNUNET_DISK_FileHandle *fh,
  * @return #GNUNET_OK on success
  */
 static int
-purge_cfg_dir(void *cls, const struct GNUNET_CONFIGURATION_Handle *cfg)
+purge_cfg_dir (void *cls, const struct GNUNET_CONFIGURATION_Handle *cfg)
 {
   const char *option = cls;
   char *tmpname;
 
   if (GNUNET_OK !=
-      GNUNET_CONFIGURATION_get_value_filename(cfg, "PATHS", option, &tmpname))
-    {
-      GNUNET_log_config_missing(GNUNET_ERROR_TYPE_ERROR, "PATHS", option);
-      return GNUNET_NO;
-    }
-  if (GNUNET_SYSERR == GNUNET_DISK_directory_remove(tmpname))
-    {
-      GNUNET_log_strerror_file(GNUNET_ERROR_TYPE_ERROR, "remove", tmpname);
-      GNUNET_free(tmpname);
-      return GNUNET_OK;
-    }
-  GNUNET_free(tmpname);
+      GNUNET_CONFIGURATION_get_value_filename (cfg, "PATHS", option, &tmpname))
+  {
+    GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR, "PATHS", option);
+    return GNUNET_NO;
+  }
+  if (GNUNET_SYSERR == GNUNET_DISK_directory_remove (tmpname))
+  {
+    GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_ERROR, "remove", tmpname);
+    GNUNET_free (tmpname);
+    return GNUNET_OK;
+  }
+  GNUNET_free (tmpname);
   return GNUNET_OK;
 }
 
@@ -1819,12 +1824,12 @@ purge_cfg_dir(void *cls, const struct GNUNET_CONFIGURATION_Handle *cfg)
  * @param option option with the dir name to purge
  */
 void
-GNUNET_DISK_purge_cfg_dir(const char *cfg_filename, const char *option)
+GNUNET_DISK_purge_cfg_dir (const char *cfg_filename, const char *option)
 {
-  GNUNET_break(GNUNET_OK ==
-               GNUNET_CONFIGURATION_parse_and_run(cfg_filename,
-                                                  &purge_cfg_dir,
-                                                  (void *)option));
+  GNUNET_break (GNUNET_OK ==
+                GNUNET_CONFIGURATION_parse_and_run (cfg_filename,
+                                                    &purge_cfg_dir,
+                                                    (void *) option));
 }