first step to remove plibc

5 files changed, 271 insertions, 391 deletions

diff --git a/src/datacache/datacache.c b/src/datacache/datacache.c
index 7dcd54fcf..57e0b0bb7 100644
--- a/src/datacache/datacache.c
+++ b/src/datacache/datacache.c
@@ -29,9 +29,10 @@
 #include "gnunet_datacache_plugin.h"
 
 
-#define LOG(kind,...) GNUNET_log_from (kind, "datacache", __VA_ARGS__)
+#define LOG(kind, ...) GNUNET_log_from (kind, "datacache", __VA_ARGS__)
 
-#define LOG_STRERROR_FILE(kind,op,fn) GNUNET_log_from_strerror_file (kind, "datacache", op, fn)
+#define LOG_STRERROR_FILE(kind, op, fn) \
+  GNUNET_log_from_strerror_file (kind, "datacache", op, fn)
 
 /**
  * Internal state of the datacache library.
@@ -89,7 +90,6 @@ struct GNUNET_DATACACHE_Handle
    * How much space is in use right now?
    */
   unsigned long long utilization;
-
 };
 
 
@@ -102,9 +102,7 @@ struct GNUNET_DATACACHE_Handle
  * @param size number of bytes that were made available
  */
 static void
-env_delete_notify (void *cls,
-                   const struct GNUNET_HashCode *key,
-                   size_t size)
+env_delete_notify (void *cls, const struct GNUNET_HashCode *key, size_t size)
 {
   struct GNUNET_DATACACHE_Handle *h = cls;
 
@@ -113,11 +111,10 @@ env_delete_notify (void *cls,
        GNUNET_h2s (key));
   GNUNET_assert (h->utilization >= size);
   h->utilization -= size;
-  GNUNET_CONTAINER_bloomfilter_remove (h->filter,
-                                       key);
+  GNUNET_CONTAINER_bloomfilter_remove (h->filter, key);
   GNUNET_STATISTICS_update (h->stats,
                             gettext_noop ("# bytes stored"),
-                            - (long long) size,
+                            -(long long) size,
                             GNUNET_NO);
   GNUNET_STATISTICS_update (h->stats,
                             gettext_noop ("# items stored"),
@@ -144,54 +141,42 @@ GNUNET_DATACACHE_create (const struct GNUNET_CONFIGURATION_Handle *cfg,
   char *name;
 
   if (GNUNET_OK !=
-      GNUNET_CONFIGURATION_get_value_size (cfg,
-                                           section,
-                                           "QUOTA",
-                                           &quota))
+      GNUNET_CONFIGURATION_get_value_size (cfg, section, "QUOTA", &quota))
   {
-    GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR,
-                               section,
-                               "QUOTA");
+    GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR, section, "QUOTA");
     return NULL;
   }
   if (GNUNET_OK !=
-      GNUNET_CONFIGURATION_get_value_string (cfg,
-                                             section,
-                                             "DATABASE",
-                                             &name))
+      GNUNET_CONFIGURATION_get_value_string (cfg, section, "DATABASE", &name))
   {
-    GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR,
-                               section,
-                               "DATABASE");
+    GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR, section, "DATABASE");
     return NULL;
   }
-  bf_size = quota / 32;         /* 8 bit per entry, 1 bit per 32 kb in DB */
+  bf_size = quota / 32; /* 8 bit per entry, 1 bit per 32 kb in DB */
 
   ret = GNUNET_new (struct GNUNET_DATACACHE_Handle);
 
   if (GNUNET_YES !=
-      GNUNET_CONFIGURATION_get_value_yesno (cfg,
-                                            section,
-                                            "DISABLE_BF"))
+      GNUNET_CONFIGURATION_get_value_yesno (cfg, section, "DISABLE_BF"))
   {
     if (GNUNET_YES !=
-        GNUNET_CONFIGURATION_get_value_yesno (cfg,
-                                              section,
-                                              "DISABLE_BF_RC"))
+        GNUNET_CONFIGURATION_get_value_yesno (cfg, section, "DISABLE_BF_RC"))
     {
       ret->bloom_name = GNUNET_DISK_mktemp ("gnunet-datacachebloom");
     }
     if (NULL != ret->bloom_name)
     {
-      ret->filter = GNUNET_CONTAINER_bloomfilter_load (ret->bloom_name,
-                                                       quota / 1024,     /* 8 bit per entry in DB, expect 1k entries */
-                                                       5);
+      ret->filter = GNUNET_CONTAINER_bloomfilter_load (
+        ret->bloom_name,
+        quota / 1024, /* 8 bit per entry in DB, expect 1k entries */
+        5);
     }
     if (NULL == ret->filter)
     {
-      ret->filter = GNUNET_CONTAINER_bloomfilter_init (NULL,
-                                                       bf_size,
-                                                       5); /* approx. 3% false positives at max use */
+      ret->filter =
+        GNUNET_CONTAINER_bloomfilter_init (NULL,
+                                           bf_size,
+                                           5); /* approx. 3% false positives at max use */
     }
   }
   ret->stats = GNUNET_STATISTICS_create ("datacache", cfg);
