more complete DISK API

17 files changed, 885 insertions, 290 deletions

diff --git a/src/include/Makefile.am b/src/include/Makefile.am
index bc832c444..0fb7aa0fd 100644
--- a/src/include/Makefile.am
+++ b/src/include/Makefile.am
@@ -24,6 +24,7 @@ gnunetinclude_HEADERS = \
   gnunet_fragmentation_lib.h \
   gnunet_getopt_lib.h \
   gnunet_hello_lib.h \
+  gnunet_io_lib.h \
   gnunet_network_lib.h \
   gnunet_peerinfo_service.h \
   gnunet_program_lib.h \
diff --git a/src/include/gnunet_disk_lib.h b/src/include/gnunet_disk_lib.h
index 3886be7c9..23a4789fa 100644
--- a/src/include/gnunet_disk_lib.h
+++ b/src/include/gnunet_disk_lib.h
@@ -28,6 +28,7 @@
 
 #include "gnunet_configuration_lib.h"
 #include "gnunet_scheduler_lib.h"
+#include "gnunet_io_lib.h"
 
 /* we need size_t, and since it can be both unsigned int
    or unsigned long long, this IS platform dependent;
@@ -43,6 +44,37 @@ extern "C"
 #endif
 #endif
 
+/* Open the file for reading */
+#define GNUNET_DISK_OPEN_READ           1
+/* Open the file for writing */
+#define GNUNET_DISK_OPEN_WRITE          2
+/* Open the file for both reading and writing */
+#define GNUNET_DISK_OPEN_READWRITE      3
+/* Fail if file already exists */
+#define GNUNET_DISK_OPEN_FAILIFEXISTS   4
+/* Truncate file if it exists */
+#define GNUNET_DISK_OPEN_TRUNCATE       8
+/* Create file if it doesn't exist */
+#define GNUNET_DISK_OPEN_CREATE         16
+/* Append to the file */
+#define GNUNET_DISK_OPEN_APPEND         32
+
+#define GNUNET_DISK_MAP_READ    1
+#define GNUNET_DISK_MAP_WRITE   2
+#define GNUNET_DISK_MAP_READWRITE 3
+
+#define GNUNET_DISK_PERM_USER_READ      1
+#define GNUNET_DISK_PERM_USER_WRITE     2
+#define GNUNET_DISK_PERM_USER_EXEC      4
+#define GNUNET_DISK_PERM_GROUP_READ     8
+#define GNUNET_DISK_PERM_GROUP_WRITE    16
+#define GNUNET_DISK_PERM_GROUP_EXEC     32
+#define GNUNET_DISK_PERM_OTHER_READ     64
+#define GNUNET_DISK_PERM_OTHER_WRITE    128
+#define GNUNET_DISK_PERM_OTHER_EXEC     256
+
+enum GNUNET_DISK_Seek {GNUNET_SEEK_SET, GNUNET_SEEK_CUR, GNUNET_SEEK_END};
+
 /**
  * Get the number of blocks that are left on the partition that
  * contains the given file (for normal users).
@@ -64,6 +96,18 @@ int GNUNET_DISK_file_test (const char *fil);
 
 
 /**
+ * Move the read/write pointer in a file
+ * @param h handle of an open file
+ * @param offset position to move to
+ * @param whence specification to which position the offset parameter relates to
+ * @return the new position on success, GNUNET_SYSERR otherwise
+ */
+off_t
+GNUNET_DISK_file_seek (const struct GNUNET_IO_Handle *h, off_t offset,
+    enum GNUNET_DISK_Seek whence);
+
+
+/**
  * Get the size of the file (or directory)
  * of the given file (in bytes).
  *
@@ -77,41 +121,63 @@ int GNUNET_DISK_file_size (const char *filename,
 
 
 /**
- * Wrapper around "open()".  Opens a file.
- *
- * @return file handle, -1 on error
+ * Open a file
+ * @param fn file name to be opened
+ * @param flags opening flags, a combination of GNUNET_DISK_OPEN_xxx bit flags
+ * @param perm permissions for the newly created file
+ * @return IO handle on success, NULL on error
  */
-int GNUNET_DISK_file_open (const char *filename, int oflag, ...);
+struct GNUNET_IO_Handle *GNUNET_DISK_file_open (const char *fn, int flags, ...);
 
 
 /**
- * Wrapper around "close()".  Closes a file.
+ * Close an open file
+ * @param h file handle
+ * @return GNUNET_OK on success, GNUNET_SYSERR otherwise
  */
-void GNUNET_DISK_file_close (const char *filename, int fd);
+int GNUNET_DISK_file_close (struct GNUNET_IO_Handle **h);
 
 
 /**
  * Read the contents of a binary file into a buffer.
- * @param fileName the name of the file, not freed,
- *        must already be expanded!
+ * @param h handle to an open file
+ * @param result the buffer to write the result to
  * @param len the maximum number of bytes to read
+ * @return the number of bytes read on success, GNUNET_SYSERR on failure
+ */
+int GNUNET_DISK_file_read (const struct GNUNET_IO_Handle *h, void *result, int len);
+
+
+/**
+ * Read the contents of a binary file into a buffer.
+ * @param fn file name
  * @param result the buffer to write the result to
- * @return the number of bytes read on success, -1 on failure
+ * @param len the maximum number of bytes to read
+ * @return the number of bytes read on success, GNUNET_SYSERR on failure
  */
-int GNUNET_DISK_file_read (const char *fileName, int len, void *result);
+int GNUNET_DISK_fn_read (const char * const fn, void *result, int len);
 
 
 /**
  * Write a buffer to a file.
- * @param fileName the name of the file, NOT freed!
+ * @param h handle to open file
  * @param buffer the data to write
  * @param n number of bytes to write
- * @param mode the mode for file permissions
- * @return GNUNET_OK on success, GNUNET_SYSERR on error
+ * @return number of bytes written on success, GNUNET_SYSERR on error
  */
-int GNUNET_DISK_file_write (const char *fileName,
-                            const void *buffer, unsigned int n,
-                            const char *mode);
+int GNUNET_DISK_file_write (const struct GNUNET_IO_Handle *h, const void *buffer,
+    unsigned int n);
+
+
+/**
+ * Write a buffer to a file.
+ * @param fn file name
+ * @param buffer the data to write
+ * @param n number of bytes to write
+ * @return number of bytes written on success, GNUNET_SYSERR on error
+ */
+int GNUNET_DISK_fn_write (const char * const fn, const void *buffer,
+    unsigned int n, int mode);
 
 
 /**
@@ -235,6 +301,18 @@ int GNUNET_DISK_directory_create (const char *dir);
 
 
 /**
+ * Lock a part of a file
+ * @param fh file handle
+ * @lockStart absolute position from where to lock
+ * @lockEnd absolute position until where to lock
+ * @return GNUNET_OK on success, GNUNET_SYSERR on error
+ */
+int
+GNUNET_DISK_file_lock(struct GNUNET_IO_Handle *fh, off_t lockStart,
+    off_t lockEnd);
+
+
+/**
  * @brief Removes special characters as ':' from a filename.
  * @param fn the filename to canonicalize
  */
@@ -266,6 +344,33 @@ int GNUNET_DISK_file_change_owner (const char *filename, const char *user);
 char *GNUNET_DISK_get_home_filename (struct GNUNET_CONFIGURATION_Handle *cfg,
                                      const char *serviceName, ...);
 
