-load revocations from disk, misc doxygen/style fixes

6 files changed, 225 insertions, 126 deletions

diff --git a/src/fs/fs_file_information.c b/src/fs/fs_file_information.c
index 1e997cfab..87d618b07 100644
--- a/src/fs/fs_file_information.c
+++ b/src/fs/fs_file_information.c
@@ -116,7 +116,7 @@ GNUNET_FS_file_information_create_from_file (struct GNUNET_FS_Handle *h,
   char fn_conv[MAX_PATH];
 #endif
 
-  /* FIXME: should includeSymLinks be GNUNET_NO or GNUNET_YES here? */
+  /* FIXME: should include_symbolic_links be GNUNET_NO or GNUNET_YES here? */
   if (GNUNET_OK != GNUNET_DISK_file_size (filename, &fsize, GNUNET_NO, GNUNET_YES))
   {
     GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING, "stat", filename);
diff --git a/src/include/gnunet_configuration_lib.h b/src/include/gnunet_configuration_lib.h
index 10cfc4138..05ba8a2db 100644
--- a/src/include/gnunet_configuration_lib.h
+++ b/src/include/gnunet_configuration_lib.h
@@ -324,9 +324,10 @@ GNUNET_CONFIGURATION_have_value (const struct GNUNET_CONFIGURATION_Handle *cfg,
  * @return #GNUNET_OK on success, #GNUNET_SYSERR on error
  */
 int
-GNUNET_CONFIGURATION_get_value_string (const struct GNUNET_CONFIGURATION_Handle
-                                       *cfg, const char *section,
-                                       const char *option, char **value);
+GNUNET_CONFIGURATION_get_value_string (const struct GNUNET_CONFIGURATION_Handle *cfg, 
+                                       const char *section,
+                                       const char *option, 
+                                       char **value);
 
 
 /**
@@ -341,11 +342,11 @@ GNUNET_CONFIGURATION_get_value_string (const struct GNUNET_CONFIGURATION_Handle
  * @return #GNUNET_OK on success, #GNUNET_SYSERR on error
  */
 int
-GNUNET_CONFIGURATION_get_value_filename (const struct
-                                         GNUNET_CONFIGURATION_Handle *cfg,
+GNUNET_CONFIGURATION_get_value_filename (const struct GNUNET_CONFIGURATION_Handle *cfg,
                                          const char *section,
                                          const char *option, char **value);
 
+
 /**
  * Iterate over the set of filenames stored in a configuration value.
  *
diff --git a/src/include/gnunet_crypto_lib.h b/src/include/gnunet_crypto_lib.h
index c72c135c1..eda23077b 100644
--- a/src/include/gnunet_crypto_lib.h
+++ b/src/include/gnunet_crypto_lib.h
@@ -189,7 +189,6 @@ struct GNUNET_CRYPTO_EccPublicSignKey
 };
 
 
-
 /**
  * The identity of the host (wraps the signing key of the peer).
  */
@@ -296,7 +295,7 @@ GNUNET_CRYPTO_seed_weak_random (int32_t seed);
  * @param sum current sum, initially 0
  * @param buf buffer to calculate CRC over (must be 16-bit aligned)
  * @param len number of bytes in @a buf, must be multiple of 2
- * @return updated crc sum (must be subjected to GNUNET_CRYPTO_crc16_finish to get actual crc16)
+ * @return updated crc sum (must be subjected to #GNUNET_CRYPTO_crc16_finish to get actual crc16)
  */
 uint32_t
 GNUNET_CRYPTO_crc16_step (uint32_t sum, const void *buf, size_t len);
@@ -426,7 +425,7 @@ GNUNET_CRYPTO_symmetric_decrypt (const void *block, size_t size,
  * @param iv initialization vector
  * @param skey session key
  * @param salt salt for the derivation
- * @param salt_len size of the salt
+ * @param salt_len size of the @a salt
  * @param ... pairs of void * & size_t for context chunks, terminated by NULL
  */
 void
@@ -441,7 +440,7 @@ GNUNET_CRYPTO_symmetric_derive_iv (struct GNUNET_CRYPTO_SymmetricInitializationV
  * @param iv initialization vector
  * @param skey session key
  * @param salt salt for the derivation
- * @param salt_len size of the salt
+ * @param salt_len size of the @a salt
  * @param argp pairs of void * & size_t for context chunks, terminated by NULL
  */
 void
@@ -494,7 +493,7 @@ GNUNET_CRYPTO_hash_from_string2 (const char *enc, size_t enclen,
  * @ingroup hash
  *
  * Compute the distance between 2 hashcodes.  The
- * computation must be fast, not involve a[0] or a[4] (they're used
+ * computation must be fast, not involve @a a[0] or @a a[4] (they're used
  * elsewhere), and be somewhat consistent. And of course, the result
  * should be a positive number.
  *
@@ -503,8 +502,8 @@ GNUNET_CRYPTO_hash_from_string2 (const char *enc, size_t enclen,
  * @return number between 0 and UINT32_MAX
  */
 uint32_t
-GNUNET_CRYPTO_hash_distance_u32 (const struct GNUNET_HashCode * a,
-                                 const struct GNUNET_HashCode * b);
+GNUNET_CRYPTO_hash_distance_u32 (const struct GNUNET_HashCode *a,
+                                 const struct GNUNET_HashCode *b);
 
 
 /**
@@ -542,8 +541,7 @@ GNUNET_CRYPTO_hmac (const struct GNUNET_CRYPTO_AuthKey *key,
  * @param res resulting hash, NULL on error
  */
 typedef void (*GNUNET_CRYPTO_HashCompletedCallback) (void *cls,
-                                                     const struct GNUNET_HashCode *
-                                                     res);
+                                                     const struct GNUNET_HashCode *res);
 
 
 /**
@@ -593,30 +591,30 @@ GNUNET_CRYPTO_hash_create_random (enum GNUNET_CRYPTO_Quality mode,
 
 /**
  * @ingroup hash
- * compute result(delta) = b - a
+ * compute @a result = @a b - @a a
  *
  * @param a some hash code
  * @param b some hash code
  * @param result set to @a b - @a a
  */
 void
-GNUNET_CRYPTO_hash_difference (const struct GNUNET_HashCode * a,
-                               const struct GNUNET_HashCode * b,
-                               struct GNUNET_HashCode * result);
+GNUNET_CRYPTO_hash_difference (const struct GNUNET_HashCode *a,
+                               const struct GNUNET_HashCode *b,
+                               struct GNUNET_HashCode *result);
 
 
 /**
  * @ingroup hash
- * compute result(b) = a + delta
+ * compute @a result = @a a + @a delta
  *
  * @param a some hash code
  * @param delta some hash code
  * @param result set to @a a + @a delta
  */
 void
-GNUNET_CRYPTO_hash_sum (const struct GNUNET_HashCode * a,
-                        const struct GNUNET_HashCode * delta,
-                        struct GNUNET_HashCode * result);
+GNUNET_CRYPTO_hash_sum (const struct GNUNET_HashCode *a,
+                        const struct GNUNET_HashCode *delta,
+                        struct GNUNET_HashCode *result);
 
 
 /**
@@ -643,8 +641,7 @@ GNUNET_CRYPTO_hash_xor (const struct GNUNET_HashCode * a, const struct GNUNET_Ha
 void
 GNUNET_CRYPTO_hash_to_aes_key (const struct GNUNET_HashCode * hc,
                                struct GNUNET_CRYPTO_SymmetricSessionKey *skey,
-                               struct GNUNET_CRYPTO_SymmetricInitializationVector
-                               *iv);
+                               struct GNUNET_CRYPTO_SymmetricInitializationVector *iv);
 
 
 /**
@@ -663,7 +660,7 @@ GNUNET_CRYPTO_hash_get_bit (const struct GNUNET_HashCode *code,
 /**
  * @ingroup hash
  * Determine how many low order bits match in two
- * struct GNUNET_HashCodes.  i.e. - 010011 and 011111 share
+ * `struct GNUNET_HashCodes`.  i.e. - 010011 and 011111 share
  * the first two lowest order bits, and therefore the
  * return value is two (NOT XOR distance, nor how many
  * bits match absolutely!).
@@ -673,8 +670,8 @@ GNUNET_CRYPTO_hash_get_bit (const struct GNUNET_HashCode *code,
  * @return the number of bits that match
  */
 unsigned int
-GNUNET_CRYPTO_hash_matching_bits (const struct GNUNET_HashCode * first,
-                                  const struct GNUNET_HashCode * second);
+GNUNET_CRYPTO_hash_matching_bits (const struct GNUNET_HashCode *first,
+                                  const struct GNUNET_HashCode *second);
 
 
 /**
@@ -684,10 +681,11 @@ GNUNET_CRYPTO_hash_matching_bits (const struct GNUNET_HashCode * first,
  *
  * @param h1 some hash code
  * @param h2 some hash code
- * @return 1 if h1 > h2, -1 if h1 < h2 and 0 if h1 == h2.
+ * @return 1 if @a h1 > @a h2, -1 if @a h1 < @a h2 and 0 if @a h1 == @a h2.
  */
 int
-GNUNET_CRYPTO_hash_cmp (const struct GNUNET_HashCode * h1, const struct GNUNET_HashCode * h2);
+GNUNET_CRYPTO_hash_cmp (const struct GNUNET_HashCode *h1,
+                        const struct GNUNET_HashCode *h2);
 
 
 /**
@@ -698,12 +696,12 @@ GNUNET_CRYPTO_hash_cmp (const struct GNUNET_HashCode * h1, const struct GNUNET_H
  * @param h1 some hash code
  * @param h2 some hash code
  * @param target some hash code
- * @return -1 if h1 is closer, 1 if h2 is closer and 0 if h1==h2.
+ * @return -1 if @a h1 is closer, 1 if @a h2 is closer and 0 if @a h1== @a h2.
  */
 int
-GNUNET_CRYPTO_hash_xorcmp (const struct GNUNET_HashCode * h1,
-                           const struct GNUNET_HashCode * h2,
-                           const struct GNUNET_HashCode * target);
+GNUNET_CRYPTO_hash_xorcmp (const struct GNUNET_HashCode *h1,
+                           const struct GNUNET_HashCode *h2,
+                           const struct GNUNET_HashCode *target);
 
 
 /**
diff --git a/src/include/gnunet_disk_lib.h b/src/include/gnunet_disk_lib.h
index a800010f8..b5f0ccdda 100644
--- a/src/include/gnunet_disk_lib.h
+++ b/src/include/gnunet_disk_lib.h
@@ -282,7 +282,7 @@ GNUNET_DISK_handle_invalid (const struct GNUNET_DISK_FileHandle *h);
  * (of a file that exists and that is not a directory).
  *
  * @param fil filename to check
- * @return GNUNET_YES if yes, GNUNET_NO if not a file, GNUNET_SYSERR if something
+ * @return #GNUNET_YES if yes, #GNUNET_NO if not a file, #GNUNET_SYSERR if something
  * else (will print an error message in that case, too).
  */
 int
@@ -320,15 +320,16 @@ GNUNET_DISK_file_seek (const struct GNUNET_DISK_FileHandle *h, OFF_T offset,
  * @param size set to the size of the file (or,
  *             in the case of directories, the sum
  *             of all sizes of files in the directory)
- * @param includeSymLinks should symbolic links be
+ * @param include_symbolic_links should symbolic links be
  *        included?
- * @param singleFileMode GNUNET_YES to only get size of one file
- *        and return GNUNET_SYSERR for directories.
- * @return GNUNET_SYSERR on error, GNUNET_OK on success
+ * @param single_file_mode #GNUNET_YES to only get size of one file
+ *        and return #GNUNET_SYSERR for directories.
+ * @return #GNUNET_SYSERR on error, #GNUNET_OK on success
  */
 int
-GNUNET_DISK_file_size (const char *filename, uint64_t * size,
-                       int includeSymLinks, int singleFileMode);
+GNUNET_DISK_file_size (const char *filename, uint64_t *size,
+                       int include_symbolic_links, 
+                       int single_file_mode);
 
 
 /**
@@ -347,8 +348,9 @@ GNUNET_DISK_file_size (const char *filename, uint64_t * size,
  * @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);
 
 
 /**
@@ -392,7 +394,8 @@ GNUNET_DISK_mkdtemp (const char *t);
  * @return IO handle on success, NULL on error
  */
 struct GNUNET_DISK_FileHandle *
-GNUNET_DISK_file_open (const char *fn, enum GNUNET_DISK_OpenFlags flags,
+GNUNET_DISK_file_open (const char *fn, 
+                       enum GNUNET_DISK_OpenFlags flags,
                        enum GNUNET_DISK_AccessPermissions perm);
 
 
@@ -418,7 +421,10 @@ GNUNET_DISK_file_handle_size (struct GNUNET_DISK_FileHandle *fh,
  * @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);
 
 
 /**
@@ -432,7 +438,9 @@ GNUNET_DISK_pipe (int blocking_read, int blocking_write, int inherit_read, int i
  * @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]);
 
 
 /**
@@ -529,13 +537,15 @@ GNUNET_DISK_get_handle_from_native (FILE *fd);
 
 /**
  * Read the contents of a binary file into a buffer.
+ *
  * @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
  */
 ssize_t
-GNUNET_DISK_file_read (const struct GNUNET_DISK_FileHandle *h, void *result,
+GNUNET_DISK_file_read (const struct GNUNET_DISK_FileHandle *h, 
+                       void *result,
                        size_t len);
 
 
@@ -579,18 +589,20 @@ GNUNET_DISK_fn_read (const char *fn,
  */
 ssize_t
 GNUNET_DISK_file_write (const struct GNUNET_DISK_FileHandle *h,
-                        const void *buffer, size_t n);
+                        const void *buffer, 
+                        size_t n);
 
 
 /**
  * Write a buffer to a file, blocking, if necessary.
+ *
  * @param h handle to open file
  * @param buffer the data to write
  * @param n number of bytes to write
  * @return number of bytes written on success, #GNUNET_SYSERR on error
  */
 ssize_t
-GNUNET_DISK_file_write_blocking (const struct GNUNET_DISK_FileHandle * h,
+GNUNET_DISK_file_write_blocking (const struct GNUNET_DISK_FileHandle *h,
                                  const void *buffer, 
                                  size_t n);
 
@@ -606,7 +618,9 @@ 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,
+GNUNET_DISK_fn_write (const char *fn,
+                      const void *buffer, 
+                      size_t n,
                       enum GNUNET_DISK_AccessPermissions mode);
 
 
@@ -766,7 +780,8 @@ 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,
+GNUNET_DISK_file_unlock (struct GNUNET_DISK_FileHandle *fh, 
+                         OFF_T unlock_start,
                          OFF_T unlock_end);
 
 
diff --git a/src/revocation/gnunet-service-revocation.c b/src/revocation/gnunet-service-revocation.c
index dbf8817f8..a410f7b4e 100644
--- a/src/revocation/gnunet-service-revocation.c
+++ b/src/revocation/gnunet-service-revocation.c
@@ -31,7 +31,6 @@
  * peers that connect.
  *
  * TODO:
- * - load revocations from disk
  * - store revocations to disk
  * - handle p2p revocations
  * - handle p2p connect (trigger SET union)
@@ -122,6 +121,11 @@ static struct GNUNET_SERVER_Handle *srv;
 static struct GNUNET_SERVER_NotificationContext *nc;
 
 /**
+ * File handle for the revocation database.
+ */
+static struct GNUNET_DISK_FileHandle *revocation_db;
+
+/**
  * Amount of work required (W-bit collisions) for REVOCATION proofs, in collision-bits.
  */
 static unsigned long long revocation_work_required;
@@ -401,6 +405,11 @@ shutdown_task (void *cls,
     GNUNET_SERVER_notification_context_destroy (nc);
     nc = NULL;
   }
+  if (NULL != revocation_db)
+  {
+    GNUNET_DISK_file_close (revocation_db);
+    revocation_db = NULL;
+  }
   GNUNET_CONTAINER_multihashmap_iterate (revocation_map,
                                          &free_entry,
                                          NULL);
@@ -453,7 +462,23 @@ run (void *cls,
      sizeof (struct RevokeMessage)},
     {NULL, 0, 0}
   };
+  char *fn;
+  uint64_t left;
+  struct RevokeMessage *rm;
+  struct GNUNET_HashCode hc;
 
+  if (GNUNET_OK !=
+      GNUNET_CONFIGURATION_get_value_filename (c,
+                                               "REVOCATION",
+                                               "DATABASE",
+                                               &fn))
+  {
+    GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR,
+                               "REVOCATION",
+                               "DATABASE");
+    GNUNET_SCHEDULER_shutdown ();
+    return;
+  }
   cfg = c;
   srv = server;  
   revocation_map = GNUNET_CONTAINER_multihashmap_create (16, GNUNET_NO);
@@ -466,6 +491,7 @@ run (void *cls,
                                "REVOCATION",
                                "WORKBITS");
     GNUNET_SCHEDULER_shutdown ();
+    GNUNET_free (fn);
     return;
   }
   if (revocation_work_required >= sizeof (struct GNUNET_HashCode) * 8)
@@ -475,10 +501,59 @@ run (void *cls,
                                "WORKBITS",
                                _("Value is too large.\n"));
     GNUNET_SCHEDULER_shutdown ();
+    GNUNET_free (fn);
     return;
   }
   revocation_set = GNUNET_SET_create (cfg,
                                       GNUNET_SET_OPERATION_UNION);
+  
+  revocation_db = GNUNET_DISK_file_open (fn,
+                                         GNUNET_DISK_OPEN_READWRITE |
+                                         GNUNET_DISK_OPEN_CREATE,
+                                         GNUNET_DISK_PERM_USER_READ | GNUNET_DISK_PERM_USER_WRITE |
+                                         GNUNET_DISK_PERM_GROUP_READ |
+                                         GNUNET_DISK_PERM_OTHER_READ);
+  if (NULL == revocation_db)
+  {
+    GNUNET_log_config_invalid (GNUNET_ERROR_TYPE_ERROR,
+                               "REVOCATION",
+                               "DATABASE",
+                               _("Could not open revocation database file!"));
+    GNUNET_SCHEDULER_shutdown ();
+    GNUNET_free (fn);
+    return;
+  }
+  if (GNUNET_OK !=
+      GNUNET_DISK_file_size (fn, &left, GNUNET_YES, GNUNET_YES))
+    left = 0;                         
+  while (left > sizeof (struct RevokeMessage))
+  {
+    rm = GNUNET_new (struct RevokeMessage);    
+    if (sizeof (struct RevokeMessage) !=
+        GNUNET_DISK_file_read (revocation_db,
+                               rm,
+                               sizeof (struct RevokeMessage)))
+    {
+      GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_ERROR,
+                                "read",
+                                fn);
+      GNUNET_free (rm);
+      GNUNET_SCHEDULER_shutdown ();
+      GNUNET_free (fn);
+      return;
+    }
+    GNUNET_break (0 == ntohl (rm->reserved));
+    GNUNET_CRYPTO_hash (&rm->public_key,
+                        sizeof (struct GNUNET_CRYPTO_EccPublicSignKey),
+                        &hc);
+    GNUNET_break (GNUNET_OK ==
+                  GNUNET_CONTAINER_multihashmap_put (revocation_map,
+                                                     &hc,
+                                                     rm,
+                                                     GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));    
+  }
+  GNUNET_free (fn);
+  
   GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_FOREVER_REL, &shutdown_task,
                                 NULL);
   peers = GNUNET_CONTAINER_multipeermap_create (128, GNUNET_NO);
diff --git a/src/util/disk.c b/src/util/disk.c
index 9390743fd..d349aeb8e 100644
--- a/src/util/disk.c
+++ b/src/util/disk.c
@@ -282,23 +282,23 @@ GNUNET_DISK_file_seek (const struct GNUNET_DISK_FileHandle * h, OFF_T offset,
  * @param size set to the size of the file (or,
  *             in the case of directories, the sum
  *             of all sizes of files in the directory)
- * @param includeSymLinks should symbolic links be
+ * @param include_symbolic_links should symbolic links be
  *        included?
- * @param singleFileMode GNUNET_YES to only get size of one file
+ * @param single_file_mode GNUNET_YES to only get size of one file
  *        and return GNUNET_SYSERR for directories.
  * @return GNUNET_SYSERR on error, GNUNET_OK on success
  */
 int
 GNUNET_DISK_file_size (const char *filename, uint64_t * size,
-                       int includeSymLinks, int singleFileMode)
+                       int include_symbolic_links, int single_file_mode)
 {
   struct GetFileSizeData gfsd;
   int ret;
 
   GNUNET_assert (size != NULL);
   gfsd.total = 0;
-  gfsd.include_sym_links = includeSymLinks;
-  gfsd.single_file_mode = singleFileMode;
+  gfsd.include_sym_links = include_symbolic_links;
+  gfsd.single_file_mode = single_file_mode;
   ret = getSizeRec (&gfsd, filename);
   *size = gfsd.total;
   return ret;
@@ -318,7 +318,7 @@ GNUNET_DISK_file_size (const char *filename, uint64_t * size,
  * @param filename name of the file
  * @param dev set to the device ID
  * @param ino set to the inode ID
- * @return GNUNET_OK on success
+ * @return #GNUNET_OK on success
  */
 int
 GNUNET_DISK_file_get_identifiers (const char *filename, uint64_t * dev,
@@ -557,15 +557,15 @@ GNUNET_DISK_mktemp (const char *t)
 
 
 /**
- * Test if "fil" is a directory and listable. Optionally, also check if the
+ * Test if @a fil is a directory and listable. Optionally, also check if the
  * directory is readable.  Will not print an error message if the directory does
- * not exist.  Will log errors if GNUNET_SYSERR is returned (i.e., a file exists
+ * not exist.  Will log errors if #GNUNET_SYSERR is returned (i.e., a file exists
  * with the same name).
  *
  * @param fil filename to test
- * @param is_readable GNUNET_YES to additionally check if "fil" is readable;
- *          GNUNET_NO to disable this check
- * @return GNUNET_YES if yes, GNUNET_NO if not; GNUNET_SYSERR if it
+ * @param is_readable GNUNET_YES to additionally check if @a fil is readable;
+ *          #GNUNET_NO to disable this check
+ * @return #GNUNET_YES if yes, #GNUNET_NO if not; #GNUNET_SYSERR if it
  *           does not exist or stat'ed
  */
 int
@@ -605,7 +605,7 @@ GNUNET_DISK_directory_test (const char *fil, int is_readable)
  * (of a file that exists and that is not a directory).
  *
  * @param fil filename to check
- * @return GNUNET_YES if yes, GNUNET_NO if not a file, GNUNET_SYSERR if something
+ * @return #GNUNET_YES if yes, GNUNET_NO if not a file, #GNUNET_SYSERR if something
  * else (will print an error message in that case, too).
  */
 int
@@ -651,7 +651,7 @@ GNUNET_DISK_file_test (const char *fil)
  * Implementation of "mkdir -p"
  *
  * @param dir the directory to create
- * @returns GNUNET_OK on success, GNUNET_SYSERR on failure
+ * @return #GNUNET_OK on success, #GNUNET_SYSERR on failure
  */
 int
 GNUNET_DISK_directory_create (const char *dir)
@@ -759,9 +759,9 @@ GNUNET_DISK_directory_create (const char *dir)
  * a file.
  *
  * @param filename name of a file in the directory
- * @returns GNUNET_OK on success,
- *          GNUNET_SYSERR on failure,
- *          GNUNET_NO if the directory
+ * @returns #GNUNET_OK on success,
+ *          #GNUNET_SYSERR on failure,
+ *          #GNUNET_NO if the directory
  *          exists but is not writeable for us
  */
 int
@@ -788,27 +788,29 @@ GNUNET_DISK_directory_create_for_file (const char *filename)
 
 /**
  * Read the contents of a binary file into a buffer.
+ *
  * @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
+ * @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,
+GNUNET_DISK_file_read (const struct GNUNET_DISK_FileHandle *h, 
+                       void *result,
                        size_t len)
 {
-  if (h == NULL)
+  if (NULL == h)
   {
     errno = EINVAL;
     return GNUNET_SYSERR;
   }
 
 #ifdef MINGW
-  DWORD bytesRead;
+  DWORD bytes_read;
 
   if (h->type != GNUNET_DISK_HANLDE_TYPE_PIPE)
   {
-    if (!ReadFile (h->h, result, len, &bytesRead, NULL))
+    if (!ReadFile (h->h, result, len, &bytes_read, NULL))
     {
       SetErrnoFromWinError (GetLastError ());
       return GNUNET_SYSERR;
@@ -816,7 +818,7 @@ GNUNET_DISK_file_read (const struct GNUNET_DISK_FileHandle * h, void *result,
   }
   else
   {
-    if (!ReadFile (h->h, result, len, &bytesRead, h->oOverlapRead))
+    if (!ReadFile (h->h, result, len, &bytes_read, h->oOverlapRead))
     {
       if (GetLastError () != ERROR_IO_PENDING)
       {
@@ -825,11 +827,11 @@ GNUNET_DISK_file_read (const struct GNUNET_DISK_FileHandle * h, void *result,
         return GNUNET_SYSERR;
       }
       LOG (GNUNET_ERROR_TYPE_DEBUG, "Will get overlapped result\n");
-      GetOverlappedResult (h->h, h->oOverlapRead, &bytesRead, TRUE);
+      GetOverlappedResult (h->h, h->oOverlapRead, &bytes_read, TRUE);
     }
-    LOG (GNUNET_ERROR_TYPE_DEBUG, "Read %u bytes from pipe\n", bytesRead);
+    LOG (GNUNET_ERROR_TYPE_DEBUG, "Read %u bytes from pipe\n", bytes_read);
   }
-  return bytesRead;
+  return bytes_read;
 #else
   return read (h->fd, result, len);
 #endif
@@ -844,25 +846,25 @@ GNUNET_DISK_file_read (const struct GNUNET_DISK_FileHandle * h, void *result,
  * @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
+ * @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,
+GNUNET_DISK_file_read_non_blocking (const struct GNUNET_DISK_FileHandle *h,
                                     void *result, 
                                     size_t len)
 {
-  if (h == NULL)
+  if (NULL == h)
   {
     errno = EINVAL;
     return GNUNET_SYSERR;
   }
 
 #ifdef MINGW
-  DWORD bytesRead;
+  DWORD bytes_read;
 
   if (h->type != GNUNET_DISK_HANLDE_TYPE_PIPE)
   {
-    if (!ReadFile (h->h, result, len, &bytesRead, NULL))
+    if (!ReadFile (h->h, result, len, &bytes_read, NULL))
     {
       SetErrnoFromWinError (GetLastError ());
       return GNUNET_SYSERR;
@@ -870,7 +872,7 @@ GNUNET_DISK_file_read_non_blocking (const struct GNUNET_DISK_FileHandle * h,
   }
   else
   {
-    if (!ReadFile (h->h, result, len, &bytesRead, h->oOverlapRead))
+    if (!ReadFile (h->h, result, len, &bytes_read, h->oOverlapRead))
     {
       if (GetLastError () != ERROR_IO_PENDING)
       {
@@ -887,9 +889,9 @@ GNUNET_DISK_file_read_non_blocking (const struct GNUNET_DISK_FileHandle * h,
         return GNUNET_SYSERR;
       }
     }
-    LOG (GNUNET_ERROR_TYPE_DEBUG, "Read %u bytes\n", bytesRead);
+    LOG (GNUNET_ERROR_TYPE_DEBUG, "Read %u bytes\n", bytes_read);
   }
-  return bytesRead;
+  return bytes_read;
 #else
   int flags;
   ssize_t ret;
@@ -916,10 +918,12 @@ GNUNET_DISK_file_read_non_blocking (const struct GNUNET_DISK_FileHandle * h,
  * @param fn file name
  * @param result the buffer to write the result to
  * @param len the maximum number of bytes to read
- * @return number of bytes read, GNUNET_SYSERR on failure
+ * @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;
@@ -936,27 +940,28 @@ GNUNET_DISK_fn_read (const char *fn, void *result, size_t len)
 
 /**
  * Write a buffer to a file.
+ *
  * @param h handle to open file
  * @param buffer the data to write
  * @param n number of bytes to write
- * @return number of bytes written on success, GNUNET_SYSERR on error
+ * @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)
 {
-  if (h == NULL)
+  if (NULL == h)
   {
     errno = EINVAL;
     return GNUNET_SYSERR;
   }
 
 #ifdef MINGW
-  DWORD bytesWritten;
+  DWORD bytes_written;
 
   if (h->type != GNUNET_DISK_HANLDE_TYPE_PIPE)
   {
-    if (!WriteFile (h->h, buffer, n, &bytesWritten, NULL))
+    if (!WriteFile (h->h, buffer, n, &bytes_written, NULL))
     {
       SetErrnoFromWinError (GetLastError ());
       return GNUNET_SYSERR;
@@ -965,7 +970,7 @@ GNUNET_DISK_file_write (const struct GNUNET_DISK_FileHandle * h,
   else
   {
     LOG (GNUNET_ERROR_TYPE_DEBUG, "It is a pipe trying to write %u bytes\n", n);
-    if (!WriteFile (h->h, buffer, n, &bytesWritten, h->oOverlapWrite))
+    if (!WriteFile (h->h, buffer, n, &bytes_written, h->oOverlapWrite))
     {
       if (GetLastError () != ERROR_IO_PENDING)
       {
@@ -975,7 +980,7 @@ GNUNET_DISK_file_write (const struct GNUNET_DISK_FileHandle * h,
         return GNUNET_SYSERR;
       }
       LOG (GNUNET_ERROR_TYPE_DEBUG, "Will get overlapped result\n");
-      if (!GetOverlappedResult (h->h, h->oOverlapWrite, &bytesWritten, TRUE))
+      if (!GetOverlappedResult (h->h, h->oOverlapWrite, &bytes_written, TRUE))
       {
         SetErrnoFromWinError (GetLastError ());
         LOG (GNUNET_ERROR_TYPE_DEBUG,
@@ -997,21 +1002,21 @@ GNUNET_DISK_file_write (const struct GNUNET_DISK_FileHandle * h,
       {
         LOG (GNUNET_ERROR_TYPE_DEBUG,
             "Wrote %u bytes (ovr says %u), picking the greatest\n",
-            bytesWritten, ovr);
+            bytes_written, ovr);
       }
     }
-    if (bytesWritten == 0)
+    if (bytes_written == 0)
     {
       if (n > 0)
       {
-        LOG (GNUNET_ERROR_TYPE_DEBUG, "Wrote %u bytes, returning -1 with EAGAIN\n", bytesWritten);
+        LOG (GNUNET_ERROR_TYPE_DEBUG, "Wrote %u bytes, returning -1 with EAGAIN\n", bytes_written);
         errno = EAGAIN;
         return GNUNET_SYSERR;
       }
     }
-    LOG (GNUNET_ERROR_TYPE_DEBUG, "Wrote %u bytes\n", bytesWritten);
+    LOG (GNUNET_ERROR_TYPE_DEBUG, "Wrote %u bytes\n", bytes_written);
   }
-  return bytesWritten;
+  return bytes_written;
 #else
   return write (h->fd, buffer, n);
 #endif
@@ -1020,37 +1025,39 @@ GNUNET_DISK_file_write (const struct GNUNET_DISK_FileHandle * h,
 
 /**
  * Write a buffer to a file, blocking, if necessary.
+ *
  * @param h handle to open file
  * @param buffer the data to write
  * @param n number of bytes to write
- * @return number of bytes written on success, GNUNET_SYSERR on error
+ * @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)
+                                 const void *buffer, 
+                                 size_t n)
 {
-  if (h == NULL)
+  if (NULL == h)
   {
     errno = EINVAL;
     return GNUNET_SYSERR;
   }
 
 #ifdef MINGW
-  DWORD bytesWritten;
+  DWORD bytes_written;
   /* We do a non-overlapped write, which is as blocking as it gets */
   LOG (GNUNET_ERROR_TYPE_DEBUG, "Writing %u bytes\n", n);
-  if (!WriteFile (h->h, buffer, n, &bytesWritten, NULL))
+  if (!WriteFile (h->h, buffer, n, &bytes_written, NULL))
   {
     SetErrnoFromWinError (GetLastError ());
     LOG (GNUNET_ERROR_TYPE_DEBUG, "Error writing to pipe: %u\n",
         GetLastError ());
     return GNUNET_SYSERR;
   }
-  if (bytesWritten == 0 && n > 0)
+  if (bytes_written == 0 && n > 0)
   {
     LOG (GNUNET_ERROR_TYPE_DEBUG, "Waiting for pipe to clean\n");
     WaitForSingleObject (h->h, INFINITE);
-    if (!WriteFile (h->h, buffer, n, &bytesWritten, NULL))
+    if (!WriteFile (h->h, buffer, n, &bytes_written, NULL))
     {
       SetErrnoFromWinError (GetLastError ());
       LOG (GNUNET_ERROR_TYPE_DEBUG, "Error writing to pipe: %u\n",
@@ -1058,8 +1065,10 @@ GNUNET_DISK_file_write_blocking (const struct GNUNET_DISK_FileHandle * h,
       return GNUNET_SYSERR;
     }
   }
-  LOG (GNUNET_ERROR_TYPE_DEBUG, "Wrote %u bytes\n", bytesWritten);
-  return bytesWritten;
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Wrote %u bytes\n",
+       bytes_written);
+  return bytes_written;
 #else
   int flags;
   ssize_t ret;
@@ -1084,7 +1093,7 @@ GNUNET_DISK_file_write_blocking (const struct GNUNET_DISK_FileHandle * h,
  * @param buffer the data to write
  * @param n number of bytes to write
  * @param mode file permissions
- * @return number of bytes written on success, GNUNET_SYSERR on error
+ * @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,
@@ -1110,9 +1119,9 @@ GNUNET_DISK_fn_write (const char *fn, const void *buffer, size_t n,
  * @param dir_name the name of the directory
  * @param callback the method to call for each file,
  *        can be NULL, in that case, we only count
- * @param callback_cls closure for callback
- * @return the number of files found, GNUNET_SYSERR on error or
- *         ieration aborted by callback returning GNUNET_SYSERR
+ * @param callback_cls closure for @a callback
+ * @return the number of files found, #GNUNET_SYSERR on error or
+ *         ieration aborted by callback returning #GNUNET_SYSERR
  */
 int
 GNUNET_DISK_directory_scan (const char *dir_name,
@@ -1143,7 +1152,8 @@ GNUNET_DISK_directory_scan (const char *dir_name,
   }
   if (!S_ISDIR (istat.st_mode))
   {
-    LOG (GNUNET_ERROR_TYPE_WARNING, _("Expected `%s' to be a directory!\n"),
+    LOG (GNUNET_ERROR_TYPE_WARNING, 
+         _("Expected `%s' to be a directory!\n"),
          dir_name);
     GNUNET_free (dname);
     return GNUNET_SYSERR;
@@ -1324,7 +1334,7 @@ GNUNET_DISK_directory_iterator_start (enum GNUNET_SCHEDULER_Priority prio,
 {
   struct GNUNET_DISK_DirectoryIterator *di;
 
-  di = GNUNET_malloc (sizeof (struct GNUNET_DISK_DirectoryIterator));
+  di = GNUNET_new (struct GNUNET_DISK_DirectoryIterator);
   di->callback = callback;
   di->callback_cls = callback_cls;
   di->directory = OPENDIR (dir_name);
@@ -1748,7 +1758,7 @@ GNUNET_DISK_file_open (const char *fn,
     }
 #endif
 
-  ret = GNUNET_malloc (sizeof (struct GNUNET_DISK_FileHandle));
+  ret = GNUNET_new (struct GNUNET_DISK_FileHandle);
 #ifdef MINGW
   ret->h = h;
   ret->type = GNUNET_DISK_HANLDE_TYPE_FILE;
@@ -1843,7 +1853,7 @@ GNUNET_DISK_get_handle_from_w32_handle (HANDLE osfh)
     return NULL;
   }
 
-  fh = GNUNET_malloc (sizeof (struct GNUNET_DISK_FileHandle));
+  fh = GNUNET_new (struct GNUNET_DISK_FileHandle);
 
   fh->h = osfh;
   fh->type = ftype;
@@ -1883,7 +1893,7 @@ GNUNET_DISK_get_handle_from_int_fd (int fno)
     return NULL; /* invalid FD */
 
 #ifndef WINDOWS
-  fh = GNUNET_malloc (sizeof (struct GNUNET_DISK_FileHandle));
+  fh = GNUNET_new (struct GNUNET_DISK_FileHandle);
 
   fh->fd = fno;
 #else
@@ -2064,7 +2074,7 @@ GNUNET_DISK_file_map (const struct GNUNET_DISK_FileHandle *h,
     return NULL;
   }
 
-  *m = GNUNET_malloc (sizeof (struct GNUNET_DISK_MapHandle));
+  *m = GNUNET_new (struct GNUNET_DISK_MapHandle);
   (*m)->h = CreateFileMapping (h->h, NULL, protect, 0, 0, NULL);
   if ((*m)->h == INVALID_HANDLE_VALUE)
   {
@@ -2090,7 +2100,7 @@ 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_malloc (sizeof (struct GNUNET_DISK_MapHandle));
+  *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)
@@ -2322,9 +2332,9 @@ GNUNET_DISK_pipe (int blocking_read, int blocking_write, int inherit_read, int i
   HANDLE tmp_handle;
   int save_errno;
 
-  p = GNUNET_malloc (sizeof (struct GNUNET_DISK_PipeHandle));
-  p->fd[0] = GNUNET_malloc (sizeof (struct GNUNET_DISK_FileHandle));
-  p->fd[1] = GNUNET_malloc (sizeof (struct GNUNET_DISK_FileHandle));
+  p = GNUNET_new (struct GNUNET_DISK_PipeHandle);
+  p->fd[0] = GNUNET_new (struct GNUNET_DISK_FileHandle);
+  p->fd[1] = GNUNET_new (struct GNUNET_DISK_FileHandle);
 
   /* All pipes are overlapped. If you want them to block - just
    * call WriteFile() and ReadFile() with NULL overlapped pointer.
@@ -2417,7 +2427,7 @@ GNUNET_DISK_pipe_from_fd (int blocking_read, int blocking_write, int fd[2])
 {
   struct GNUNET_DISK_PipeHandle *p;
 
-  p = GNUNET_malloc (sizeof (struct GNUNET_DISK_PipeHandle));
+  p = GNUNET_new (struct GNUNET_DISK_PipeHandle);
 
 #ifndef MINGW
   int ret;
@@ -2427,7 +2437,7 @@ GNUNET_DISK_pipe_from_fd (int blocking_read, int blocking_write, int fd[2])
   ret = 0;
   if (fd[0] >= 0)
   {
-    p->fd[0] = GNUNET_malloc (sizeof (struct GNUNET_DISK_FileHandle));
+    p->fd[0] = GNUNET_new (struct GNUNET_DISK_FileHandle);
     p->fd[0]->fd = fd[0];
     if (!blocking_read)
     {
@@ -2450,7 +2460,7 @@ GNUNET_DISK_pipe_from_fd (int blocking_read, int blocking_write, int fd[2])
 
   if (fd[1] >= 0)
   {
-    p->fd[1] = GNUNET_malloc (sizeof (struct GNUNET_DISK_FileHandle));
+    p->fd[1] = GNUNET_new (struct GNUNET_DISK_FileHandle);
     p->fd[1]->fd = fd[1];
     if (!blocking_write)
     {
@@ -2487,7 +2497,7 @@ GNUNET_DISK_pipe_from_fd (int blocking_read, int blocking_write, int fd[2])
 #else
   if (fd[0] >= 0)
   {
-    p->fd[0] = GNUNET_malloc (sizeof (struct GNUNET_DISK_FileHandle));
+    p->fd[0] = GNUNET_new (struct GNUNET_DISK_FileHandle);
     p->fd[0]->h = (HANDLE) _get_osfhandle (fd[0]);
     if (p->fd[0]->h != INVALID_HANDLE_VALUE)
     {
@@ -2505,7 +2515,7 @@ GNUNET_DISK_pipe_from_fd (int blocking_read, int blocking_write, int fd[2])
   }
   if (fd[1] >= 0)
   {
-    p->fd[1] = GNUNET_malloc (sizeof (struct GNUNET_DISK_FileHandle));
+    p->fd[1] = GNUNET_new (struct GNUNET_DISK_FileHandle);
     p->fd[1]->h = (HANDLE) _get_osfhandle (fd[1]);
     if (p->fd[1]->h != INVALID_HANDLE_VALUE)
     {