@@ -202,19 +187,15 @@ GNUNET_DATACACHE_create (const struct GNUNET_CONFIGURATION_Handle *cfg,
   ret->env.cls = ret;
   ret->env.delete_notify = &env_delete_notify;
   ret->env.quota = quota;
-  LOG (GNUNET_ERROR_TYPE_INFO,
-       _("Loading `%s' datacache plugin\n"),
-       name);
-  GNUNET_asprintf (&libname,
-                   "libgnunet_plugin_datacache_%s",
-                   name);
+  LOG (GNUNET_ERROR_TYPE_INFO, _ ("Loading `%s' datacache plugin\n"), name);
+  GNUNET_asprintf (&libname, "libgnunet_plugin_datacache_%s", name);
   ret->short_name = name;
   ret->lib_name = libname;
   ret->api = GNUNET_PLUGIN_load (libname, &ret->env);
   if (ret->api == NULL)
   {
     LOG (GNUNET_ERROR_TYPE_ERROR,
-         _("Failed to load datacache plugin for `%s'\n"),
+         _ ("Failed to load datacache plugin for `%s'\n"),
          name);
     GNUNET_DATACACHE_destroy (ret);
     return NULL;
@@ -234,23 +215,20 @@ GNUNET_DATACACHE_destroy (struct GNUNET_DATACACHE_Handle *h)
   if (NULL != h->filter)
     GNUNET_CONTAINER_bloomfilter_free (h->filter);
   if (NULL != h->api)
-    GNUNET_break (NULL ==
-                  GNUNET_PLUGIN_unload (h->lib_name,
-                                        h->api));
+    GNUNET_break (NULL == GNUNET_PLUGIN_unload (h->lib_name, h->api));
   GNUNET_free (h->lib_name);
   GNUNET_free (h->short_name);
   GNUNET_free (h->section);
   if (NULL != h->bloom_name)
   {
-    if (0 != UNLINK (h->bloom_name))
+    if (0 != unlink (h->bloom_name))
       GNUNET_log_from_strerror_file (GNUNET_ERROR_TYPE_WARNING,
                                      "datacache",
                                      "unlink",
                                      h->bloom_name);
     GNUNET_free (h->bloom_name);
   }
-  GNUNET_STATISTICS_destroy (h->stats,
-                             GNUNET_NO);
+  GNUNET_STATISTICS_destroy (h->stats, GNUNET_NO);
   GNUNET_free (h);
 }
 
@@ -277,19 +255,19 @@ GNUNET_DATACACHE_put (struct GNUNET_DATACACHE_Handle *h,
                       const char *data,
                       enum GNUNET_BLOCK_Type type,
                       struct GNUNET_TIME_Absolute discard_time,
-                      unsigned int path_info_len,
-                      const struct GNUNET_PeerIdentity *path_info)
+                      unsigned int path_info_len,
+                      const struct GNUNET_PeerIdentity *path_info)
 {
   ssize_t used;
 
   used = h->api->put (h->api->cls,
                       key,
                       xor_distance,
-                      data_size,
+                      data_size,
                       data,
-                      type,
+                      type,
                       discard_time,
-                      path_info_len,
+                      path_info_len,
                       path_info);
   if (-1 == used)
   {
@@ -305,8 +283,7 @@ GNUNET_DATACACHE_put (struct GNUNET_DATACACHE_Handle *h,
        "Stored data under key `%s' in cache\n",
        GNUNET_h2s (key));
   if (NULL != h->filter)
-    GNUNET_CONTAINER_bloomfilter_add (h->filter,
-                                      key);
+    GNUNET_CONTAINER_bloomfilter_add (h->filter, key);
   GNUNET_STATISTICS_update (h->stats,
                             gettext_noop ("# bytes stored"),
                             used,
@@ -316,8 +293,7 @@ GNUNET_DATACACHE_put (struct GNUNET_DATACACHE_Handle *h,
                             1,
                             GNUNET_NO);
   while (h->utilization + used > h->env.quota)
-    GNUNET_assert (GNUNET_OK ==
-                   h->api->del (h->api->cls));
+    GNUNET_assert (GNUNET_OK == h->api->del (h->api->cls));
   h->utilization += used;
   return GNUNET_OK;
 }
@@ -348,23 +324,20 @@ GNUNET_DATACACHE_get (struct GNUNET_DATACACHE_Handle *h,
   LOG (GNUNET_ERROR_TYPE_DEBUG,
        "Processing request for key `%s'\n",
        GNUNET_h2s (key));
-  if ( (NULL != h->filter) &&
-       (GNUNET_OK != GNUNET_CONTAINER_bloomfilter_test (h->filter, key)) )
+  if ((NULL != h->filter) &&
+      (GNUNET_OK != GNUNET_CONTAINER_bloomfilter_test (h->filter, key)))
   {
     GNUNET_STATISTICS_update (h->stats,
-                              gettext_noop ("# requests filtered by bloom filter"),
+                              gettext_noop (
+                                "# requests filtered by bloom filter"),
                               1,
                               GNUNET_NO);
     LOG (GNUNET_ERROR_TYPE_DEBUG,
          "Bloomfilter filters request for key `%s'\n",
          GNUNET_h2s (key));
-    return 0;                   /* can not be present */
+    return 0; /* can not be present */
   }
-  return h->api->get (h->api->cls,
-                      key,
-                      type,
-                      iter,
-                      iter_cls);
+  return h->api->get (h->api->cls, key, type, iter, iter_cls);
 }
 
 
@@ -382,14 +355,12 @@ GNUNET_DATACACHE_get_random (struct GNUNET_DATACACHE_Handle *h,
                              void *iter_cls)
 {
   GNUNET_STATISTICS_update (h->stats,
-                            gettext_noop ("# requests for random value received"),
+                            gettext_noop (
+                              "# requests for random value received"),
                             1,
                             GNUNET_NO);
-  LOG (GNUNET_ERROR_TYPE_DEBUG,
-       "Processing request for random value\n");
-  return h->api->get_random (h->api->cls,
-                             iter,
-                             iter_cls);
+  LOG (GNUNET_ERROR_TYPE_DEBUG, "Processing request for random value\n");
+  return h->api->get_random (h->api->cls, iter, iter_cls);
 }
 
 
@@ -414,17 +385,14 @@ GNUNET_DATACACHE_get_closest (struct GNUNET_DATACACHE_Handle *h,
                               void *iter_cls)
 {
   GNUNET_STATISTICS_update (h->stats,
-                            gettext_noop ("# proximity search requests received"),
+                            gettext_noop (
+                              "# proximity search requests received"),
                             1,
                             GNUNET_NO);
   LOG (GNUNET_ERROR_TYPE_DEBUG,
        "Processing proximity search at `%s'\n",
        GNUNET_h2s (key));
-  return h->api->get_closest (h->api->cls,
-                              key,
-                              num_results,
-                              iter,
-                              iter_cls);
+  return h->api->get_closest (h->api->cls, key, num_results, iter, iter_cls);
 }
 
 
diff --git a/src/datacache/perf_datacache.c b/src/datacache/perf_datacache.c
index 4381171c5..1dfb46cf1 100644
--- a/src/datacache/perf_datacache.c
+++ b/src/datacache/perf_datacache.c
@@ -74,7 +74,7 @@ run (void *cls, char *const *args, const char *cfgfile,
 
   if (h == NULL)
   {
-    FPRINTF (stderr, "%s", "Failed to initialize datacache.  Database likely not setup, skipping test.\n");
+    fprintf (stderr, "%s", "Failed to initialize datacache.  Database likely not setup, skipping test.\n");
     ok = 77; /* mark test as skipped */
     return;
   }
@@ -84,7 +84,7 @@ run (void *cls, char *const *args, const char *cfgfile,
   for (i = 0; i < ITERATIONS; i++)
   {
     if (0 == i % (ITERATIONS / 80))
-      FPRINTF (stderr, "%s",  ".");
+      fprintf (stderr, "%s",  ".");
     GNUNET_CRYPTO_hash (&k, sizeof (struct GNUNET_HashCode), &n);
     ASSERT (GNUNET_OK ==
             GNUNET_DATACACHE_put (h, &k, sizeof (struct GNUNET_HashCode),
@@ -92,8 +92,8 @@ run (void *cls, char *const *args, const char *cfgfile,
                                   0, NULL));
     k = n;
   }
-  FPRINTF (stderr, "%s",  "\n");
-  FPRINTF (stdout, "Stored %u items in %s\n", ITERATIONS,
+  fprintf (stderr, "%s",  "\n");
+  fprintf (stdout, "Stored %u items in %s\n", ITERATIONS,
            GNUNET_STRINGS_relative_time_to_string (GNUNET_TIME_absolute_get_duration (start), GNUNET_YES));
   GNUNET_snprintf (gstr, sizeof (gstr), "DATACACHE-%s", plugin_name);
   GAUGER (gstr, "Time to PUT item in datacache",
@@ -104,13 +104,13 @@ run (void *cls, char *const *args, const char *cfgfile,
   for (i = 0; i < ITERATIONS; i++)
   {
     if (0 == i % (ITERATIONS / 80))
-      FPRINTF (stderr, "%s",  ".");
+      fprintf (stderr, "%s",  ".");
     GNUNET_CRYPTO_hash (&k, sizeof (struct GNUNET_HashCode), &n);
     GNUNET_DATACACHE_get (h, &k, 1 + i % 16, &checkIt, &n);
     k = n;
   }
-  FPRINTF (stderr, "%s",  "\n");
-  FPRINTF (stdout,
+  fprintf (stderr, "%s",  "\n");
+  fprintf (stdout,
            "Found %u/%u items in %s (%u were deleted during storage processing)\n",
            found, ITERATIONS,
            GNUNET_STRINGS_relative_time_to_string (GNUNET_TIME_absolute_get_duration (start), GNUNET_YES),
@@ -152,7 +152,7 @@ main (int argc, char *argv[])
   GNUNET_PROGRAM_run ((sizeof (xargv) / sizeof (char *)) - 1, xargv,
                       "perf-datacache", "nohelp", options, &run, NULL);
   if ( (0 != ok) && (77 != ok) )
-    FPRINTF (stderr, "Missed some perfcases: %d\n", ok);
+    fprintf (stderr, "Missed some perfcases: %d\n", ok);
   return ok;
 }
 
diff --git a/src/datacache/plugin_datacache_sqlite.c b/src/datacache/plugin_datacache_sqlite.c
index 07a72957a..0cf77d6e6 100644
--- a/src/datacache/plugin_datacache_sqlite.c
+++ b/src/datacache/plugin_datacache_sqlite.c
@@ -29,16 +29,17 @@
 #include "gnunet_sq_lib.h"
 #include <sqlite3.h>
 
-#define LOG(kind,...) GNUNET_log_from (kind, "datacache-sqlite", __VA_ARGS__)
+#define LOG(kind, ...) GNUNET_log_from (kind, "datacache-sqlite", __VA_ARGS__)
 
-#define LOG_STRERROR_FILE(kind,op,fn) GNUNET_log_from_strerror_file (kind, "datacache-sqlite", op, fn)
+#define LOG_STRERROR_FILE(kind, op, fn) \
+  GNUNET_log_from_strerror_file (kind, "datacache-sqlite", op, fn)
 
 
 /**
  * How much overhead do we assume per entry in the
  * datacache?
  */
-#define OVERHEAD (sizeof(struct GNUNET_HashCode) + 36)
+#define OVERHEAD (sizeof (struct GNUNET_HashCode) + 36)
 
 /**
  * Context for all functions in this plugin.
@@ -115,7 +116,16 @@ struct Plugin
  * @param level log level
  * @param cmd failed command
  */
-#define LOG_SQLITE(db, level, cmd) do { LOG (level, _("`%s' failed at %s:%d with error: %s\n"), cmd, __FILE__, __LINE__, sqlite3_errmsg(db)); } while(0)
+#define LOG_SQLITE(db, level, cmd)                    \
+  do                                                  \
+  {                                                   \
+    LOG (level,                                       \
+         _ ("`%s' failed at %s:%d with error: %s\n"), \
+         cmd,                                         \
+         __FILE__,                                    \
+         __LINE__,                                    \
+         sqlite3_errmsg (db));                        \
+  } while (0)
 
 
 /**
@@ -124,7 +134,21 @@ struct Plugin
  * @param db database handle
  * @param cmd SQL command to execute
  */
-#define SQLITE3_EXEC(db, cmd) do { emsg = NULL; if (SQLITE_OK != sqlite3_exec(db, cmd, NULL, NULL, &emsg)) { LOG (GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK, _("`%s' failed at %s:%d with error: %s\n"), "sqlite3_exec", __FILE__, __LINE__, emsg); sqlite3_free(emsg); } } while(0)
+#define SQLITE3_EXEC(db, cmd)                                   \
+  do                                                            \
+  {                                                             \
+    emsg = NULL;                                                \
+    if (SQLITE_OK != sqlite3_exec (db, cmd, NULL, NULL, &emsg)) \
+    {                                                           \
+      LOG (GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,    \
+           _ ("`%s' failed at %s:%d with error: %s\n"),         \
+           "sqlite3_exec",                                      \
+           __FILE__,                                            \
+           __LINE__,                                            \
+           emsg);                                               \
+      sqlite3_free (emsg);                                      \
+    }                                                           \
+  } while (0)
 
 
 /**
@@ -137,9 +161,9 @@ struct Plugin
  */
 static int
 sq_prepare (sqlite3 *dbh,
-            const char *zSql,    /* SQL statement, UTF-8 encoded */
+            const char *zSql, /* SQL statement, UTF-8 encoded */
             sqlite3_stmt **ppStmt)
-{                               /* OUT: Statement handle */
+{ /* OUT: Statement handle */
   char *dummy;
 
   return sqlite3_prepare (dbh,
@@ -166,58 +190,53 @@ sq_prepare (sqlite3 *dbh,
  */
 static ssize_t
 sqlite_plugin_put (void *cls,
-                   const struct GNUNET_HashCode *key,
+                   const struct GNUNET_HashCode *key,
                    uint32_t xor_distance,
-                   size_t size,
+                   size_t size,
                    const char *data,
-                   enum GNUNET_BLOCK_Type type,
+                   enum GNUNET_BLOCK_Type type,
                    struct GNUNET_TIME_Absolute discard_time,
-                   unsigned int path_info_len,
-                   const struct GNUNET_PeerIdentity *path_info)
+                   unsigned int path_info_len,
+                   const struct GNUNET_PeerIdentity *path_info)
 {
   struct Plugin *plugin = cls;
   uint32_t type32 = type;
-  struct GNUNET_SQ_QueryParam params[] = {
-    GNUNET_SQ_query_param_uint32 (&type32),
-    GNUNET_SQ_query_param_absolute_time (&discard_time),
-    GNUNET_SQ_query_param_auto_from_type (key),
-    GNUNET_SQ_query_param_uint32 (&xor_distance),
-    GNUNET_SQ_query_param_fixed_size (data, size),
-    GNUNET_SQ_query_param_fixed_size (path_info,
-                                      path_info_len * sizeof (struct GNUNET_PeerIdentity)),
-    GNUNET_SQ_query_param_end
-  };
+  struct GNUNET_SQ_QueryParam params[] =
+    {GNUNET_SQ_query_param_uint32 (&type32),
+     GNUNET_SQ_query_param_absolute_time (&discard_time),
+     GNUNET_SQ_query_param_auto_from_type (key),
+     GNUNET_SQ_query_param_uint32 (&xor_distance),
+     GNUNET_SQ_query_param_fixed_size (data, size),
+     GNUNET_SQ_query_param_fixed_size (path_info,
+                                       path_info_len *
+                                         sizeof (struct GNUNET_PeerIdentity)),
+     GNUNET_SQ_query_param_end};
 
   LOG (GNUNET_ERROR_TYPE_DEBUG,
        "Processing PUT of %u bytes with key `%s' and expiration %s\n",
        (unsigned int) size,
        GNUNET_h2s (key),
-       GNUNET_STRINGS_relative_time_to_string (GNUNET_TIME_absolute_get_remaining (discard_time),
+       GNUNET_STRINGS_relative_time_to_string (GNUNET_TIME_absolute_get_remaining (
+                                                 discard_time),
                                                GNUNET_YES));
-  if (GNUNET_OK !=
-      GNUNET_SQ_bind (plugin->insert_stmt,
-                      params))
+  if (GNUNET_OK != GNUNET_SQ_bind (plugin->insert_stmt, params))
   {
     LOG_SQLITE (plugin->dbh,
                 GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
                 "sqlite3_bind_xxx");
-    GNUNET_SQ_reset (plugin->dbh,
-                     plugin->insert_stmt);
+    GNUNET_SQ_reset (plugin->dbh, plugin->insert_stmt);
     return -1;
   }
-  if (SQLITE_DONE !=
-      sqlite3_step (plugin->insert_stmt))
+  if (SQLITE_DONE != sqlite3_step (plugin->insert_stmt))
   {
     LOG_SQLITE (plugin->dbh,
                 GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
                 "sqlite3_step");
-    GNUNET_SQ_reset (plugin->dbh,
-                     plugin->insert_stmt);
+    GNUNET_SQ_reset (plugin->dbh, plugin->insert_stmt);
     return -1;
   }
   plugin->num_items++;
-  GNUNET_SQ_reset (plugin->dbh,
-                   plugin->insert_stmt);
+  GNUNET_SQ_reset (plugin->dbh, plugin->insert_stmt);
   return size + OVERHEAD;
 }
 
@@ -251,62 +270,50 @@ sqlite_plugin_get (void *cls,
   unsigned int total;
   size_t psize;
   struct GNUNET_PeerIdentity *path;
-  struct GNUNET_SQ_QueryParam params_count[] = {
-    GNUNET_SQ_query_param_auto_from_type (key),
-    GNUNET_SQ_query_param_uint32 (&type32),
-    GNUNET_SQ_query_param_absolute_time (&now),
-    GNUNET_SQ_query_param_end
-  };
-  struct GNUNET_SQ_QueryParam params_select[] = {
-    GNUNET_SQ_query_param_auto_from_type (key),
-    GNUNET_SQ_query_param_uint32 (&type32),
-    GNUNET_SQ_query_param_absolute_time (&now),
-    GNUNET_SQ_query_param_uint32 (&off),
-    GNUNET_SQ_query_param_end
-  };
-  struct GNUNET_SQ_ResultSpec rs[] = {
-    GNUNET_SQ_result_spec_variable_size (&dat,
-                                         &size),
-    GNUNET_SQ_result_spec_absolute_time (&exp),
-    GNUNET_SQ_result_spec_variable_size ((void **) &path,
-                                         &psize),
-    GNUNET_SQ_result_spec_end
-  };
+  struct GNUNET_SQ_QueryParam params_count[] =
+    {GNUNET_SQ_query_param_auto_from_type (key),
+     GNUNET_SQ_query_param_uint32 (&type32),
+     GNUNET_SQ_query_param_absolute_time (&now),
+     GNUNET_SQ_query_param_end};
+  struct GNUNET_SQ_QueryParam params_select[] =
+    {GNUNET_SQ_query_param_auto_from_type (key),
+     GNUNET_SQ_query_param_uint32 (&type32),
+     GNUNET_SQ_query_param_absolute_time (&now),
+     GNUNET_SQ_query_param_uint32 (&off),
+     GNUNET_SQ_query_param_end};
+  struct GNUNET_SQ_ResultSpec rs[] =
+    {GNUNET_SQ_result_spec_variable_size (&dat, &size),
+     GNUNET_SQ_result_spec_absolute_time (&exp),
+     GNUNET_SQ_result_spec_variable_size ((void **) &path, &psize),
+     GNUNET_SQ_result_spec_end};
 
   now = GNUNET_TIME_absolute_get ();
   LOG (GNUNET_ERROR_TYPE_DEBUG,
        "Processing GET for key `%s'\n",
        GNUNET_h2s (key));
 
-  if (GNUNET_OK !=
-      GNUNET_SQ_bind (plugin->get_count_stmt,
-                      params_count))
+  if (GNUNET_OK != GNUNET_SQ_bind (plugin->get_count_stmt, params_count))
   {
     LOG_SQLITE (plugin->dbh,
                 GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
                 "sqlite3_bind_xxx");
-    GNUNET_SQ_reset (plugin->dbh,
-                     plugin->get_count_stmt);
+    GNUNET_SQ_reset (plugin->dbh, plugin->get_count_stmt);
     return 0;
   }
-  if (SQLITE_ROW !=
-      sqlite3_step (plugin->get_count_stmt))
+  if (SQLITE_ROW != sqlite3_step (plugin->get_count_stmt))
   {
-    LOG_SQLITE (plugin->dbh, GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
+    LOG_SQLITE (plugin->dbh,
+                GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
                 "sqlite_step");
-    GNUNET_SQ_reset (plugin->dbh,
-                     plugin->get_count_stmt);
+    GNUNET_SQ_reset (plugin->dbh, plugin->get_count_stmt);
     LOG (GNUNET_ERROR_TYPE_DEBUG,
          "No content found when processing GET for key `%s'\n",
          GNUNET_h2s (key));
     return 0;
   }
-  total = sqlite3_column_int (plugin->get_count_stmt,
-                              0);
-  GNUNET_SQ_reset (plugin->dbh,
-                   plugin->get_count_stmt);
-  if ( (0 == total) ||
-       (NULL == iter) )
+  total = sqlite3_column_int (plugin->get_count_stmt, 0);
+  GNUNET_SQ_reset (plugin->dbh, plugin->get_count_stmt);
+  if ((0 == total) || (NULL == iter))
   {
     if (0 == total)
       LOG (GNUNET_ERROR_TYPE_DEBUG,
@@ -316,32 +323,24 @@ sqlite_plugin_get (void *cls,
   }
 
   cnt = 0;
-  off = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK,
-                                  total);
+  off = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, total);
   while (cnt < total)
   {
     off = (off + 1) % total;
-    if (GNUNET_OK !=
-        GNUNET_SQ_bind (plugin->get_stmt,
-                        params_select))
+    if (GNUNET_OK != GNUNET_SQ_bind (plugin->get_stmt, params_select))
     {
       LOG_SQLITE (plugin->dbh,
                   GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
                   "sqlite3_bind_xxx");
-      GNUNET_SQ_reset (plugin->dbh,
-                       plugin->get_stmt);
+      GNUNET_SQ_reset (plugin->dbh, plugin->get_stmt);
       return cnt;
     }
-    if (SQLITE_ROW !=
-        sqlite3_step (plugin->get_stmt))
+    if (SQLITE_ROW != sqlite3_step (plugin->get_stmt))
       break;
-    if (GNUNET_OK !=
-        GNUNET_SQ_extract_result (plugin->get_stmt,
-                                  rs))
+    if (GNUNET_OK != GNUNET_SQ_extract_result (plugin->get_stmt, rs))
     {
       GNUNET_break (0);
-      GNUNET_SQ_reset (plugin->dbh,
-                       plugin->get_stmt);
+      GNUNET_SQ_reset (plugin->dbh, plugin->get_stmt);
       break;
     }
     if (0 != psize % sizeof (struct GNUNET_PeerIdentity))
@@ -356,26 +355,16 @@ sqlite_plugin_get (void *cls,
          "Found %u-byte result when processing GET for key `%s'\n",
          (unsigned int) size,
          GNUNET_h2s (key));
-    if (GNUNET_OK != iter (iter_cls,
-                           key,
-                           size,
-                           dat,
-                           type,
-                           exp,
-                           psize,
-                           path))
+    if (GNUNET_OK != iter (iter_cls, key, size, dat, type, exp, psize, path))
     {
       GNUNET_SQ_cleanup_result (rs);
-      GNUNET_SQ_reset (plugin->dbh,
-                       plugin->get_stmt);
+      GNUNET_SQ_reset (plugin->dbh, plugin->get_stmt);
       break;
     }
     GNUNET_SQ_cleanup_result (rs);
-    GNUNET_SQ_reset (plugin->dbh,
-                     plugin->get_stmt);
+    GNUNET_SQ_reset (plugin->dbh, plugin->get_stmt);
   }
-  GNUNET_SQ_reset (plugin->dbh,
-                   plugin->get_stmt);
+  GNUNET_SQ_reset (plugin->dbh, plugin->get_stmt);
   return cnt;
 }
 
@@ -396,94 +385,66 @@ sqlite_plugin_del (void *cls)
   size_t dsize;
   struct GNUNET_HashCode hc;
   struct GNUNET_TIME_Absolute now;
-  struct GNUNET_SQ_ResultSpec rs[] = {
-    GNUNET_SQ_result_spec_uint64 (&rowid),
-    GNUNET_SQ_result_spec_auto_from_type (&hc),
-    GNUNET_SQ_result_spec_variable_size ((void **) &data,
-                                         &dsize),
-    GNUNET_SQ_result_spec_end
-  };
-  struct GNUNET_SQ_QueryParam params[] = {
-    GNUNET_SQ_query_param_uint64 (&rowid),
-    GNUNET_SQ_query_param_end
-  };
-  struct GNUNET_SQ_QueryParam time_params[] = {
-    GNUNET_SQ_query_param_absolute_time (&now),
-    GNUNET_SQ_query_param_end
-  };
-
-  LOG (GNUNET_ERROR_TYPE_DEBUG,
-       "Processing DEL\n");
+  struct GNUNET_SQ_ResultSpec rs[] =
+    {GNUNET_SQ_result_spec_uint64 (&rowid),
+     GNUNET_SQ_result_spec_auto_from_type (&hc),
+     GNUNET_SQ_result_spec_variable_size ((void **) &data, &dsize),
+     GNUNET_SQ_result_spec_end};
+  struct GNUNET_SQ_QueryParam params[] = {GNUNET_SQ_query_param_uint64 (&rowid),
+                                          GNUNET_SQ_query_param_end};
+  struct GNUNET_SQ_QueryParam time_params[] =
+    {GNUNET_SQ_query_param_absolute_time (&now), GNUNET_SQ_query_param_end};
+
+  LOG (GNUNET_ERROR_TYPE_DEBUG, "Processing DEL\n");
   now = GNUNET_TIME_absolute_get ();
-  if (GNUNET_OK !=
-      GNUNET_SQ_bind (plugin->del_expired_stmt,
-                      time_params))
+  if (GNUNET_OK != GNUNET_SQ_bind (plugin->del_expired_stmt, time_params))
   {
     LOG_SQLITE (plugin->dbh,
                 GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
                 "sqlite3_bind");
-    GNUNET_SQ_reset (plugin->dbh,
-                     plugin->del_expired_stmt);
+    GNUNET_SQ_reset (plugin->dbh, plugin->del_expired_stmt);
     return GNUNET_SYSERR;
   }
-  if ( (SQLITE_ROW !=
-        sqlite3_step (plugin->del_expired_stmt)) ||
-       (GNUNET_OK !=
-        GNUNET_SQ_extract_result (plugin->del_expired_stmt,
-                                  rs)) )
+  if ((SQLITE_ROW != sqlite3_step (plugin->del_expired_stmt)) ||
+      (GNUNET_OK != GNUNET_SQ_extract_result (plugin->del_expired_stmt, rs)))
   {
-    GNUNET_SQ_reset (plugin->dbh,
-                     plugin->del_expired_stmt);
-    if (SQLITE_ROW !=
-        sqlite3_step (plugin->del_select_stmt))
+    GNUNET_SQ_reset (plugin->dbh, plugin->del_expired_stmt);
+    if (SQLITE_ROW != sqlite3_step (plugin->del_select_stmt))
     {
       LOG_SQLITE (plugin->dbh,
                   GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
                   "sqlite3_step");
-      GNUNET_SQ_reset (plugin->dbh,
-                       plugin->del_select_stmt);
+      GNUNET_SQ_reset (plugin->dbh, plugin->del_select_stmt);
       return GNUNET_SYSERR;
     }
-    if (GNUNET_OK !=
-        GNUNET_SQ_extract_result (plugin->del_select_stmt,
-                                  rs))
+    if (GNUNET_OK != GNUNET_SQ_extract_result (plugin->del_select_stmt, rs))
     {
-      GNUNET_SQ_reset (plugin->dbh,
-                       plugin->del_select_stmt);
+      GNUNET_SQ_reset (plugin->dbh, plugin->del_select_stmt);
       GNUNET_break (0);
       return GNUNET_SYSERR;
     }
   }
   GNUNET_SQ_cleanup_result (rs);
-  GNUNET_SQ_reset (plugin->dbh,
-                   plugin->del_select_stmt);
-  if (GNUNET_OK !=
-      GNUNET_SQ_bind (plugin->del_stmt,
-                      params))
+  GNUNET_SQ_reset (plugin->dbh, plugin->del_select_stmt);
+  if (GNUNET_OK != GNUNET_SQ_bind (plugin->del_stmt, params))
   {
     LOG_SQLITE (plugin->dbh,
                 GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
                 "sqlite3_bind");
-    GNUNET_SQ_reset (plugin->dbh,
-                     plugin->del_stmt);
+    GNUNET_SQ_reset (plugin->dbh, plugin->del_stmt);
     return GNUNET_SYSERR;
   }
-  if (SQLITE_DONE !=
-      sqlite3_step (plugin->del_stmt))
+  if (SQLITE_DONE != sqlite3_step (plugin->del_stmt))
   {
     LOG_SQLITE (plugin->dbh,
                 GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
                 "sqlite3_step");
-    GNUNET_SQ_reset (plugin->dbh,
-                     plugin->del_stmt);
+    GNUNET_SQ_reset (plugin->dbh, plugin->del_stmt);
     return GNUNET_SYSERR;
   }
   plugin->num_items--;
-  plugin->env->delete_notify (plugin->env->cls,
-                              &hc,
-                              dsize + OVERHEAD);
-  GNUNET_SQ_reset (plugin->dbh,
-                   plugin->del_stmt);
+  plugin->env->delete_notify (plugin->env->cls, &hc, dsize + OVERHEAD);
+  GNUNET_SQ_reset (plugin->dbh, plugin->del_stmt);
   return GNUNET_OK;
 }
 
@@ -510,48 +471,36 @@ sqlite_plugin_get_random (void *cls,
   uint32_t type;
   struct GNUNET_PeerIdentity *path;
   struct GNUNET_HashCode key;
-  struct GNUNET_SQ_QueryParam params[] = {
-    GNUNET_SQ_query_param_uint32 (&off),
-    GNUNET_SQ_query_param_end
-  };
-  struct GNUNET_SQ_ResultSpec rs[] = {
-    GNUNET_SQ_result_spec_variable_size (&dat,
-                                         &size),
-    GNUNET_SQ_result_spec_absolute_time (&exp),
-    GNUNET_SQ_result_spec_variable_size ((void **) &path,
-                                         &psize),
-    GNUNET_SQ_result_spec_auto_from_type (&key),
-    GNUNET_SQ_result_spec_uint32 (&type),
-    GNUNET_SQ_result_spec_end
-  };
+  struct GNUNET_SQ_QueryParam params[] = {GNUNET_SQ_query_param_uint32 (&off),
+                                          GNUNET_SQ_query_param_end};
+  struct GNUNET_SQ_ResultSpec rs[] =
+    {GNUNET_SQ_result_spec_variable_size (&dat, &size),
+     GNUNET_SQ_result_spec_absolute_time (&exp),
+     GNUNET_SQ_result_spec_variable_size ((void **) &path, &psize),
+     GNUNET_SQ_result_spec_auto_from_type (&key),
+     GNUNET_SQ_result_spec_uint32 (&type),
+     GNUNET_SQ_result_spec_end};
 
   if (0 == plugin->num_items)
     return 0;
   if (NULL == iter)
     return 1;
-  off = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_NONCE,
-                                  plugin->num_items);
-  if (GNUNET_OK !=
-      GNUNET_SQ_bind (plugin->get_random_stmt,
-                      params))
+  off =
+    GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_NONCE, plugin->num_items);
+  if (GNUNET_OK != GNUNET_SQ_bind (plugin->get_random_stmt, params))
   {
     return 0;
   }
-  if (SQLITE_ROW !=
-      sqlite3_step (plugin->get_random_stmt))
+  if (SQLITE_ROW != sqlite3_step (plugin->get_random_stmt))
   {
     GNUNET_break (0);
-    GNUNET_SQ_reset (plugin->dbh,
-                     plugin->get_random_stmt);
+    GNUNET_SQ_reset (plugin->dbh, plugin->get_random_stmt);
     return 0;
   }
-  if (GNUNET_OK !=
-      GNUNET_SQ_extract_result (plugin->get_random_stmt,
-                                rs))
+  if (GNUNET_OK != GNUNET_SQ_extract_result (plugin->get_random_stmt, rs))
   {
     GNUNET_break (0);
-    GNUNET_SQ_reset (plugin->dbh,
-                     plugin->get_random_stmt);
+    GNUNET_SQ_reset (plugin->dbh, plugin->get_random_stmt);
     return 0;
   }
   if (0 != psize % sizeof (struct GNUNET_PeerIdentity))
@@ -574,8 +523,7 @@ sqlite_plugin_get_random (void *cls,
                psize,
                path);
   GNUNET_SQ_cleanup_result (rs);
-  GNUNET_SQ_reset (plugin->dbh,
-                   plugin->get_random_stmt);
+  GNUNET_SQ_reset (plugin->dbh, plugin->get_random_stmt);
   return 1;
 }
 
@@ -611,45 +559,35 @@ sqlite_plugin_get_closest (void *cls,
   uint32_t type;
   struct GNUNET_HashCode hc;
   struct GNUNET_PeerIdentity *path;
-  struct GNUNET_SQ_QueryParam params[] = {
-    GNUNET_SQ_query_param_auto_from_type (key),
-    GNUNET_SQ_query_param_absolute_time (&now),
-    GNUNET_SQ_query_param_uint32 (&num_results32),
-    GNUNET_SQ_query_param_end
-  };
-  struct GNUNET_SQ_ResultSpec rs[] = {
-    GNUNET_SQ_result_spec_variable_size (&dat,
-                                         &size),
-    GNUNET_SQ_result_spec_absolute_time (&exp),
-    GNUNET_SQ_result_spec_variable_size ((void **) &path,
-                                         &psize),
-    GNUNET_SQ_result_spec_uint32 (&type),
-    GNUNET_SQ_result_spec_auto_from_type (&hc),
-    GNUNET_SQ_result_spec_end
-  };
+  struct GNUNET_SQ_QueryParam params[] =
+    {GNUNET_SQ_query_param_auto_from_type (key),
+     GNUNET_SQ_query_param_absolute_time (&now),
+     GNUNET_SQ_query_param_uint32 (&num_results32),
+     GNUNET_SQ_query_param_end};
+  struct GNUNET_SQ_ResultSpec rs[] =
+    {GNUNET_SQ_result_spec_variable_size (&dat, &size),
+     GNUNET_SQ_result_spec_absolute_time (&exp),
+     GNUNET_SQ_result_spec_variable_size ((void **) &path, &psize),
+     GNUNET_SQ_result_spec_uint32 (&type),
+     GNUNET_SQ_result_spec_auto_from_type (&hc),
+     GNUNET_SQ_result_spec_end};
 
   now = GNUNET_TIME_absolute_get ();
   LOG (GNUNET_ERROR_TYPE_DEBUG,
        "Processing GET_CLOSEST for key `%s'\n",
        GNUNET_h2s (key));
-  if (GNUNET_OK !=
-      GNUNET_SQ_bind (plugin->get_closest_stmt,
-                      params))
+  if (GNUNET_OK != GNUNET_SQ_bind (plugin->get_closest_stmt, params))
   {
     LOG_SQLITE (plugin->dbh,
                 GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
                 "sqlite3_bind_xxx");
-    GNUNET_SQ_reset (plugin->dbh,
-                     plugin->get_closest_stmt);
+    GNUNET_SQ_reset (plugin->dbh, plugin->get_closest_stmt);
     return 0;
   }
   cnt = 0;
-  while (SQLITE_ROW ==
-         sqlite3_step (plugin->get_closest_stmt))
+  while (SQLITE_ROW == sqlite3_step (plugin->get_closest_stmt))
   {
-    if (GNUNET_OK !=
-        GNUNET_SQ_extract_result (plugin->get_closest_stmt,
-                                  rs))
+    if (GNUNET_OK != GNUNET_SQ_extract_result (plugin->get_closest_stmt, rs))
     {
       GNUNET_break (0);
       break;
@@ -666,22 +604,14 @@ sqlite_plugin_get_closest (void *cls,
          "Found %u-byte result at %s when processing GET_CLOSE\n",
          (unsigned int) size,
          GNUNET_h2s (&hc));
-    if (GNUNET_OK != iter (iter_cls,
-                           &hc,
-                           size,
-                           dat,
-                           type,
-                           exp,
-                           psize,
-                           path))
+    if (GNUNET_OK != iter (iter_cls, &hc, size, dat, type, exp, psize, path))
     {
       GNUNET_SQ_cleanup_result (rs);
       break;
     }
     GNUNET_SQ_cleanup_result (rs);
   }
-  GNUNET_SQ_reset (plugin->dbh,
-                   plugin->get_closest_stmt);
+  GNUNET_SQ_reset (plugin->dbh, plugin->get_closest_stmt);
   return cnt;
 }
 
@@ -703,10 +633,9 @@ libgnunet_plugin_datacache_sqlite_init (void *cls)
   sqlite3 *dbh;
   char *emsg;
 
-  if (GNUNET_YES ==
-      GNUNET_CONFIGURATION_get_value_yesno (env->cfg,
-                                            "datacache-sqlite",
-                                            "IN_MEMORY"))
+  if (GNUNET_YES == GNUNET_CONFIGURATION_get_value_yesno (env->cfg,
+                                                          "datacache-sqlite",
+                                                          "IN_MEMORY"))
   {
     if (SQLITE_OK != sqlite3_open (":memory:", &dbh))
       return NULL;
@@ -716,10 +645,10 @@ libgnunet_plugin_datacache_sqlite_init (void *cls)
   {
     fn = GNUNET_DISK_mktemp ("gnunet-datacache");
     if (fn == NULL)
-      {
-        GNUNET_break (0);
-        return NULL;
-      }
+    {
+      GNUNET_break (0);
+      return NULL;
+    }
     /* fn should be UTF-8-encoded. If it isn't, it's a bug. */
     fn_utf8 = GNUNET_strdup (fn);
     if (SQLITE_OK != sqlite3_open (fn_utf8, &dbh))
@@ -736,10 +665,9 @@ libgnunet_plugin_datacache_sqlite_init (void *cls)
   SQLITE3_EXEC (dbh, "PRAGMA journal_mode=OFF");
   SQLITE3_EXEC (dbh, "PRAGMA synchronous=OFF");
   SQLITE3_EXEC (dbh, "PRAGMA page_size=4092");
-  if (GNUNET_YES ==
-      GNUNET_CONFIGURATION_get_value_yesno (env->cfg,
-                                            "datacache-sqlite",
-                                            "IN_MEMORY"))
+  if (GNUNET_YES == GNUNET_CONFIGURATION_get_value_yesno (env->cfg,
+                                                          "datacache-sqlite",
+                                                          "IN_MEMORY"))
     SQLITE3_EXEC (dbh, "PRAGMA sqlite_temp_store=3");
 
   SQLITE3_EXEC (dbh,
@@ -749,7 +677,7 @@ libgnunet_plugin_datacache_sqlite_init (void *cls)
                 "  key BLOB NOT NULL DEFAULT '',"
                 "  prox INTEGER NOT NULL,"
                 "  value BLOB NOT NULL,"
-                "  path BLOB DEFAULT '')");
+                "  path BLOB DEFAULT '')");
   SQLITE3_EXEC (dbh, "CREATE INDEX idx_hashidx ON ds091 (key,type,expire)");
   SQLITE3_EXEC (dbh, "CREATE INDEX idx_prox_expire ON ds091 (prox,expire)");
   SQLITE3_EXEC (dbh, "CREATE INDEX idx_expire_only ON ds091 (expire)");
@@ -758,53 +686,46 @@ libgnunet_plugin_datacache_sqlite_init (void *cls)
   plugin->dbh = dbh;
   plugin->fn = fn_utf8;
 
-  if ( (SQLITE_OK !=
-        sq_prepare (plugin->dbh,
-                    "INSERT INTO ds091 (type, expire, key, prox, value, path) "
-                    "VALUES (?, ?, ?, ?, ?, ?)",
-                    &plugin->insert_stmt)) ||
-       (SQLITE_OK !=
-        sq_prepare (plugin->dbh,
-                    "SELECT count(*) FROM ds091 "
-                    "WHERE key=? AND type=? AND expire >= ?",
-                    &plugin->get_count_stmt)) ||
-       (SQLITE_OK !=
-        sq_prepare (plugin->dbh,
-                    "SELECT value,expire,path FROM ds091"
-                    " WHERE key=? AND type=? AND expire >= ? LIMIT 1 OFFSET ?",
-                    &plugin->get_stmt)) ||
-       (SQLITE_OK !=
-        sq_prepare (plugin->dbh,
-                    "SELECT _ROWID_,key,value FROM ds091"
-                    " WHERE expire < ?"
-                    " ORDER BY expire ASC LIMIT 1",
-                    &plugin->del_expired_stmt)) ||
-       (SQLITE_OK !=
-        sq_prepare (plugin->dbh,
-                    "SELECT _ROWID_,key,value FROM ds091"
-                    " ORDER BY prox ASC, expire ASC LIMIT 1",
-                    &plugin->del_select_stmt)) ||
-       (SQLITE_OK !=
-        sq_prepare (plugin->dbh,
-                    "DELETE FROM ds091 WHERE _ROWID_=?",
-                    &plugin->del_stmt)) ||
-       (SQLITE_OK !=
-        sq_prepare (plugin->dbh,
-                    "SELECT value,expire,path,key,type FROM ds091 "
-                    "ORDER BY key LIMIT 1 OFFSET ?",
-                    &plugin->get_random_stmt)) ||
-       (SQLITE_OK !=
-        sq_prepare (plugin->dbh,
-                    "SELECT value,expire,path,type,key FROM ds091 "
-                    "WHERE key>=? AND expire >= ? ORDER BY KEY ASC LIMIT ?",
-                    &plugin->get_closest_stmt))
-       )
+  if ((SQLITE_OK !=
+       sq_prepare (plugin->dbh,
+                   "INSERT INTO ds091 (type, expire, key, prox, value, path) "
+                   "VALUES (?, ?, ?, ?, ?, ?)",
+                   &plugin->insert_stmt)) ||
+      (SQLITE_OK != sq_prepare (plugin->dbh,
+                                "SELECT count(*) FROM ds091 "
+                                "WHERE key=? AND type=? AND expire >= ?",
+                                &plugin->get_count_stmt)) ||
+      (SQLITE_OK !=
+       sq_prepare (plugin->dbh,
+                   "SELECT value,expire,path FROM ds091"
+                   " WHERE key=? AND type=? AND expire >= ? LIMIT 1 OFFSET ?",
+                   &plugin->get_stmt)) ||
+      (SQLITE_OK != sq_prepare (plugin->dbh,
+                                "SELECT _ROWID_,key,value FROM ds091"
+                                " WHERE expire < ?"
+                                " ORDER BY expire ASC LIMIT 1",
+                                &plugin->del_expired_stmt)) ||
+      (SQLITE_OK != sq_prepare (plugin->dbh,
+                                "SELECT _ROWID_,key,value FROM ds091"
+                                " ORDER BY prox ASC, expire ASC LIMIT 1",
+                                &plugin->del_select_stmt)) ||
+      (SQLITE_OK != sq_prepare (plugin->dbh,
+                                "DELETE FROM ds091 WHERE _ROWID_=?",
+                                &plugin->del_stmt)) ||
+      (SQLITE_OK != sq_prepare (plugin->dbh,
+                                "SELECT value,expire,path,key,type FROM ds091 "
+                                "ORDER BY key LIMIT 1 OFFSET ?",
+                                &plugin->get_random_stmt)) ||
+      (SQLITE_OK !=
+       sq_prepare (plugin->dbh,
+                   "SELECT value,expire,path,type,key FROM ds091 "
+                   "WHERE key>=? AND expire >= ? ORDER BY KEY ASC LIMIT ?",
+                   &plugin->get_closest_stmt)))
   {
     LOG_SQLITE (plugin->dbh,
                 GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
                 "sq_prepare");
-    GNUNET_break (SQLITE_OK ==
-                  sqlite3_close (plugin->dbh));
+    GNUNET_break (SQLITE_OK == sqlite3_close (plugin->dbh));
     GNUNET_free (plugin);
     return NULL;
   }
@@ -816,8 +737,7 @@ libgnunet_plugin_datacache_sqlite_init (void *cls)
   api->del = &sqlite_plugin_del;
   api->get_random = &sqlite_plugin_get_random;
   api->get_closest = &sqlite_plugin_get_closest;
-  LOG (GNUNET_ERROR_TYPE_INFO,
-       "Sqlite datacache running\n");
+  LOG (GNUNET_ERROR_TYPE_INFO, "Sqlite datacache running\n");
   return api;
 }
 
@@ -839,12 +759,9 @@ libgnunet_plugin_datacache_sqlite_done (void *cls)
   sqlite3_stmt *stmt;
 #endif
 
-#if !WINDOWS || defined(__CYGWIN__)
-  if ( (NULL != plugin->fn) &&
-       (0 != UNLINK (plugin->fn)) )
-    LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_WARNING,
-                       "unlink",
-                       plugin->fn);
+#if ! WINDOWS || defined(__CYGWIN__)
+  if ((NULL != plugin->fn) && (0 != unlink (plugin->fn)))
+    LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_WARNING, "unlink", plugin->fn);
   GNUNET_free_non_null (plugin->fn);
 #endif
   sqlite3_finalize (plugin->insert_stmt);
@@ -860,7 +777,8 @@ libgnunet_plugin_datacache_sqlite_done (void *cls)
   if (SQLITE_BUSY == result)
   {
     LOG (GNUNET_ERROR_TYPE_WARNING,
-         _("Tried to close sqlite without finalizing all prepared statements.\n"));
+         _ (
+           "Tried to close sqlite without finalizing all prepared statements.\n"));
     stmt = sqlite3_next_stmt (plugin->dbh, NULL);
     while (NULL != stmt)
     {
@@ -876,16 +794,11 @@ libgnunet_plugin_datacache_sqlite_done (void *cls)
   }
 #endif
   if (SQLITE_OK != result)
-    LOG_SQLITE (plugin->dbh,
-                GNUNET_ERROR_TYPE_ERROR,
-                "sqlite3_close");
-
-#if WINDOWS && !defined(__CYGWIN__)
-  if ( (NULL != plugin->fn) &&
-       (0 != UNLINK (plugin->fn)) )
-    LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_WARNING,
-                       "unlink",
-                       plugin->fn);
+    LOG_SQLITE (plugin->dbh, GNUNET_ERROR_TYPE_ERROR, "sqlite3_close");
+
+#if WINDOWS && ! defined(__CYGWIN__)
+  if ((NULL != plugin->fn) && (0 != unlink (plugin->fn)))
+    LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_WARNING, "unlink", plugin->fn);
   GNUNET_free_non_null (plugin->fn);
 #endif
   GNUNET_free (plugin);
@@ -894,5 +807,4 @@ libgnunet_plugin_datacache_sqlite_done (void *cls)
 }
 
 
-
 /* end of plugin_datacache_sqlite.c */
diff --git a/src/datacache/test_datacache.c b/src/datacache/test_datacache.c
index d62a31c27..572a775df 100644
--- a/src/datacache/test_datacache.c
+++ b/src/datacache/test_datacache.c
@@ -84,7 +84,7 @@ run (void *cls,
                                "testcache");
   if (h == NULL)
   {
-    FPRINTF (stderr,
+    fprintf (stderr,
              "%s",
              "Failed to initialize datacache.  Database likely not setup, skipping test.\n");
     ok = 77; /* mark test as skipped */
@@ -183,7 +183,7 @@ main (int argc, char *argv[])
                       &run,
                       NULL);
   if ( (0 != ok) && (77 != ok) )
-    FPRINTF (stderr,
+    fprintf (stderr,
              "Missed some testcases: %d\n",
              ok);
   return ok;
diff --git a/src/datacache/test_datacache_quota.c b/src/datacache/test_datacache_quota.c
index 7c4e56ea5..0201df3b3 100644
--- a/src/datacache/test_datacache_quota.c
+++ b/src/datacache/test_datacache_quota.c
@@ -63,7 +63,7 @@ run (void *cls,
 
   if (h == NULL)
   {
-    FPRINTF (stderr,
+    fprintf (stderr,
              "%s",
              "Failed to initialize datacache.  Database likely not setup, skipping test.\n");
     return;
@@ -73,7 +73,7 @@ run (void *cls,
   memset (&k, 0, sizeof (struct GNUNET_HashCode));
   for (unsigned int i = 0; i < 10; i++)
   {
-    FPRINTF (stderr,
+    fprintf (stderr,
              "%s",
              ".");
     GNUNET_CRYPTO_hash (&k,
@@ -97,11 +97,11 @@ run (void *cls,
     }
     k = n;
   }
-  FPRINTF (stderr, "%s",  "\n");
+  fprintf (stderr, "%s",  "\n");
   memset (&k, 0, sizeof (struct GNUNET_HashCode));
   for (unsigned int i = 0; i < 10; i++)
   {
-    FPRINTF (stderr, "%s",  ".");
+    fprintf (stderr, "%s",  ".");
     GNUNET_CRYPTO_hash (&k, sizeof (struct GNUNET_HashCode), &n);
     if (i < 2)
       ASSERT (0 == GNUNET_DATACACHE_get (h, &k, 1 + i, NULL, NULL));
@@ -109,7 +109,7 @@ run (void *cls,
       ASSERT (0 < GNUNET_DATACACHE_get (h, &k, 1 + i, NULL, NULL));
     k = n;
   }
-  FPRINTF (stderr, "%s",  "\n");
+  fprintf (stderr, "%s",  "\n");
   GNUNET_DATACACHE_destroy (h);
   return;
 FAILURE:
@@ -152,7 +152,7 @@ main (int argc,
                       &run,
                       NULL);
   if (0 != ok)
-    FPRINTF (stderr,
+    fprintf (stderr,
              "Missed some testcases: %d\n",
              ok);
   return ok;