+/**
+ * Map a file into memory
+ * @param h open file handle
+ * @param m handle to the new mapping
+ * @param access access specification, GNUNET_DISK_MAP_xxx
+ * @param len size of the mapping
+ * @return pointer to the mapped memory region, NULL on failure
+ */
+void *GNUNET_DISK_file_map (const struct GNUNET_IO_Handle *h, struct GNUNET_IO_Handle **m,
+    int access, size_t len);
+
+/**
+ * Unmap a file
+ * @param h mapping handle
+ * @param addr pointer to the mapped memory region
+ * @param len size of the mapping
+ * @return GNUNET_OK on success, GNUNET_SYSERR otherwise
+ */
+int GNUNET_DISK_file_unmap (struct GNUNET_IO_Handle **h, void *addr, size_t len);
+
+/**
+ * Write file changes to disk
+ * @param h handle to an open file
+ * @return GNUNET_OK on success, GNUNET_SYSERR otherwise
+ */
+int GNUNET_DISK_file_sync (const struct GNUNET_IO_Handle *h);
+
 #if 0                           /* keep Emacsens' auto-indent happy */
 {
 #endif
diff --git a/src/include/gnunet_io_lib.h b/src/include/gnunet_io_lib.h
new file mode 100644
index 000000000..3d04a2317
--- /dev/null
+++ b/src/include/gnunet_io_lib.h
@@ -0,0 +1,46 @@
+/*
+     This file is part of GNUnet.
+     (C) 2009 Christian Grothoff (and other contributing authors)
+
+     GNUnet is free software; you can redistribute it and/or modify
+     it under the terms of the GNU General Public License as published
+     by the Free Software Foundation; either version 2, or (at your
+     option) any later version.
+
+     GNUnet is distributed in the hope that it will be useful, but
+     WITHOUT ANY WARRANTY; without even the implied warranty of
+     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+     General Public License for more details.
+
+     You should have received a copy of the GNU General Public License
+     along with GNUnet; see the file COPYING.  If not, write to the
+     Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+     Boston, MA 02111-1307, USA.
+*/
+
+/**
+ * @file include/gnunet_io_lib.h
+ * @brief Helper functions for abstract IO handles
+ * @author Nils Durner
+ */
+
+#ifndef IO_HANDLE_H_
+#define IO_HANDLE_H_
+
+struct GNUNET_IO_Handle;
+
+/**
+ * Checks whether a handle is invalid
+ * @param h handle to check
+ * @return GNUNET_YES if invalid, GNUNET_NO if valid
+ */
+int GNUNET_IO_handle_invalid (const struct GNUNET_IO_Handle *h);
+
+/**
+ * Mark a handle as invalid
+ * @param h file handle
+ */
+void GNUNET_IO_handle_invalidate (struct GNUNET_IO_Handle *h);
+
+
+#endif /* IO_HANDLE_H_ */
diff --git a/src/include/gnunet_util_lib.h b/src/include/gnunet_util_lib.h
index 6354e28fa..58621caf5 100644
--- a/src/include/gnunet_util_lib.h
+++ b/src/include/gnunet_util_lib.h
@@ -43,6 +43,7 @@ extern "C"
 #include "gnunet_crypto_lib.h"
 #include "gnunet_disk_lib.h"
 #include "gnunet_getopt_lib.h"
+#include "gnunet_io_lib.h"
 #include "gnunet_network_lib.h"
 #include "gnunet_plugin_lib.h"
 #include "gnunet_program_lib.h"
diff --git a/src/peerinfo/gnunet-service-peerinfo.c b/src/peerinfo/gnunet-service-peerinfo.c
index 0d383c0f1..eb2dc4264 100644
--- a/src/peerinfo/gnunet-service-peerinfo.c
+++ b/src/peerinfo/gnunet-service-peerinfo.c
@@ -197,14 +197,14 @@ add_host_to_known_hosts (const struct GNUNET_PeerIdentity *identity)
   entry->identity = *identity;
   fn = get_trust_filename (identity);
   if ((GNUNET_DISK_file_test (fn) == GNUNET_YES) &&
-      (sizeof (trust) == GNUNET_DISK_file_read (fn, sizeof (trust), &trust)))
+      (sizeof (trust) == GNUNET_DISK_fn_read (fn, &trust, sizeof (trust))))
     entry->disk_trust = entry->trust = ntohl (trust);
   GNUNET_free (fn);
 
   fn = get_host_filename (identity);
   if (GNUNET_DISK_file_test (fn) == GNUNET_YES)
     {
-      size = GNUNET_DISK_file_read (fn, sizeof (buffer), buffer);
+      size = GNUNET_DISK_fn_read (fn, buffer, sizeof (buffer));
       hello = (const struct GNUNET_HELLO_Message *) buffer;
       now = GNUNET_TIME_absolute_get ();
       hello_clean = GNUNET_HELLO_iterate_addresses (hello,
@@ -371,7 +371,9 @@ bind_address (const struct GNUNET_PeerIdentity *peer,
       host->hello = mrg;
     }
   fn = get_host_filename (peer);
-  GNUNET_DISK_file_write (fn, host->hello, GNUNET_HELLO_size (hello), "644");
+  GNUNET_DISK_fn_write (fn, host->hello, GNUNET_HELLO_size (hello),
+      GNUNET_DISK_PERM_USER_READ | GNUNET_DISK_PERM_USER_WRITE
+          | GNUNET_DISK_PERM_GROUP_READ | GNUNET_DISK_PERM_OTHER_READ);
   GNUNET_free (fn);
 }
 
@@ -455,8 +457,9 @@ flush_trust (struct HostEntry *host)
   else
     {
       trust = htonl (host->trust);
-      if (GNUNET_OK ==
-          GNUNET_DISK_file_write (fn, &trust, sizeof (uint32_t), "644"))
+      if (GNUNET_OK == GNUNET_DISK_fn_write (fn, &trust, sizeof(uint32_t),
+          GNUNET_DISK_PERM_USER_READ | GNUNET_DISK_PERM_USER_WRITE
+              | GNUNET_DISK_PERM_GROUP_READ | GNUNET_DISK_PERM_OTHER_READ))
         host->disk_trust = host->trust;
     }
   GNUNET_free (fn);
@@ -497,7 +500,7 @@ discard_hosts_helper (void *cls, const char *fn)
   struct GNUNET_HELLO_Message *new_hello;
   int size;
 
-  size = GNUNET_DISK_file_read (fn, sizeof (buffer), buffer);
+  size = GNUNET_DISK_fn_read (fn, buffer, sizeof (buffer));
   if ((size < sizeof (struct GNUNET_MessageHeader)) && (0 != UNLINK (fn)))
     {
       GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING |
@@ -513,9 +516,9 @@ discard_hosts_helper (void *cls, const char *fn)
                               GNUNET_ERROR_TYPE_BULK, "unlink", fn);
   if (new_hello != NULL)
     {
-      GNUNET_DISK_file_write (fn,
-                              new_hello,
-                              GNUNET_HELLO_size (new_hello), "644");
+      GNUNET_DISK_fn_write (fn, new_hello, GNUNET_HELLO_size (new_hello),
+          GNUNET_DISK_PERM_USER_READ | GNUNET_DISK_PERM_USER_WRITE
+              | GNUNET_DISK_PERM_GROUP_READ | GNUNET_DISK_PERM_OTHER_READ);
       GNUNET_free (new_hello);
     }
   return GNUNET_OK;
diff --git a/src/statistics/gnunet-service-statistics.c b/src/statistics/gnunet-service-statistics.c
index 42ff8d927..c7388ebd9 100644
--- a/src/statistics/gnunet-service-statistics.c
+++ b/src/statistics/gnunet-service-statistics.c
@@ -99,7 +99,7 @@ load (struct GNUNET_SERVER_Handle *server,
       struct GNUNET_CONFIGURATION_Handle *cfg)
 {
   char *fn;
-  int fd;
+  struct GNUNET_IO_Handle *fh, *mh;
   struct stat sb;
   char *buf;
   size_t off;
@@ -114,17 +114,17 @@ load (struct GNUNET_SERVER_Handle *server,
       GNUNET_free (fn);
       return;
     }
-  fd = GNUNET_DISK_file_open (fn, O_RDONLY);
-  if (fd == -1)
+  fh = GNUNET_DISK_file_open (fn, GNUNET_DISK_OPEN_READ);
+  if (!fh)
     {
       GNUNET_free (fn);
       return;
     }
-  buf = MMAP (NULL, sb.st_size, PROT_READ, MAP_SHARED, fd, 0);
-  if (MAP_FAILED == buf)
+  buf = GNUNET_DISK_file_map (fh, &mh, GNUNET_DISK_MAP_READ, sb.st_size);
+  if (NULL == buf)
     {
       GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING, "mmap", fn);
-      GNUNET_break (0 == CLOSE (fd));
+      GNUNET_break (GNUNET_OK == GNUNET_DISK_file_close (&fh));
       GNUNET_free (fn);
       return;
     }
@@ -143,8 +143,8 @@ load (struct GNUNET_SERVER_Handle *server,
         }
       off += ntohs (msg->size);
     }
-  GNUNET_break (0 == MUNMAP (buf, sb.st_size));
-  GNUNET_break (0 == CLOSE (fd));
+  GNUNET_break (GNUNET_OK == GNUNET_DISK_file_unmap (&mh, buf, sb.st_size));
+  GNUNET_break (GNUNET_OK == GNUNET_DISK_file_close (&fh));
   GNUNET_free (fn);
 }
 
@@ -160,39 +160,37 @@ save (void *cls, struct GNUNET_CONFIGURATION_Handle *cfg)
 {
   struct StatsEntry *pos;
   char *fn;
-  int fd;
+  struct GNUNET_IO_Handle *fh;
   uint16_t size;
   unsigned long long total;
 
-  fd = -1;
   fn = GNUNET_DISK_get_home_filename (cfg,
                                       "statistics", "statistics.data", NULL);
   if (fn != NULL)
-    fd =
-      GNUNET_DISK_file_open (fn, O_WRONLY | O_CREAT | O_TRUNC,
-                             S_IRUSR | S_IWUSR);
+    fh = GNUNET_DISK_file_open (fn, GNUNET_DISK_OPEN_WRITE
+        | GNUNET_DISK_OPEN_CREATE | GNUNET_DISK_OPEN_TRUNCATE,
+        GNUNET_DISK_PERM_USER_READ | GNUNET_DISK_PERM_USER_WRITE);
   total = 0;
   while (NULL != (pos = start))
     {
       start = pos->next;
-      if ((pos->persistent) && (fd != -1))
+      if ((pos->persistent) && fh)
         {
           size = htons (pos->msg->header.size);
-          if (size != WRITE (fd, pos->msg, size))
+          if (size != GNUNET_DISK_file_write (fh, pos->msg, size))
             {
               GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING,
                                         "write", fn);
-              GNUNET_DISK_file_close (fn, fd);
-              fd = -1;
+              GNUNET_DISK_file_close (&fh);
             }
           else
             total += size;
         }
       GNUNET_free (pos);
     }
-  if (fd != -1)
+  if (fh)
     {
-      GNUNET_DISK_file_close (fn, fd);
+      GNUNET_DISK_file_close (&fh);
       if (total == 0)
         GNUNET_break (0 == UNLINK (fn));
       else
diff --git a/src/topology/gnunet-daemon-topology.c b/src/topology/gnunet-daemon-topology.c
index 0ef896714..f4884e00d 100644
--- a/src/topology/gnunet-daemon-topology.c
+++ b/src/topology/gnunet-daemon-topology.c
@@ -38,26 +38,26 @@
 /**
  * For how long do we blacklist a peer after a failed
  * connection attempt?
- */ 
+ */
 #define BLACKLIST_AFTER_ATTEMPT GNUNET_TIME_UNIT_HOURS
 
 /**
  * For how long do we blacklist a friend after a failed
  * connection attempt?
- */ 
+ */
 #define BLACKLIST_AFTER_ATTEMPT_FRIEND GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MINUTES, 15)
 
 /**
  * How frequently are we allowed to ask PEERINFO for more
  * HELLO's to advertise (at most)?
- */ 
+ */
 #define MIN_HELLO_GATHER_DELAY GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MINUTES, 27)
 
 /**
  * How often do we at most advertise the same HELLO to the same peer?
  * Also used to remove HELLOs of peers that PEERINFO no longer lists
  * from our cache.
- */ 
+ */
 #define HELLO_ADVERTISEMENT_MIN_FREQUENCY GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_HOURS, 12)
 
 
@@ -97,7 +97,7 @@ struct PeerList
    * ID of the peer.
    */
   struct GNUNET_PeerIdentity id;
-  
+
 };
 
 
@@ -122,12 +122,12 @@ struct HelloList
    * this HELLO.
    */
   struct GNUNET_CONTAINER_BloomFilter *filter;
-  
+
   /**
    * What peer is this HELLO for?
    */
   struct GNUNET_PeerIdentity id;
- 
+
   /**
    * When should we remove this entry from the linked list (either
    * resetting the filter or possibly eliminating it for good because
@@ -152,12 +152,12 @@ static struct GNUNET_SCHEDULER_Handle * sched;
  * Our configuration.
  */
 static struct GNUNET_CONFIGURATION_Handle * cfg;
-   
+
 /**
  * Handle to the core API.
  */
 static struct GNUNET_CORE_Handle *handle;
-   
+
 /**
  * Handle to the transport API.
  */
@@ -167,7 +167,7 @@ static struct GNUNET_TRANSPORT_Handle *transport;
  * Identity of this peer.
  */
 static struct GNUNET_PeerIdentity my_identity;
-         
+
 /**
  * Linked list of all of our friends and all of our current
  * neighbours.
@@ -194,17 +194,17 @@ static unsigned int minimum_friend_count;
  * Number of peers (friends and others) that we are currently connected to.
  */
 static unsigned int connection_count;
- 
+
 /**
  * Target number of connections.
  */
 static unsigned int target_connection_count;
- 
+
 /**
  * Number of friends that we are currently connected to.
  */
 static unsigned int friend_count;
- 
+
 /**
  * Should the topology daemon try to establish connections?
  */
@@ -239,7 +239,7 @@ force_disconnect (const struct GNUNET_PeerIdentity *peer)
  * Function called by core when our attempt to connect
  * succeeded.  Does nothing.
  */
-static size_t 
+static size_t
 ready_callback (void *cls,
                 size_t size, void *buf)
 {
@@ -346,7 +346,7 @@ static void connect_notify (void *cls,
           GNUNET_assert (GNUNET_NO == pos->is_connected);
           pos->is_connected = GNUNET_YES;
           pos->blacklisted_until.value = 0; /* remove blacklisting */
-          friend_count++;         
+          friend_count++;
           return;
         }
       pos = pos->next;
@@ -364,8 +364,8 @@ static void connect_notify (void *cls,
 /**
  * Disconnect from all non-friends (we're below quota).
  */
-static void 
-drop_non_friends () 
+static void
+drop_non_friends ()
 {
   struct PeerList *pos;
 
@@ -427,7 +427,7 @@ static void disconnect_notify (void *cls,
         }
       prev = pos;
       pos = pos->next;
-    } 
+    }
   GNUNET_break (0);
 }
 
@@ -444,12 +444,12 @@ find_more_peers (void *cls,
 /**
  * Determine when we should try again to find more peers and
  * schedule the task.
- */ 
+ */
 static void
 schedule_peer_search ()
 {
   struct GNUNET_TIME_Relative delay;
-  
+
   /* Typically, we try again every 15 minutes; the minimum period is
      15s; if we are above the connection target, we reduce re-trying
      by the square of how much we are above; so for example, with 200%
@@ -473,8 +473,8 @@ schedule_peer_search ()
 
 
 /**
- * Iterator called on each address. 
- * 
+ * Iterator called on each address.
+ *
  * @param cls flag that we will set if we see any addresses.
  */
 static int
@@ -526,18 +526,18 @@ consider_for_advertising (const struct GNUNET_HELLO_Message *hello)
   memcpy (&pos->msg, hello, size);
   pos->id = pid;
   pos->expiration = GNUNET_TIME_relative_to_absolute (HELLO_ADVERTISEMENT_MIN_FREQUENCY);
-  /* 2^{-5} chance of not sending a HELLO to a peer is 
-     acceptably small (if the filter is 50% full); 
+  /* 2^{-5} chance of not sending a HELLO to a peer is
+     acceptably small (if the filter is 50% full);
      64 bytes of memory are small compared to the rest
      of the data structure and would only really become
      "useless" once a HELLO has been passed on to ~100
-     other peers, which is likely more than enough in 
+     other peers, which is likely more than enough in
      any case; hence 64, 5 as bloomfilter parameters. */
   pos->filter = GNUNET_CONTAINER_bloomfilter_load (NULL, 64, 5);
   /* never send a peer its own HELLO */
   GNUNET_CONTAINER_bloomfilter_add (pos->filter, &pos->id.hashPubKey);
   pos->next = hellos;
-  hellos = pos;  
+  hellos = pos;
 }
 
 
@@ -585,7 +585,7 @@ process_peer (void *cls,
             }
         }
       pos = pos->next;
-    }  
+    }
   if (GNUNET_YES == friends_only)
     return;
   if (friend_count < minimum_friend_count)
@@ -700,7 +700,7 @@ core_init (void *cls,
     {
       GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                   _("Failed to connect to core service, can not manage topology!\n"));
-      return; 
+      return;
     }
   handle = server;
   my_identity = *my_id;
@@ -744,7 +744,7 @@ read_friends_file (struct GNUNET_CONFIGURATION_Handle *cfg)
                                            "FRIENDS",
                                            &fn);
   if (GNUNET_OK != GNUNET_DISK_file_test (fn))
-    GNUNET_DISK_file_write (fn, NULL, 0, "600");
+    GNUNET_DISK_fn_write (fn, NULL, 0, "600");
   if (0 != STAT (fn, &frstat))
     {
       if ((friends_only) || (minimum_friend_count > 0))
@@ -761,11 +761,11 @@ read_friends_file (struct GNUNET_CONFIGURATION_Handle *cfg)
                   _("Friends file `%s' is empty.\n"),
                   fn);
       GNUNET_free (fn);
-      return; 
+      return;
     }
   data = GNUNET_malloc_large (frstat.st_size);
   if (frstat.st_size !=
-      GNUNET_DISK_file_read (fn, frstat.st_size, data))
+      GNUNET_DISK_fn_read (fn, data, frstat.st_size))
     {
       GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                   _("Failed to read friends list from `%s'\n"), fn);
@@ -914,10 +914,10 @@ hello_advertising (void *cls,
   while (NULL != (pos = next))
     {
       next = pos->next;
-      if (GNUNET_NO == 
+      if (GNUNET_NO ==
           GNUNET_CONTAINER_bloomfilter_test (pos->filter,
                                              &receiver->hashPubKey))
-        break;  
+        break;
       if (0 == GNUNET_TIME_absolute_get_remaining (pos->expiration).value)
         {
           /* time to discard... */
@@ -947,11 +947,11 @@ hello_advertising (void *cls,
           size = 0;
         }
       return size;
-    }  
+    }
   if ( (GNUNET_NO == hello_gathering_active) &&
        (GNUNET_TIME_absolute_get_duration (last_hello_gather_time).value >
         MIN_HELLO_GATHER_DELAY.value) )
-    {     
+    {
       hello_gathering_active = GNUNET_YES;
       last_hello_gather_time = GNUNET_TIME_absolute_get();
       GNUNET_PEERINFO_for_all (cfg,
@@ -994,14 +994,14 @@ cleaning_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
  * @param cfgfile name of the configuration file used (for saving, can be NULL!)
  * @param c configuration
  */
-static void 
+static void
 run (void *cls,
      struct GNUNET_SCHEDULER_Handle * s,
      char *const *args,
      const char *cfgfile,
      struct GNUNET_CONFIGURATION_Handle * c)
 {
-  struct GNUNET_CORE_MessageHandler handlers[] = 
+  struct GNUNET_CORE_MessageHandler handlers[] =
     {
       { &handle_encrypted_hello, GNUNET_MESSAGE_TYPE_HELLO, 0},
       { NULL, 0, 0 }
@@ -1012,7 +1012,7 @@ run (void *cls,
   cfg = c;
   autoconnect = GNUNET_CONFIGURATION_get_value_yesno (cfg,
                                                       "TOPOLOGY",
-                                                      "AUTOCONNECT"); 
+                                                      "AUTOCONNECT");
   friends_only = GNUNET_CONFIGURATION_get_value_yesno (cfg,
                                                        "TOPOLOGY",
                                                        "FRIENDS-ONLY");
@@ -1050,7 +1050,7 @@ run (void *cls,
                        NULL, GNUNET_NO,
                        NULL, GNUNET_NO,
                        handlers);
-  
+
   GNUNET_SCHEDULER_add_delayed (sched,
                                 GNUNET_YES,
                                 GNUNET_SCHEDULER_PRIORITY_IDLE,
@@ -1075,7 +1075,7 @@ main (int argc, char *const *argv)
   ret = (GNUNET_OK ==
          GNUNET_PROGRAM_run (argc,
                              argv,
-                             "topology", 
+                             "topology",
                              _("GNUnet topology control (maintaining P2P mesh and F2F constraints)"),
                              options,
                              &run, NULL)) ? 0 : 1;
diff --git a/src/util/Makefile.am b/src/util/Makefile.am
index 64178e538..014521f90 100644
--- a/src/util/Makefile.am
+++ b/src/util/Makefile.am
@@ -33,6 +33,8 @@ libgnunetutil_la_SOURCES = \
   disk.c \
   getopt.c \
   getopt_helpers.c \
+  io_handle.c \
+  io_handle.h \
   network.c \
   os_installation.c \
   os_load.c \
diff --git a/src/util/container_bloomfilter.c b/src/util/container_bloomfilter.c
index 8b76ef8dc..37780cb2a 100644
--- a/src/util/container_bloomfilter.c
+++ b/src/util/container_bloomfilter.c
@@ -60,7 +60,7 @@ struct GNUNET_CONTAINER_BloomFilter
   /**
    * The bit counter file on disk
    */
-  int fd;
+  struct GNUNET_IO_Handle *fh;
 
   /**
    * How many bits we set for each stored element
@@ -139,10 +139,10 @@ testBit (char *bitArray, unsigned int bitIdx)
  *
  * @param bitArray memory area to set the bit in
  * @param bitIdx which bit to test
- * @param fd A file to keep the 4 bit address usage counters in
+ * @param fh A file to keep the 4 bit address usage counters in
  */
 static void
-incrementBit (char *bitArray, unsigned int bitIdx, int fd)
+incrementBit (char *bitArray, unsigned int bitIdx, const struct GNUNET_IO_Handle *fh)
 {
   unsigned int fileSlot;
   unsigned char value;
@@ -151,14 +151,14 @@ incrementBit (char *bitArray, unsigned int bitIdx, int fd)
   unsigned int targetLoc;
 
   setBit (bitArray, bitIdx);
-  if (fd == -1)
+  if (GNUNET_IO_handle_invalid (fh))
     return;
   /* Update the counter file on disk */
   fileSlot = bitIdx / 2;
   targetLoc = bitIdx % 2;
 
-  GNUNET_assert (fileSlot == (unsigned int) LSEEK (fd, fileSlot, SEEK_SET));
-  if (1 != READ (fd, &value, 1))
+  GNUNET_assert (fileSlot == (unsigned int) GNUNET_DISK_file_seek (fh, fileSlot, GNUNET_SEEK_SET));
+  if (1 != GNUNET_DISK_file_read (fh, &value, 1))
     value = 0;
   low = value & 0xF;
   high = (value & (~0xF)) >> 4;
@@ -174,8 +174,8 @@ incrementBit (char *bitArray, unsigned int bitIdx, int fd)
         high++;
     }
   value = ((high << 4) | low);
-  GNUNET_assert (fileSlot == (unsigned int) LSEEK (fd, fileSlot, SEEK_SET));
-  GNUNET_assert (1 == WRITE (fd, &value, 1));
+  GNUNET_assert (fileSlot == (unsigned int) GNUNET_DISK_file_seek (fh, fileSlot, GNUNET_SEEK_SET));
+  GNUNET_assert (1 == GNUNET_DISK_file_write (fh, &value, 1));
 }
 
 /**
@@ -184,10 +184,10 @@ incrementBit (char *bitArray, unsigned int bitIdx, int fd)
  *
  * @param bitArray memory area to set the bit in
  * @param bitIdx which bit to test
- * @param fd A file to keep the 4bit address usage counters in
+ * @param fh A file to keep the 4bit address usage counters in
  */
 static void
-decrementBit (char *bitArray, unsigned int bitIdx, int fd)
+decrementBit (char *bitArray, unsigned int bitIdx, const struct GNUNET_IO_Handle *fh)
 {
   unsigned int fileSlot;
   unsigned char value;
@@ -195,13 +195,13 @@ decrementBit (char *bitArray, unsigned int bitIdx, int fd)
   unsigned int low;
   unsigned int targetLoc;
 
-  if (fd == -1)
+  if (GNUNET_IO_handle_invalid (fh))
     return;                     /* cannot decrement! */
   /* Each char slot in the counter file holds two 4 bit counters */
   fileSlot = bitIdx / 2;
   targetLoc = bitIdx % 2;
-  LSEEK (fd, fileSlot, SEEK_SET);
-  if (1 != READ (fd, &value, 1))
+  GNUNET_DISK_file_seek (fh, fileSlot, GNUNET_SEEK_SET);
+  if (1 != GNUNET_DISK_file_read (fh, &value, 1))
     value = 0;
   low = value & 0xF;
   high = (value & 0xF0) >> 4;
@@ -226,8 +226,8 @@ decrementBit (char *bitArray, unsigned int bitIdx, int fd)
         }
     }
   value = ((high << 4) | low);
-  LSEEK (fd, fileSlot, SEEK_SET);
-  GNUNET_assert (1 == WRITE (fd, &value, 1));
+  GNUNET_DISK_file_seek (fh, fileSlot, GNUNET_SEEK_SET);
+  GNUNET_assert (1 == GNUNET_DISK_file_write (fh, &value, 1));
 }
 
 #define BUFFSIZE 65536
@@ -235,36 +235,36 @@ decrementBit (char *bitArray, unsigned int bitIdx, int fd)
 /**
  * Creates a file filled with zeroes
  *
- * @param fd the file handle
+ * @param fh the file handle
  * @param size the size of the file
  * @return GNUNET_OK if created ok, GNUNET_SYSERR otherwise
  */
 static int
-makeEmptyFile (int fd, unsigned int size)
+makeEmptyFile (const struct GNUNET_IO_Handle *fh, unsigned int size)
 {
   char *buffer;
   unsigned int bytesleft = size;
   int res = 0;
 
-  if (fd == -1)
+  if (GNUNET_IO_handle_invalid (fh))
     return GNUNET_SYSERR;
   buffer = GNUNET_malloc (BUFFSIZE);
   memset (buffer, 0, BUFFSIZE);
-  LSEEK (fd, 0, SEEK_SET);
+  GNUNET_DISK_file_seek (fh, 0, GNUNET_SEEK_SET);
 
   while (bytesleft > 0)
     {
       if (bytesleft > BUFFSIZE)
         {
-          res = WRITE (fd, buffer, BUFFSIZE);
+          res = GNUNET_DISK_file_write (fh, buffer, BUFFSIZE);
           bytesleft -= BUFFSIZE;
         }
       else
         {
-          res = WRITE (fd, buffer, bytesleft);
+          res = GNUNET_DISK_file_write (fh, buffer, bytesleft);
           bytesleft = 0;
         }
-      GNUNET_assert (res != -1);
+      GNUNET_assert (res != GNUNET_SYSERR);
     }
   GNUNET_free (buffer);
   return GNUNET_OK;
@@ -338,7 +338,7 @@ static void
 incrementBitCallback (struct GNUNET_CONTAINER_BloomFilter *bf,
                       unsigned int bit, void *arg)
 {
-  incrementBit (bf->bitArray, bit, bf->fd);
+  incrementBit (bf->bitArray, bit, bf->fh);
 }
 
 /**
@@ -352,7 +352,7 @@ static void
 decrementBitCallback (struct GNUNET_CONTAINER_BloomFilter *bf,
                       unsigned int bit, void *arg)
 {
-  decrementBit (bf->bitArray, bit, bf->fd);
+  decrementBit (bf->bitArray, bit, bf->fh);
 }
 
 /**
@@ -406,14 +406,10 @@ GNUNET_CONTAINER_bloomfilter_load (const char *filename, unsigned int size,
   /* Try to open a bloomfilter file */
   if (filename != NULL)
     {
-#ifndef _MSC_VER
-      bf->fd = GNUNET_DISK_file_open (filename, O_RDWR | O_CREAT,
-                                      S_IRUSR | S_IWUSR);
-#else
-      bf->fd = GNUNET_DISK_file_open (filename,
-                                      O_WRONLY | O_CREAT, S_IREAD | S_IWRITE);
-#endif
-      if (-1 == bf->fd)
+      bf->fh = GNUNET_DISK_file_open (filename,
+          GNUNET_DISK_OPEN_WRITE | GNUNET_DISK_OPEN_CREATE,
+          GNUNET_DISK_PERM_USER_READ | GNUNET_DISK_PERM_USER_WRITE);
+      if (!bf->fh)
         {
           GNUNET_free (bf);
           return NULL;
@@ -422,8 +418,8 @@ GNUNET_CONTAINER_bloomfilter_load (const char *filename, unsigned int size,
     }
   else
     {
-      bf->fd = -1;
       bf->filename = NULL;
+      bf->fh = NULL;
     }
   /* Alloc block */
   bf->bitArray = GNUNET_malloc_large (size);
@@ -431,7 +427,7 @@ GNUNET_CONTAINER_bloomfilter_load (const char *filename, unsigned int size,
   bf->addressesPerElement = k;
   memset (bf->bitArray, 0, bf->bitArraySize);
 
-  if (bf->fd != -1)
+  if (bf->filename != NULL)
     {
       /* Read from the file what bits we can */
       rbuff = GNUNET_malloc (BUFFSIZE);
@@ -440,7 +436,7 @@ GNUNET_CONTAINER_bloomfilter_load (const char *filename, unsigned int size,
         {
           int res;
 
-          res = READ (bf->fd, rbuff, BUFFSIZE);
+          res = GNUNET_DISK_file_read (bf->fh, rbuff, BUFFSIZE);
           if (res == 0)
             break;              /* is ok! we just did not use that many bits yet */
           for (i = 0; i < res; i++)
@@ -491,8 +487,8 @@ GNUNET_CONTAINER_bloomfilter_init (const char *data, unsigned int size,
       return NULL;
     }
   bf = GNUNET_malloc (sizeof (struct GNUNET_CONTAINER_BloomFilter));
-  bf->fd = -1;
   bf->filename = NULL;
+  bf->fh = NULL;
   bf->bitArray = GNUNET_malloc_large (size);
   bf->bitArraySize = size;
   bf->addressesPerElement = k;
@@ -537,9 +533,11 @@ GNUNET_CONTAINER_bloomfilter_free (struct GNUNET_CONTAINER_BloomFilter *bf)
 {
   if (NULL == bf)
     return;
-  if (bf->fd != -1)
-    GNUNET_DISK_file_close (bf->filename, bf->fd);
-  GNUNET_free_non_null (bf->filename);
+  if (bf->filename != NULL)
+    {
+      GNUNET_DISK_file_close (&bf->fh);
+      GNUNET_free (bf->filename);
+    }
   GNUNET_free (bf->bitArray);
   GNUNET_free (bf);
 }
@@ -556,8 +554,8 @@ GNUNET_CONTAINER_bloomfilter_clear (struct GNUNET_CONTAINER_BloomFilter *bf)
     return;
 
   memset (bf->bitArray, 0, bf->bitArraySize);
-  if (bf->fd != -1)
-    makeEmptyFile (bf->fd, bf->bitArraySize * 4);
+  if (bf->filename != NULL)
+    makeEmptyFile (bf->fh, bf->bitArraySize * 4);
 }
 
 
@@ -634,7 +632,7 @@ GNUNET_CONTAINER_bloomfilter_remove (struct GNUNET_CONTAINER_BloomFilter *bf,
 {
   if (NULL == bf)
     return;
-  if (bf->fd == -1)
+  if (bf->filename == NULL)
     return;
   iterateBits (bf, &decrementBitCallback, NULL, e);
 }
@@ -668,8 +666,8 @@ GNUNET_CONTAINER_bloomfilter_resize (struct GNUNET_CONTAINER_BloomFilter *bf,
   bf->bitArraySize = size;
   bf->bitArray = GNUNET_malloc (size);
   memset (bf->bitArray, 0, bf->bitArraySize);
-  if (bf->fd != -1)
-    makeEmptyFile (bf->fd, bf->bitArraySize * 4);
+  if (bf->filename != NULL)
+    makeEmptyFile (bf->fh, bf->bitArraySize * 4);
   while (GNUNET_YES == iterator (&hc, iterator_arg))
     GNUNET_CONTAINER_bloomfilter_add (bf, &hc);
 }
diff --git a/src/util/crypto_hash.c b/src/util/crypto_hash.c
index 139496eac..5a7cb33d7 100644
--- a/src/util/crypto_hash.c
+++ b/src/util/crypto_hash.c
@@ -429,7 +429,7 @@ struct FileHashContext
   /**
    * File descriptor.
    */
-  int fd;
+  struct GNUNET_IO_Handle *fh;
 
 };
 
@@ -443,8 +443,8 @@ file_hash_finish (struct FileHashContext *fhc, const GNUNET_HashCode * res)
 {
   fhc->callback (fhc->callback_cls, res);
   GNUNET_free (fhc->filename);
-  if (fhc->fd != -1)
-    GNUNET_break (0 == CLOSE (fhc->fd));
+  if (!GNUNET_IO_handle_invalid (fhc->fh))
+    GNUNET_break (0 == GNUNET_DISK_file_close (&fhc->fh));
   GNUNET_free (fhc);            /* also frees fhc->buffer */
 }
 
@@ -466,7 +466,7 @@ file_hash_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
   delta = fhc->bsize;
   if (fhc->fsize - fhc->offset < delta)
     delta = fhc->fsize - fhc->offset;
-  if (delta != READ (fhc->fd, fhc->buffer, delta))
+  if (delta != GNUNET_DISK_file_read (fhc->fh, fhc->buffer, delta))
     {
       GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING,
                                 "read", fhc->filename);
@@ -517,7 +517,7 @@ GNUNET_CRYPTO_hash_file (struct GNUNET_SCHEDULER_Handle *sched,
   fhc->callback_cls = callback_cls;
   fhc->buffer = (unsigned char *) &fhc[1];
   fhc->filename = GNUNET_strdup (filename);
-  fhc->fd = -1;
+  fhc->fh = NULL;
   sha512_init (&fhc->hctx);
   fhc->bsize = blocksize;
   if (GNUNET_OK != GNUNET_DISK_file_size (filename, &fhc->fsize, GNUNET_NO))
@@ -526,8 +526,9 @@ GNUNET_CRYPTO_hash_file (struct GNUNET_SCHEDULER_Handle *sched,
       return;
     }
   fhc->run_on_shutdown = run_on_shutdown;
-  fhc->fd = GNUNET_DISK_file_open (filename, O_RDONLY | O_LARGEFILE);
-  if (fhc->fd == -1)
+  fhc->fh = GNUNET_DISK_file_open (filename,
+      GNUNET_DISK_OPEN_READ);
+  if (!fhc->fh)
     {
       file_hash_finish (fhc, NULL);
       return;
diff --git a/src/util/disk.c b/src/util/disk.c
index 5042f0867..b0d3b18a4 100644
--- a/src/util/disk.c
+++ b/src/util/disk.c
@@ -1,6 +1,6 @@
 /*
      This file is part of GNUnet.
-     (C) 2001, 2002, 2005, 2006 Christian Grothoff (and other contributing authors)
+     (C) 2001, 2002, 2005, 2006, 2009 Christian Grothoff (and other contributing authors)
 
      GNUnet is free software; you can redistribute it and/or modify
      it under the terms of the GNU General Public License as published
@@ -22,11 +22,14 @@
  * @file util/disk.c
  * @brief disk IO convenience methods
  * @author Christian Grothoff
+ * @author Nils Durner
  */
 
 #include "platform.h"
+#include "io_handle.h"
 #include "gnunet_common.h"
 #include "gnunet_directories.h"
+#include "gnunet_io_lib.h"
 #include "gnunet_disk_lib.h"
 #include "gnunet_scheduler_lib.h"
 #include "gnunet_strings_lib.h"
@@ -108,6 +111,44 @@ getSizeRec (void *ptr, const char *fn)
   return GNUNET_OK;
 }
 
+
+/**
+ * Move the read/write pointer in a file
+ * @param h handle of an open file
+ * @param offset position to move to
+ * @param whence specification to which position the offset parameter relates to
+ * @return the new position on success, GNUNET_SYSERR otherwise
+ */
+off_t
+GNUNET_DISK_file_seek (const struct GNUNET_IO_Handle *h, off_t offset,
+    enum GNUNET_DISK_Seek whence)
+{
+  if (h == NULL)
+    {
+      errno = EINVAL;
+      return GNUNET_SYSERR;
+    }
+
+#ifdef MINGW
+  DWORD ret;
+  static DWORD t[] = { [GNUNET_SEEK_SET] = FILE_BEGIN,
+      [GNUNET_SEEK_CUR] = FILE_CURRENT, [GNUNET_SEEK_END] = FILE_END };
+
+  ret = SetFilePointer (h->h, offset, NULL, t[whence]);
+  if (ret == INVALID_SET_FILE_POINTER)
+    {
+      SetErrnoFromWinError (GetLastError ());
+      return GNUNET_SYSERR;
+    }
+  return ret;
+#else
+  static int t[] = { [GNUNET_SEEK_SET] = SEEK_SET,
+      [GNUNET_SEEK_CUR] = SEEK_CUR, [GNUNET_SEEK_END] = SEEK_END };
+
+  return lseek (h->fd, offset, t[whence]);
+#endif
+}
+
 /**
  * Get the size of the file (or directory)
  * of the given file (in bytes).
@@ -129,6 +170,7 @@ GNUNET_DISK_file_size (const char *filename,
   return ret;
 }
 
+
 /**
  * Get the number of blocks that are left on the partition that
  * contains the given file (for normal users).
@@ -359,30 +401,55 @@ GNUNET_DISK_directory_create_for_file (const char *dir)
 
 /**
  * Read the contents of a binary file into a buffer.
- * @param fileName the name of the file, not freed,
- *        must already be expanded!
+ * @param h handle to an open file
+ * @param result the buffer to write the result to
  * @param len the maximum number of bytes to read
+ * @return the number of bytes read on success, GNUNET_SYSERR on failure
+ */
+int
+GNUNET_DISK_file_read (const struct GNUNET_IO_Handle *h, void *result, int len)
+{
+  if (h == NULL)
+    {
+      errno = EINVAL;
+      return GNUNET_SYSERR;
+    }
+
+#ifdef MINGW
+  DWORD bytesRead;
+
+  if (!ReadFile (h->h, result, len, &bytesRead, NULL))
+    {
+      SetErrnoFromWinError (GetLastError ());
+      return GNUNET_SYSERR;
+    }
+  return bytesRead;
+#else
+  return read (h->fd, result, len);
+#endif
+}
+
+
+/**
+ * Read the contents of a binary file into a buffer.
+ * @param fn file name
  * @param result the buffer to write the result to
- * @return the number of bytes read on success, -1 on failure
+ * @param len the maximum number of bytes to read
+ * @return the number of bytes read on success, GNUNET_SYSERR on failure
  */
 int
-GNUNET_DISK_file_read (const char *fileName, int len, void *result)
+GNUNET_DISK_fn_read (const char * const fn, void *result, int len)
 {
-  /* open file, must exist, open read only */
-  int handle;
-  int size;
-
-  GNUNET_assert (fileName != NULL);
-  GNUNET_assert (len > 0);
-  if (len == 0)
-    return 0;
-  GNUNET_assert (result != NULL);
-  handle = GNUNET_DISK_file_open (fileName, O_RDONLY, S_IRUSR);
-  if (handle < 0)
-    return -1;
-  size = READ (handle, result, len);
-  GNUNET_DISK_file_close (fileName, handle);
-  return size;
+  struct GNUNET_IO_Handle *fh;
+  int ret;
+
+  fh = GNUNET_DISK_file_open (fn, GNUNET_DISK_OPEN_READ);
+  if (!fh)
+    return GNUNET_SYSERR;
+  ret = GNUNET_DISK_file_read (fh, result, len);
+  GNUNET_assert(GNUNET_OK == GNUNET_DISK_file_close(&fh));
+
+  return ret;
 }
 
 
@@ -404,45 +471,57 @@ atoo (const char *s)
 
 /**
  * Write a buffer to a file.
- * @param fileName the name of the file, NOT freed!
+ * @param h handle to open file
  * @param buffer the data to write
  * @param n number of bytes to write
- * @param mode permissions to set on the file
- * @return GNUNET_OK on success, GNUNET_SYSERR on error
+ * @return number of bytes written on success, GNUNET_SYSERR on error
  */
 int
-GNUNET_DISK_file_write (const char *fileName,
-                        const void *buffer, unsigned int n, const char *mode)
+GNUNET_DISK_file_write (const struct GNUNET_IO_Handle *h, const void *buffer,
+    unsigned int n)
 {
-  int handle;
-  char *fn;
-
-  /* open file, open with 600, create if not
-     present, otherwise overwrite */
-  GNUNET_assert (fileName != NULL);
-  fn = GNUNET_STRINGS_filename_expand (fileName);
-  handle = GNUNET_DISK_file_open (fn, O_CREAT | O_WRONLY, S_IRUSR | S_IWUSR);
-  if (handle == -1)
+  if (h == NULL)
     {
-      GNUNET_free (fn);
+      errno = EINVAL;
       return GNUNET_SYSERR;
     }
-  GNUNET_assert ((n == 0) || (buffer != NULL));
-  /* write the buffer take length from the beginning */
-  if (n != WRITE (handle, buffer, n))
+
+#ifdef MINGW
+  DWORD bytesWritten;
+
+  if (!WriteFile (h->h, buffer, n, &bytesWritten, NULL))
     {
-      GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING, "write", fn);
-      GNUNET_DISK_file_close (fn, handle);
-      GNUNET_free (fn);
+      SetErrnoFromWinError (GetLastError ());
       return GNUNET_SYSERR;
     }
-  GNUNET_DISK_file_close (fn, handle);
-  if (0 != CHMOD (fn, atoo (mode)))
-    {
-      GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING, "chmod", fn);
-    }
-  GNUNET_free (fn);
-  return GNUNET_OK;
+  return bytesWritten;
+#else
+  return write (h->fd, buffer, n);
+#endif
+}
+
+/**
+ * Write a buffer to a file.
+ * @param fn file name
+ * @param buffer the data to write
+ * @param n number of bytes to write
+ * @return number of bytes written on success, GNUNET_SYSERR on error
+ */
+int
+GNUNET_DISK_fn_write (const char * const fn, const void *buffer,
+    unsigned int n, int mode)
+{
+  struct GNUNET_IO_Handle *fh;
+  int ret;
+
+  fh = GNUNET_DISK_file_open (fn, GNUNET_DISK_OPEN_WRITE
+      | 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));
+
+  return ret;
 }
 
 /**
@@ -724,57 +803,6 @@ GNUNET_DISK_directory_remove (const char *fileName)
   return GNUNET_OK;
 }
 
-void
-GNUNET_DISK_file_close (const char *filename, int fd)
-{
-  if (0 != CLOSE (fd))
-    GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING, "close", filename);
-}
-
-int
-GNUNET_DISK_file_open (const char *filename, int oflag, ...)
-{
-  char *fn;
-  int mode;
-  int ret;
-#ifdef MINGW
-  char szFile[_MAX_PATH + 1];
-  long lRet;
-
-  if ((lRet = plibc_conv_to_win_path (filename, szFile)) != ERROR_SUCCESS)
-    {
-      errno = ENOENT;
-      SetLastError (lRet);
-      GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING,
-                                "plibc_conv_to_win_path", filename);
-      return -1;
-    }
-  fn = GNUNET_strdup (szFile);
-#else
-  fn = GNUNET_STRINGS_filename_expand (filename);
-#endif
-  if (oflag & O_CREAT)
-    {
-      va_list arg;
-      va_start (arg, oflag);
-      mode = va_arg (arg, int);
-      va_end (arg);
-    }
-  else
-    {
-      mode = 0;
-    }
-#ifdef MINGW
-  /* set binary mode */
-  oflag |= O_BINARY;
-#endif
-  ret = OPEN (fn, oflag, mode);
-  if (ret == -1)
-    GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING, "open", fn);
-  GNUNET_free (fn);
-  return ret;
-}
-
 #define COPY_BLK_SIZE 65536
 
 /**
@@ -788,21 +816,21 @@ GNUNET_DISK_file_copy (const char *src, const char *dst)
   unsigned long long pos;
   unsigned long long size;
   unsigned long long len;
-  int in;
-  int out;
+  struct GNUNET_IO_Handle *in, *out;
 
   if (GNUNET_OK != GNUNET_DISK_file_size (src, &size, GNUNET_YES))
     return GNUNET_SYSERR;
   pos = 0;
-  in = GNUNET_DISK_file_open (src, O_RDONLY | O_LARGEFILE);
-  if (in == -1)
+  in = GNUNET_DISK_file_open (src, GNUNET_DISK_OPEN_READ);
+  if (!in)
     return GNUNET_SYSERR;
-  out = GNUNET_DISK_file_open (dst,
-                               O_LARGEFILE | O_WRONLY | O_CREAT | O_EXCL,
-                               S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP);
-  if (out == -1)
+  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_DISK_file_close (src, in);
+      GNUNET_DISK_file_close (&in);
       return GNUNET_SYSERR;
     }
   buf = GNUNET_malloc (COPY_BLK_SIZE);
@@ -811,20 +839,20 @@ GNUNET_DISK_file_copy (const char *src, const char *dst)
       len = COPY_BLK_SIZE;
       if (len > size - pos)
         len = size - pos;
-      if (len != READ (in, buf, len))
+      if (len != GNUNET_DISK_file_read (in, buf, len))
         goto FAIL;
-      if (len != WRITE (out, buf, len))
+      if (len != GNUNET_DISK_file_write (out, buf, len))
         goto FAIL;
       pos += len;
     }
   GNUNET_free (buf);
-  GNUNET_DISK_file_close (src, in);
-  GNUNET_DISK_file_close (dst, out);
+  GNUNET_DISK_file_close (&in);
+  GNUNET_DISK_file_close (&out);
   return GNUNET_OK;
 FAIL:
   GNUNET_free (buf);
-  GNUNET_DISK_file_close (src, in);
-  GNUNET_DISK_file_close (dst, out);
+  GNUNET_DISK_file_close (&in);
+  GNUNET_DISK_file_close (&out);
   return GNUNET_SYSERR;
 }
 
@@ -881,6 +909,177 @@ GNUNET_DISK_file_change_owner (const char *filename, const char *user)
 
 
 /**
+ * Lock a part of a file
+ * @param fh file handle
+ * @lockStart absolute position from where to lock
+ * @lockEnd absolute position until where to lock
+ * @return GNUNET_OK on success, GNUNET_SYSERR on error
+ */
+int
+GNUNET_DISK_file_lock(struct GNUNET_IO_Handle *fh, off_t lockStart,
+    off_t lockEnd)
+{
+  if (fh == NULL)
+    {
+      errno = EINVAL;
+      return GNUNET_SYSERR;
+    }
+
+#ifndef MINGW
+  struct flock fl;
+
+  memset(&fl, 0, sizeof(struct flock));
+  fl.l_type = F_WRLCK;
+  fl.l_whence = SEEK_SET;
+  fl.l_start = lockStart;
+  fl.l_len = lockEnd;
+
+  return fcntl(fh->fd, F_SETLK, &fl) != 0 ? GNUNET_SYSERR : GNUNET_OK;
+#else
+  if (!LockFile(fh->h, 0, lockStart, 0, lockEnd))
+  {
+    SetErrnoFromWinError(GetLastError());
+    return GNUNET_SYSERR;
+  }
+
+  return GNUNET_OK;
+#endif
+}
+
+
+/**
+ * Open a file
+ * @param fn file name to be opened
+ * @param flags opening flags, a combination of GNUNET_DISK_OPEN_xxx bit flags
+ * @param perm permissions for the newly created file
+ * @return IO handle on success, NULL on error
+ */
+struct GNUNET_IO_Handle *
+GNUNET_DISK_file_open (const char *fn, int flags, ...)
+{
+  char *expfn;
+  struct GNUNET_IO_Handle *ret;
+#ifdef MINGW
+  DWORD access, disp;
+  HANDLE h;
+#else
+  int oflags, mode;
+  int fd;
+#endif
+
+  expfn = GNUNET_STRINGS_filename_expand (fn);
+
+#ifndef MINGW
+  oflags = 0;
+  if (flags & GNUNET_DISK_OPEN_READ)
+    oflags = O_RDONLY;
+  if (flags & GNUNET_DISK_OPEN_WRITE)
+    oflags |= O_WRONLY;
+  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_CREATE)
+    {
+      oflags |= O_CREAT;
+
+      va_list arg;
+      va_start (arg, oflag);
+      mode = va_arg (arg, int);
+      va_end (arg);
+    }
+  if (flags & GNUNET_DISK_OPEN_APPEND)
+    oflags = O_APPEND;
+
+  fd = open (expfn, oflag | O_LARGEFILE, perm, mode);
+  if (fd == -1)
+  {
+    GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING, "open", fn);
+    return NULL;
+  }
+#else
+  access = 0;
+  disp = OPEN_ALWAYS;
+
+  if (flags & GNUNET_DISK_OPEN_READ)
+    access = FILE_READ_DATA;
+  if (flags & GNUNET_DISK_OPEN_WRITE)
+    access = FILE_WRITE_DATA;
+
+  if (flags & GNUNET_DISK_OPEN_FAILIFEXISTS)
+    disp = CREATE_NEW;
+  if (flags & GNUNET_DISK_OPEN_TRUNCATE)
+    disp = TRUNCATE_EXISTING;
+  if (flags & GNUNET_DISK_OPEN_CREATE)
+    disp |= OPEN_ALWAYS;
+
+  /* TODO: access priviledges? */
+  h = CreateFile (expfn, access, FILE_SHARE_DELETE | FILE_SHARE_READ
+      | FILE_SHARE_WRITE, NULL, disp, FILE_ATTRIBUTE_NORMAL, NULL);
+  if (h == INVALID_HANDLE_VALUE)
+  {
+    SetErrnoFromWinError (GetLastError ());
+    GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING, "open", fn);
+    return NULL;
+  }
+
+  if (flags & GNUNET_DISK_OPEN_APPEND)
+    if (SetFilePointer (h, 0, 0, FILE_END) == INVALID_SET_FILE_POINTER)
+    {
+      SetErrnoFromWinError (GetLastError ());
+      GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING, "SetFilePointer", fn);
+      CloseHandle (h);
+      return NULL;
+    }
+#endif
+
+  ret = (struct GNUNET_IO_Handle *) GNUNET_malloc(sizeof(struct GNUNET_IO_Handle));
+#ifdef MINGW
+  ret->h = h;
+#else
+  ret->fd = fd;
+#endif
+
+  return ret;
+}
+
+/**
+ * Close an open file
+ * @param h file handle
+ * @return GNUNET_OK on success, GNUNET_SYSERR otherwise
+ */
+int
+GNUNET_DISK_file_close (struct GNUNET_IO_Handle **h)
+{
+  if (*h == NULL)
+    {
+      errno = EINVAL;
+      return GNUNET_SYSERR;
+    }
+
+#if MINGW
+  if (!CloseHandle ((*h)->h))
+  {
+    SetErrnoFromWinError (GetLastError ());
+    GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "close");
+    return GNUNET_SYSERR;
+  }
+#else
+  if (close ((*h)->fd) != 0)
+  {
+    GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "close");
+    return GNUNET_SYSERR;
+  }
+#endif
+
+  GNUNET_IO_handle_invalidate (*h);
+  free(*h);
+  *h = NULL;
+
+  return GNUNET_OK;
+}
+
+/**
  * Construct full path to a file inside of the private
  * directory used by GNUnet.  Also creates the corresponding
  * directory.  If the resulting name is supposed to be
@@ -949,6 +1148,145 @@ GNUNET_DISK_get_home_filename (struct GNUNET_CONFIGURATION_Handle *cfg,
   return ret;
 }
 
+/**
+ * Map a file into memory
+ * @param h open file handle
+ * @param m handle to the new mapping
+ * @param access access specification, GNUNET_DISK_MAP_xxx
+ * @param len size of the mapping
+ * @return pointer to the mapped memory region, NULL on failure
+ */
+void *
+GNUNET_DISK_file_map (const struct GNUNET_IO_Handle *h, struct GNUNET_IO_Handle **m,
+    int access, size_t len)
+{
+  if (h == NULL)
+    {
+      errno = EINVAL;
+      return NULL;
+    }
+
+#ifdef MINGW
+  DWORD mapAccess, protect;
+  void *ret;
+
+  if (access & GNUNET_DISK_MAP_READ && access & GNUNET_DISK_MAP_WRITE)
+    {
+      protect = PAGE_READWRITE;
+      mapAccess = FILE_MAP_ALL_ACCESS;
+    }
+  else if (access & GNUNET_DISK_MAP_READ)
+    {
+      protect = PAGE_READONLY;
+      mapAccess = FILE_MAP_READ;
+    }
+  else if (access & GNUNET_DISK_MAP_WRITE)
+    {
+      protect = PAGE_READWRITE;
+      mapAccess = FILE_MAP_WRITE;
+    }
+  else
+    {
+      GNUNET_break (0);
+      return NULL;
+    }
+
+  *m = (struct GNUNET_IO_Handle *) GNUNET_malloc (sizeof (struct GNUNET_IO_Handle));
+  (*m)->h = CreateFileMapping (h->h, NULL, protect, 0, 0, NULL);
+  if ((*m)->h == INVALID_HANDLE_VALUE)
+    {
+      SetErrnoFromWinError (GetLastError ());
+      GNUNET_free (*m);
+      return NULL;
+    }
+
+  ret = MapViewOfFile ((*m)->h, mapAccess, 0, 0, len);
+  if (!ret)
+    {
+      SetErrnoFromWinError (GetLastError ());
+      CloseHandle ((*m)->h);
+      GNUNET_free (*m);
+    }
+
+  return ret;
+#else
+  int prot;
+
+  prot = flags = 0;
+  if (access & GNUNET_DISK_MAP_READ)
+    prot = PROT_READ;
+  if (access & GNUNET_DISK_MAP_WRITE)
+    prot |= PROT_WRITE;
+
+  return mmap (NULL, len, prot, MAP_SHARED, h->h, 0);
+#endif
+}
+
+/**
+ * Unmap a file
+ * @param h mapping handle
+ * @param addr pointer to the mapped memory region
+ * @param len size of the mapping
+ * @return GNUNET_OK on success, GNUNET_SYSERR otherwise
+ */
+int
+GNUNET_DISK_file_unmap (struct GNUNET_IO_Handle **h, void *addr, size_t len)
+{
+#ifdef MINGW
+  int ret;
+
+  if (h == NULL || *h == NULL)
+    {
+      errno = EINVAL;
+      return GNUNET_SYSERR;
+    }
+
+  ret = UnmapViewOfFile (addr) ? GNUNET_OK : GNUNET_SYSERR;
+  if (ret != GNUNET_OK)
+    SetErrnoFromWinError (GetLastError ());
+  if (!CloseHandle ((*h)->h) && ret == GNUNET_OK)
+    {
+      ret = GNUNET_SYSERR;
+      SetErrnoFromWinError (GetLastError ());
+    }
+
+  GNUNET_IO_handle_invalidate (*h);
+  GNUNET_free (*h);
+  h = NULL;
+
+  return ret;
+#else
+  int ret;
+  ret = munmap (addr, len) != -1 ? GNUNET_OK : GNUNET_SYSERR;
+  GNUNET_IO_handle_invalidate (h);
+  return ret;
+#endif
+}
+
+/**
+ * Write file changes to disk
+ * @param h handle to an open file
+ * @return GNUNET_OK on success, GNUNET_SYSERR otherwise
+ */
+int
+GNUNET_DISK_file_sync (const struct GNUNET_IO_Handle *h)
+{
+  if (h == NULL)
+    {
+      errno = EINVAL;
+      return GNUNET_SYSERR;
+    }
 
+#ifdef MINGW
+  int ret;
+
+  ret = FlushFileBuffers (h->h) ? GNUNET_OK : GNUNET_SYSERR;
+  if (ret != GNUNET_OK)
+    SetErrnoFromWinError (GetLastError ());
+  return ret;
+#else
+  return fsync (h->fd) == -1 ? GNUNET_SYSERR : GNUNET_OK;
+#endif
+}
 
 /* end of disk.c */
diff --git a/src/util/io_handle.c b/src/util/io_handle.c
new file mode 100644
index 000000000..438974797
--- /dev/null
+++ b/src/util/io_handle.c
@@ -0,0 +1,58 @@
+/*
+     This file is part of GNUnet.
+     (C) 2009 Christian Grothoff (and other contributing authors)
+
+     GNUnet is free software; you can redistribute it and/or modify
+     it under the terms of the GNU General Public License as published
+     by the Free Software Foundation; either version 2, or (at your
+     option) any later version.
+
+     GNUnet is distributed in the hope that it will be useful, but
+     WITHOUT ANY WARRANTY; without even the implied warranty of
+     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+     General Public License for more details.
+
+     You should have received a copy of the GNU General Public License
+     along with GNUnet; see the file COPYING.  If not, write to the
+     Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+     Boston, MA 02111-1307, USA.
+*/
+/**
+ * @file util/io_handle.c
+ * @brief common functions for IO handles
+ * @author Nils Durner
+ */
+#include "platform.h"
+#include "io_handle.h"
+#include "gnunet_common.h"
+
+/**
+ * Checks whether a handle is invalid
+ * @param h handle to check
+ * @return GNUNET_YES if invalid, GNUNET_NO if valid
+ */
+int
+GNUNET_IO_handle_invalid (const struct GNUNET_IO_Handle *h)
+{
+#ifdef MINGW
+  return !h || h->h == INVALID_HANDLE_VALUE ? GNUNET_YES : GNUNET_NO;
+#else
+  return !h || h->fd == -1 ? GNUNET_YES : GNUNET_NO;
+#endif
+}
+
+/**
+ * Mark a handle as invalid
+ * @param h file handle
+ */
+void
+GNUNET_IO_handle_invalidate (struct GNUNET_IO_Handle *h)
+{
+#ifdef MINGW
+  h->h = INVALID_HANDLE_VALUE;
+#else
+  h->fd = -1;
+#endif
+}
+
+/* end of io_handle.c */
diff --git a/src/util/io_handle.h b/src/util/io_handle.h
new file mode 100644
index 000000000..cafbdf1ee
--- /dev/null
+++ b/src/util/io_handle.h
@@ -0,0 +1,38 @@
+/*
+     This file is part of GNUnet.
+     (C) 2009 Christian Grothoff (and other contributing authors)
+
+     GNUnet is free software; you can redistribute it and/or modify
+     it under the terms of the GNU General Public License as published
+     by the Free Software Foundation; either version 2, or (at your
+     option) any later version.
+
+     GNUnet is distributed in the hope that it will be useful, but
+     WITHOUT ANY WARRANTY; without even the implied warranty of
+     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+     General Public License for more details.
+
+     You should have received a copy of the GNU General Public License
+     along with GNUnet; see the file COPYING.  If not, write to the
+     Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+     Boston, MA 02111-1307, USA.
+*/
+
+/**
+ * @file util/io_handle.c
+ * @brief wrapper structure for file handles, sockets, ...
+ */
+
+#ifndef IO_HANDLE_H_
+#define IO_HANDLE_H_
+
+struct GNUNET_IO_Handle
+{
+#if MINGW
+  HANDLE h;
+#else
+  int fd;
+#endif
+};
+
+#endif /* IO_HANDLE_H_ */
diff --git a/src/util/pseudonym.c b/src/util/pseudonym.c
index 6d9146613..f529d11f8 100644
--- a/src/util/pseudonym.c
+++ b/src/util/pseudonym.c
@@ -170,7 +170,8 @@ write_pseudonym_info (struct GNUNET_CONFIGURATION_Handle *cfg,
                                                         off + 1],
                                                    size,
                                                    GNUNET_CONTAINER_META_DATA_SERIALIZE_FULL));
-  GNUNET_DISK_file_write (fn, buf, tag, "660");
+  GNUNET_DISK_fn_write (fn, buf, tag, GNUNET_DISK_PERM_USER_READ
+      | GNUNET_DISK_PERM_USER_WRITE | GNUNET_DISK_PERM_GROUP_READ);
   GNUNET_free (fn);
   GNUNET_free (buf);
   /* create entry for pseudonym name in names */
@@ -218,7 +219,7 @@ read_info (struct GNUNET_CONFIGURATION_Handle *cfg,
       return GNUNET_SYSERR;
     }
   buf = GNUNET_malloc (len);
-  if (len != GNUNET_DISK_file_read (fn, len, buf))
+  if (len != GNUNET_DISK_fn_read (fn, buf, len))
     {
       GNUNET_free (buf);
       GNUNET_free (fn);
@@ -280,7 +281,7 @@ GNUNET_PSEUDONYM_id_to_name (struct GNUNET_CONFIGURATION_Handle *cfg,
   GNUNET_HashCode nh;
   char *fn;
   unsigned long long len;
-  int fd;
+  struct GNUNET_IO_Handle *fh;
   unsigned int i;
   unsigned int idx;
   char *ret;
@@ -317,12 +318,14 @@ GNUNET_PSEUDONYM_id_to_name (struct GNUNET_CONFIGURATION_Handle *cfg,
   len = 0;
   if (0 == STAT (fn, &sbuf))
     GNUNET_DISK_file_size (fn, &len, GNUNET_YES);
-  fd = GNUNET_DISK_file_open (fn, O_CREAT | O_RDWR, S_IRUSR | S_IWUSR);
+  fh = GNUNET_DISK_file_open (fn, GNUNET_DISK_OPEN_CREATE
+      | GNUNET_DISK_OPEN_READWRITE, GNUNET_DISK_PERM_USER_READ
+      | GNUNET_DISK_PERM_USER_WRITE);
   i = 0;
   idx = -1;
   while ((len >= sizeof (GNUNET_HashCode)) &&
          (sizeof (GNUNET_HashCode)
-          == READ (fd, &nh, sizeof (GNUNET_HashCode))))
+          == GNUNET_DISK_file_read (fh, &nh, sizeof (GNUNET_HashCode))))
     {
       if (0 == memcmp (&nh, nsid, sizeof (GNUNET_HashCode)))
         {
@@ -336,10 +339,10 @@ GNUNET_PSEUDONYM_id_to_name (struct GNUNET_CONFIGURATION_Handle *cfg,
     {
       idx = i;
       if (sizeof (GNUNET_HashCode) !=
-          WRITE (fd, nsid, sizeof (GNUNET_HashCode)))
+          GNUNET_DISK_file_write (fh, nsid, sizeof (GNUNET_HashCode)))
         GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING, "write", fn);
     }
-  CLOSE (fd);
+  GNUNET_DISK_file_close (&fh);
   ret = GNUNET_malloc (strlen (name) + 32);
   GNUNET_snprintf (ret, strlen (name) + 32, "%s-%u", name, idx);
   GNUNET_free (name);
@@ -362,7 +365,7 @@ GNUNET_PSEUDONYM_name_to_id (struct GNUNET_CONFIGURATION_Handle *cfg,
   char *name;
   GNUNET_HashCode nh;
   char *fn;
-  int fd;
+  struct GNUNET_IO_Handle *fh;
 
   idx = -1;
   slen = strlen (ns_uname);
@@ -384,15 +387,17 @@ GNUNET_PSEUDONYM_name_to_id (struct GNUNET_CONFIGURATION_Handle *cfg,
       GNUNET_free (fn);
       return GNUNET_SYSERR;
     }
-  fd = GNUNET_DISK_file_open (fn, O_CREAT | O_RDWR, S_IRUSR | S_IWUSR);
+  fh = GNUNET_DISK_file_open (fn, GNUNET_DISK_OPEN_CREATE
+      | GNUNET_DISK_OPEN_READWRITE, GNUNET_DISK_PERM_USER_READ
+      | GNUNET_DISK_PERM_USER_WRITE);
   GNUNET_free (fn);
-  LSEEK (fd, idx * sizeof (GNUNET_HashCode), SEEK_SET);
-  if (sizeof (GNUNET_HashCode) != READ (fd, nsid, sizeof (GNUNET_HashCode)))
+  GNUNET_DISK_file_seek (fh, idx * sizeof (GNUNET_HashCode), GNUNET_SEEK_SET);
+  if (sizeof (GNUNET_HashCode) != GNUNET_DISK_file_read (fh, nsid, sizeof (GNUNET_HashCode)))
     {
-      CLOSE (fd);
+      GNUNET_DISK_file_close (&fh);
       return GNUNET_SYSERR;
     }
-  CLOSE (fd);
+  GNUNET_DISK_file_close (&fh);
   return GNUNET_OK;
 }
 
diff --git a/src/util/service.c b/src/util/service.c
index 732dbe9af..4264071a9 100644
--- a/src/util/service.c
+++ b/src/util/service.c
@@ -1154,7 +1154,7 @@ detach_terminal (struct GNUNET_SERVICE_Context *sctx)
   GNUNET_break (0 == CLOSE (0));
   GNUNET_break (0 == CLOSE (1));
   GNUNET_break (0 == CLOSE (filedes[0]));
-  nullfd = GNUNET_DISK_file_open ("/dev/null", O_RDWR | O_APPEND);
+  nullfd = OPEN ("/dev/null", O_RDWR | O_APPEND);
   if (nullfd < 0)
     return GNUNET_SYSERR;
   /* set stdin/stdout to /dev/null */
diff --git a/src/util/test_disk.c b/src/util/test_disk.c
index 0d385afa7..e305889d8 100644
--- a/src/util/test_disk.c
+++ b/src/util/test_disk.c
@@ -36,13 +36,12 @@ testReadWrite ()
   char tmp[100 + 1];
   int ret;
 
-  if (GNUNET_OK !=
-      GNUNET_DISK_file_write (".testfile", TESTSTRING, strlen (TESTSTRING),
-                              "644"))
+  if (GNUNET_OK != GNUNET_DISK_fn_write (".testfile", TESTSTRING, strlen (
+      TESTSTRING), GNUNET_DISK_PERM_USER_READ | GNUNET_DISK_PERM_USER_WRITE))
     return 1;
   if (GNUNET_OK != GNUNET_DISK_file_test (".testfile"))
     return 1;
-  ret = GNUNET_DISK_file_read (".testfile", sizeof (tmp) - 1, tmp);
+  ret = GNUNET_DISK_fn_read (".testfile", tmp, sizeof (tmp) - 1);
   if (ret < 0)
     {
       fprintf (stderr,
@@ -59,7 +58,7 @@ testReadWrite ()
     }
   GNUNET_DISK_file_copy (".testfile", ".testfile2");
   memset (tmp, 0, sizeof (tmp));
-  ret = GNUNET_DISK_file_read (".testfile2", sizeof (tmp) - 1, tmp);
+  ret = GNUNET_DISK_fn_read (".testfile2", tmp, sizeof (tmp) - 1);
   if (ret < 0)
     {
       fprintf (stderr,
@@ -86,15 +85,16 @@ testReadWrite ()
 static int
 testOpenClose ()
 {
-  int fd;
+  struct GNUNET_IO_Handle *fh;
   unsigned long long size;
   long avail;
 
-  fd = GNUNET_DISK_file_open (".testfile",
-                              O_RDWR | O_CREAT, S_IWUSR | S_IRUSR);
-  GNUNET_assert (-1 != fd);
-  GNUNET_break (5 == WRITE (fd, "Hello", 5));
-  GNUNET_DISK_file_close (".testfile", fd);
+  fh = GNUNET_DISK_file_open (".testfile", GNUNET_DISK_OPEN_READWRITE
+      | GNUNET_DISK_OPEN_CREATE, GNUNET_DISK_PERM_USER_READ
+      | GNUNET_DISK_PERM_USER_WRITE);
+  GNUNET_assert (GNUNET_NO == GNUNET_IO_handle_invalid (fh));
+  GNUNET_break (5 == GNUNET_DISK_file_write (fh, "Hello", 5));
+  GNUNET_DISK_file_close (&fh);
   GNUNET_break (GNUNET_OK ==
                 GNUNET_DISK_file_size (".testfile", &size, GNUNET_NO));
   if (size != 5)
@@ -105,18 +105,19 @@ testOpenClose ()
   GNUNET_log_skip (1);
   avail = GNUNET_DISK_get_blocks_available (".testfile");
   GNUNET_log_skip (0);
-  fd = GNUNET_DISK_file_open (".testfile",
-                              O_RDWR | O_CREAT, S_IWUSR | S_IRUSR);
-  GNUNET_assert (-1 != fd);
+  fh = GNUNET_DISK_file_open (".testfile", GNUNET_DISK_OPEN_READWRITE
+      | GNUNET_DISK_OPEN_CREATE, GNUNET_DISK_PERM_USER_WRITE
+      | GNUNET_DISK_PERM_USER_READ);
+  GNUNET_assert (GNUNET_NO == GNUNET_IO_handle_invalid (fh));
   while ((avail == GNUNET_DISK_get_blocks_available (".testfile")) &&
          (avail != -1))
-    if (16 != WRITE (fd, "HelloWorld123456", 16))
+    if (16 != GNUNET_DISK_file_write (fh, "HelloWorld123456", 16))
       {
-        GNUNET_DISK_file_close (".testfile", fd);
+        GNUNET_DISK_file_close (&fh);
         GNUNET_break (0 == UNLINK (".testfile"));
         return 1;
       }
-  GNUNET_DISK_file_close (".testfile", fd);
+  GNUNET_DISK_file_close (&fh);
   GNUNET_break (0 == UNLINK (".testfile"));
 
   return 0;
diff --git a/src/util/test_os_load.c b/src/util/test_os_load.c
index 2f82f60c7..8e9776883 100644
--- a/src/util/test_os_load.c
+++ b/src/util/test_os_load.c
@@ -99,7 +99,7 @@ static int
 testdisk ()
 {
   int ret;
-  int fd;
+  struct GNUNET_IO_Handle *fh;
   char buf[65536];
   struct GNUNET_TIME_Absolute start;
   struct GNUNET_CONFIGURATION_Handle *cfg;
@@ -132,20 +132,20 @@ testdisk ()
       return 0;
     }
   memset (buf, 42, sizeof (buf));
-  fd =
-    GNUNET_DISK_file_open (".loadfile", O_WRONLY | O_CREAT,
-                           S_IRUSR | S_IWUSR);
-  GNUNET_assert (fd != -1);
+  fh = GNUNET_DISK_file_open (".loadfile", GNUNET_DISK_OPEN_WRITE
+      | GNUNET_DISK_OPEN_CREATE, GNUNET_DISK_PERM_USER_READ
+      | GNUNET_DISK_PERM_USER_WRITE);
+  GNUNET_assert (GNUNET_NO == GNUNET_IO_handle_invalid(fh));
   while (GNUNET_TIME_absolute_get_duration (start).value < 60 * 1000)
     {
-      LSEEK (fd, GNUNET_CRYPTO_random_u64 (GNUNET_CRYPTO_QUALITY_WEAK,
-                                           1024 * 1024 * 1024), SEEK_SET);
-      GNUNET_assert (sizeof (buf) == WRITE (fd, buf, sizeof (buf)));
-      fsync (fd);
+      GNUNET_DISK_file_seek (fh, GNUNET_CRYPTO_random_u64 (GNUNET_CRYPTO_QUALITY_WEAK,
+                                           1024 * 1024 * 1024), GNUNET_SEEK_SET);
+      GNUNET_assert (sizeof (buf) == GNUNET_DISK_file_write (fh, buf, sizeof (buf)));
+      GNUNET_DISK_file_sync (fh);
       if (ret < GNUNET_OS_load_disk_get (cfg))
         break;
     }
-  GNUNET_break (0 == CLOSE (fd));
+  GNUNET_break (GNUNET_OK == GNUNET_DISK_file_close (&fh));
   GNUNET_break (0 == UNLINK (".loadfile"));
   if (ret >= GNUNET_OS_load_disk_get (cfg))
     {