1 files changed, 517 insertions, 555 deletions

diff --git a/src/datastore/plugin_datastore_sqlite.c b/src/datastore/plugin_datastore_sqlite.c
index f551f048d..075d31623 100644
--- a/src/datastore/plugin_datastore_sqlite.c
+++ b/src/datastore/plugin_datastore_sqlite.c
@@ -1,22 +1,22 @@
  /*
-     This file is part of GNUnet
-     (C) 2009, 2011 Christian Grothoff (and other contributing authors)
-
-     GNUnet is free software; you can redistribute it and/or modify
-     it under the terms of the GNU General Public License as published
-     by the Free Software Foundation; either version 3, or (at your
-     option) any later version.
-
-     GNUnet is distributed in the hope that it will be useful, but
-     WITHOUT ANY WARRANTY; without even the implied warranty of
-     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-     General Public License for more details.
-
-     You should have received a copy of the GNU General Public License
-     along with GNUnet; see the file COPYING.  If not, write to the
-     Free Software Foundation, Inc., 59 Temple Place - Suite 330,
-     Boston, MA 02111-1307, USA.
-*/
+  * This file is part of GNUnet
+  * (C) 2009, 2011 Christian Grothoff (and other contributing authors)
+  * 
+  * GNUnet is free software; you can redistribute it and/or modify
+  * it under the terms of the GNU General Public License as published
+  * by the Free Software Foundation; either version 3, or (at your
+  * option) any later version.
+  * 
+  * GNUnet is distributed in the hope that it will be useful, but
+  * WITHOUT ANY WARRANTY; without even the implied warranty of
+  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  * General Public License for more details.
+  * 
+  * You should have received a copy of the GNU General Public License
+  * along with GNUnet; see the file COPYING.  If not, write to the
+  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+  * Boston, MA 02111-1307, USA.
+  */
 
 /**
  * @file datastore/plugin_datastore_sqlite.c
@@ -65,7 +65,7 @@
 /**
  * Context for all functions in this plugin.
  */
-struct Plugin 
+struct Plugin
 {
   /**
    * Our execution environment.
@@ -139,25 +139,17 @@ struct Plugin
  * @return 0 on success
  */
 static int
-sq_prepare (sqlite3 * dbh, 
-            const char *zSql,
-            sqlite3_stmt ** ppStmt)
+sq_prepare (sqlite3 * dbh, const char *zSql, sqlite3_stmt ** ppStmt)
 {
   char *dummy;
   int result;
 
   result = sqlite3_prepare_v2 (dbh,
-                               zSql,
-                               strlen (zSql), 
-                               ppStmt,
-                               (const char **) &dummy);
+                               zSql,
+                               strlen (zSql), ppStmt, (const char **) &dummy);
 #if DEBUG_SQLITE && 0
   GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG,
-                   "sqlite",
-                   "Prepared `%s' / %p: %d\n",
-                   zSql,
-                   *ppStmt, 
-                   result);
+                   "sqlite", "Prepared `%s' / %p: %d\n", zSql, *ppStmt, result);
 #endif
   return result;
 }
@@ -172,35 +164,40 @@ static void
 create_indices (sqlite3 * dbh)
 {
   /* create indices */
-  if ( (SQLITE_OK !=
-        sqlite3_exec (dbh,
-                      "CREATE INDEX IF NOT EXISTS idx_hash ON gn090 (hash)", NULL, NULL, NULL)) ||
-       (SQLITE_OK !=
-        sqlite3_exec (dbh,
-                      "CREATE INDEX IF NOT EXISTS idx_hash_vhash ON gn090 (hash,vhash)", NULL,
-                      NULL, NULL)) ||
-       (SQLITE_OK !=
-        sqlite3_exec (dbh, "CREATE INDEX IF NOT EXISTS idx_expire_repl ON gn090 (expire ASC,repl DESC)", NULL, NULL,
-                      NULL)) ||
-       (SQLITE_OK != 
-        sqlite3_exec (dbh, "CREATE INDEX IF NOT EXISTS idx_comb ON gn090 (anonLevel ASC,expire ASC,prio,type,hash)",
-                      NULL, NULL, NULL)) ||
-       (SQLITE_OK != 
-        sqlite3_exec (dbh, "CREATE INDEX IF NOT EXISTS idx_anon_type_hash ON gn090 (anonLevel ASC,type,hash)",
-                      NULL, NULL, NULL)) ||
-       (SQLITE_OK != 
-        sqlite3_exec (dbh, "CREATE INDEX IF NOT EXISTS idx_expire ON gn090 (expire ASC)",
-                      NULL, NULL, NULL)) ||
-       (SQLITE_OK !=
-        sqlite3_exec (dbh, "CREATE INDEX IF NOT EXISTS idx_repl_rvalue ON gn090 (repl,rvalue)",
-                      NULL, NULL, NULL)) ||
-       (SQLITE_OK !=
-        sqlite3_exec (dbh, "CREATE INDEX IF NOT EXISTS idx_repl ON gn090 (repl DESC)",
-                      NULL, NULL, NULL)) )
-    GNUNET_log_from (GNUNET_ERROR_TYPE_ERROR,
-                     "sqlite",
-                     "Failed to create indices: %s\n",
-                     sqlite3_errmsg (dbh));
+  if ((SQLITE_OK !=
+       sqlite3_exec (dbh,
+                     "CREATE INDEX IF NOT EXISTS idx_hash ON gn090 (hash)",
+                     NULL, NULL, NULL)) ||
+      (SQLITE_OK !=
+       sqlite3_exec (dbh,
+                     "CREATE INDEX IF NOT EXISTS idx_hash_vhash ON gn090 (hash,vhash)",
+                     NULL, NULL, NULL)) ||
+      (SQLITE_OK !=
+       sqlite3_exec (dbh,
+                     "CREATE INDEX IF NOT EXISTS idx_expire_repl ON gn090 (expire ASC,repl DESC)",
+                     NULL, NULL, NULL)) ||
+      (SQLITE_OK !=
+       sqlite3_exec (dbh,
+                     "CREATE INDEX IF NOT EXISTS idx_comb ON gn090 (anonLevel ASC,expire ASC,prio,type,hash)",
+                     NULL, NULL, NULL)) ||
+      (SQLITE_OK !=
+       sqlite3_exec (dbh,
+                     "CREATE INDEX IF NOT EXISTS idx_anon_type_hash ON gn090 (anonLevel ASC,type,hash)",
+                     NULL, NULL, NULL)) ||
+      (SQLITE_OK !=
+       sqlite3_exec (dbh,
+                     "CREATE INDEX IF NOT EXISTS idx_expire ON gn090 (expire ASC)",
+                     NULL, NULL, NULL)) ||
+      (SQLITE_OK !=
+       sqlite3_exec (dbh,
+                     "CREATE INDEX IF NOT EXISTS idx_repl_rvalue ON gn090 (repl,rvalue)",
+                     NULL, NULL, NULL)) ||
+      (SQLITE_OK !=
+       sqlite3_exec (dbh,
+                     "CREATE INDEX IF NOT EXISTS idx_repl ON gn090 (repl DESC)",
+                     NULL, NULL, NULL)))
+    GNUNET_log_from (GNUNET_ERROR_TYPE_ERROR, "sqlite",
+                     "Failed to create indices: %s\n", sqlite3_errmsg (dbh));
 }
 
 
@@ -225,56 +222,55 @@ create_indices (sqlite3 * dbh)
  */
 static int
 database_setup (const struct GNUNET_CONFIGURATION_Handle *cfg,
-                struct Plugin *plugin)
+                struct Plugin *plugin)
 {
   sqlite3_stmt *stmt;
   char *afsdir;
+
 #if ENULL_DEFINED
   char *e;
 #endif
-  
-  if (GNUNET_OK != 
+
+  if (GNUNET_OK !=
       GNUNET_CONFIGURATION_get_value_filename (cfg,
-                                               "datastore-sqlite",
-                                               "FILENAME",
-                                               &afsdir))
-    {
-      GNUNET_log_from (GNUNET_ERROR_TYPE_ERROR,
-                       "sqlite",
-                       _("Option `%s' in section `%s' missing in configuration!\n"),
-                       "FILENAME",
-                       "datastore-sqlite");
-      return GNUNET_SYSERR;
-    }
+                                               "datastore-sqlite",
+                                               "FILENAME", &afsdir))
+  {
+    GNUNET_log_from (GNUNET_ERROR_TYPE_ERROR,
+                     "sqlite",
+                     _
+                     ("Option `%s' in section `%s' missing in configuration!\n"),
+                     "FILENAME", "datastore-sqlite");
+    return GNUNET_SYSERR;
+  }
   if (GNUNET_OK != GNUNET_DISK_file_test (afsdir))
+  {
+    if (GNUNET_OK != GNUNET_DISK_directory_create_for_file (afsdir))
     {
-      if (GNUNET_OK != GNUNET_DISK_directory_create_for_file (afsdir))
-        {
-          GNUNET_break (0);
-          GNUNET_free (afsdir);
-          return GNUNET_SYSERR;
-        }
-      /* database is new or got deleted, reset payload to zero! */
-      plugin->env->duc (plugin->env->cls, 0);
+      GNUNET_break (0);
+      GNUNET_free (afsdir);
+      return GNUNET_SYSERR;
     }
+    /* database is new or got deleted, reset payload to zero! */
+    plugin->env->duc (plugin->env->cls, 0);
+  }
 #ifdef ENABLE_NLS
   plugin->fn = GNUNET_STRINGS_to_utf8 (afsdir, strlen (afsdir),
-                                       nl_langinfo (CODESET));
+                                       nl_langinfo (CODESET));
 #else
-  plugin->fn = GNUNET_STRINGS_to_utf8 (afsdir, strlen (afsdir),
-                                       "UTF-8");   /* good luck */
+  plugin->fn = GNUNET_STRINGS_to_utf8 (afsdir, strlen (afsdir), "UTF-8");       /* good luck */
 #endif
   GNUNET_free (afsdir);
-  
+
   /* Open database and precompile statements */
   if (sqlite3_open (plugin->fn, &plugin->dbh) != SQLITE_OK)
-    {
-      GNUNET_log_from (GNUNET_ERROR_TYPE_ERROR,
-                       "sqlite",
-                       _("Unable to initialize SQLite: %s.\n"),
-                       sqlite3_errmsg (plugin->dbh));
-      return GNUNET_SYSERR;
-    }
+  {
+    GNUNET_log_from (GNUNET_ERROR_TYPE_ERROR,
+                     "sqlite",
+                     _("Unable to initialize SQLite: %s.\n"),
+                     sqlite3_errmsg (plugin->dbh));
+    return GNUNET_SYSERR;
+  }
   CHECK (SQLITE_OK ==
          sqlite3_exec (plugin->dbh,
                        "PRAGMA temp_store=MEMORY", NULL, NULL, ENULL));
@@ -294,8 +290,8 @@ database_setup (const struct GNUNET_CONFIGURATION_Handle *cfg,
          sqlite3_exec (plugin->dbh,
                        "PRAGMA count_changes=OFF", NULL, NULL, ENULL));
   CHECK (SQLITE_OK ==
-         sqlite3_exec (plugin->dbh, 
-                       "PRAGMA page_size=4092", NULL, NULL, ENULL));
+         sqlite3_exec (plugin->dbh,
+                       "PRAGMA page_size=4092", NULL, NULL, ENULL));
 
   CHECK (SQLITE_OK == sqlite3_busy_timeout (plugin->dbh, BUSY_TIMEOUT_MS));
 
@@ -305,62 +301,60 @@ database_setup (const struct GNUNET_CONFIGURATION_Handle *cfg,
          sq_prepare (plugin->dbh,
                      "SELECT 1 FROM sqlite_master WHERE tbl_name = 'gn090'",
                      &stmt));
-  if ( (sqlite3_step (stmt) == SQLITE_DONE) &&
-       (sqlite3_exec (plugin->dbh,
-                      "CREATE TABLE gn090 ("
-                      "  repl INT4 NOT NULL DEFAULT 0,"
-                      "  type INT4 NOT NULL DEFAULT 0,"
-                      "  prio INT4 NOT NULL DEFAULT 0,"
-                      "  anonLevel INT4 NOT NULL DEFAULT 0,"
-                      "  expire INT8 NOT NULL DEFAULT 0,"
-                      "  rvalue INT8 NOT NULL,"
-                      "  hash TEXT NOT NULL DEFAULT '',"
-                      "  vhash TEXT NOT NULL DEFAULT '',"
-                      "  value BLOB NOT NULL DEFAULT '')", NULL, NULL,
-                      NULL) != SQLITE_OK) )
-    {
-      LOG_SQLITE (plugin, NULL,
-                  GNUNET_ERROR_TYPE_ERROR, 
-                  "sqlite3_exec");
-      sqlite3_finalize (stmt);
-      return GNUNET_SYSERR;
-    }
+  if ((sqlite3_step (stmt) == SQLITE_DONE) &&
+      (sqlite3_exec (plugin->dbh,
+                     "CREATE TABLE gn090 ("
+                     "  repl INT4 NOT NULL DEFAULT 0,"
+                     "  type INT4 NOT NULL DEFAULT 0,"
+                     "  prio INT4 NOT NULL DEFAULT 0,"
+                     "  anonLevel INT4 NOT NULL DEFAULT 0,"
+                     "  expire INT8 NOT NULL DEFAULT 0,"
+                     "  rvalue INT8 NOT NULL,"
+                     "  hash TEXT NOT NULL DEFAULT '',"
+                     "  vhash TEXT NOT NULL DEFAULT '',"
+                     "  value BLOB NOT NULL DEFAULT '')", NULL, NULL,
+                     NULL) != SQLITE_OK))
+  {
+    LOG_SQLITE (plugin, NULL, GNUNET_ERROR_TYPE_ERROR, "sqlite3_exec");
+    sqlite3_finalize (stmt);
+    return GNUNET_SYSERR;
+  }
   sqlite3_finalize (stmt);
   create_indices (plugin->dbh);
 
   if ((sq_prepare (plugin->dbh,
                    "UPDATE gn090 "
-                   "SET prio = prio + ?, expire = MAX(expire,?) WHERE _ROWID_ = ?",
+                   "SET prio = prio + ?, expire = MAX(expire,?) WHERE _ROWID_ = ?",
                    &plugin->updPrio) != SQLITE_OK) ||
       (sq_prepare (plugin->dbh,
                    "UPDATE gn090 "
-                   "SET repl = MAX (0, repl - 1) WHERE _ROWID_ = ?",
+                   "SET repl = MAX (0, repl - 1) WHERE _ROWID_ = ?",
                    &plugin->updRepl) != SQLITE_OK) ||
       (sq_prepare (plugin->dbh,
-                   "SELECT type,prio,anonLevel,expire,hash,value,_ROWID_ "
-                   "FROM gn090 INDEXED BY idx_repl_rvalue "
-                   "WHERE repl=?2 AND"
-                   "      (rvalue>=?1 OR"
-                   "        NOT EXISTS (SELECT 1 FROM gn090 INDEXED BY idx_repl_rvalue WHERE repl=?2 AND rvalue>=?1 LIMIT 1))"
-                   "     ORDER BY rvalue ASC"
-                   "     LIMIT 1",
+                   "SELECT type,prio,anonLevel,expire,hash,value,_ROWID_ "
+                   "FROM gn090 INDEXED BY idx_repl_rvalue "
+                   "WHERE repl=?2 AND"
+                   "      (rvalue>=?1 OR"
+                   "        NOT EXISTS (SELECT 1 FROM gn090 INDEXED BY idx_repl_rvalue WHERE repl=?2 AND rvalue>=?1 LIMIT 1))"
+                   "     ORDER BY rvalue ASC"
+                   "     LIMIT 1",
                    &plugin->selRepl) != SQLITE_OK) ||
       (sq_prepare (plugin->dbh,
-                   "SELECT MAX(repl) "
-                   "FROM gn090 INDEXED BY idx_repl_rvalue",
+                   "SELECT MAX(repl) "
+                   "FROM gn090 INDEXED BY idx_repl_rvalue",
                    &plugin->maxRepl) != SQLITE_OK) ||
       (sq_prepare (plugin->dbh,
-                   "SELECT type,prio,anonLevel,expire,hash,value,_ROWID_ "
-                   "FROM gn090 INDEXED BY idx_expire"
-                   " WHERE NOT EXISTS (SELECT 1 FROM gn090 WHERE expire < ?1 LIMIT 1) OR (expire < ?1) "
-                   " ORDER BY expire ASC LIMIT 1",
+                   "SELECT type,prio,anonLevel,expire,hash,value,_ROWID_ "
+                   "FROM gn090 INDEXED BY idx_expire"
+                   " WHERE NOT EXISTS (SELECT 1 FROM gn090 WHERE expire < ?1 LIMIT 1) OR (expire < ?1) "
+                   " ORDER BY expire ASC LIMIT 1",
                    &plugin->selExpi) != SQLITE_OK) ||
-      (sq_prepare (plugin->dbh, 
-                   "SELECT type,prio,anonLevel,expire,hash,value,_ROWID_ "
-                   "FROM gn090 INDEXED BY idx_anon_type_hash "
-                   "WHERE (anonLevel = 0 AND type=?1) "
-                   "ORDER BY hash DESC LIMIT 1 OFFSET ?2",
-                   &plugin->selZeroAnon) != SQLITE_OK) ||
+      (sq_prepare (plugin->dbh,
+                   "SELECT type,prio,anonLevel,expire,hash,value,_ROWID_ "
+                   "FROM gn090 INDEXED BY idx_anon_type_hash "
+                   "WHERE (anonLevel = 0 AND type=?1) "
+                   "ORDER BY hash DESC LIMIT 1 OFFSET ?2",
+                   &plugin->selZeroAnon) != SQLITE_OK) ||
       (sq_prepare (plugin->dbh,
                    "INSERT INTO gn090 (repl, type, prio, "
                    "anonLevel, expire, rvalue, hash, vhash, value) "
@@ -369,11 +363,10 @@ database_setup (const struct GNUNET_CONFIGURATION_Handle *cfg,
       (sq_prepare (plugin->dbh,
                    "DELETE FROM gn090 WHERE _ROWID_ = ?",
                    &plugin->delRow) != SQLITE_OK))
-    {
-      LOG_SQLITE (plugin, NULL,
-                  GNUNET_ERROR_TYPE_ERROR, "precompiling");
-      return GNUNET_SYSERR;
-    }
+  {
+    LOG_SQLITE (plugin, NULL, GNUNET_ERROR_TYPE_ERROR, "precompiling");
+    return GNUNET_SYSERR;
+  }
 
   return GNUNET_OK;
 }
@@ -388,6 +381,7 @@ static void
 database_shutdown (struct Plugin *plugin)
 {
   int result;
+
 #if SQLITE_VERSION_NUMBER >= 3007000
   sqlite3_stmt *stmt;
 #endif
@@ -408,36 +402,35 @@ database_shutdown (struct Plugin *plugin)
     sqlite3_finalize (plugin->selZeroAnon);
   if (plugin->insertContent != NULL)
     sqlite3_finalize (plugin->insertContent);
-  result = sqlite3_close(plugin->dbh);
+  result = sqlite3_close (plugin->dbh);
 #if SQLITE_VERSION_NUMBER >= 3007000
   if (result == SQLITE_BUSY)
+  {
+    GNUNET_log_from (GNUNET_ERROR_TYPE_WARNING,
+                     "sqlite",
+                     _
+                     ("Tried to close sqlite without finalizing all prepared statements.\n"));
+    stmt = sqlite3_next_stmt (plugin->dbh, NULL);
+    while (stmt != NULL)
     {
-      GNUNET_log_from (GNUNET_ERROR_TYPE_WARNING, 
-                       "sqlite",
-                       _("Tried to close sqlite without finalizing all prepared statements.\n"));
-      stmt = sqlite3_next_stmt(plugin->dbh, NULL); 
-      while (stmt != NULL)
-        {
 #if DEBUG_SQLITE
-          GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG,
-                     "sqlite", "Closing statement %p\n", stmt);
+      GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG,
+                       "sqlite", "Closing statement %p\n", stmt);
 #endif
-          result = sqlite3_finalize(stmt);
+      result = sqlite3_finalize (stmt);
 #if DEBUG_SQLITE
-          if (result != SQLITE_OK)
-              GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG,
-                               "sqlite",
-                               "Failed to close statement %p: %d\n", stmt, result);
+      if (result != SQLITE_OK)
+        GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG,
+                         "sqlite",
+                         "Failed to close statement %p: %d\n", stmt, result);
 #endif
-          stmt = sqlite3_next_stmt(plugin->dbh, NULL);
-        }
-      result = sqlite3_close(plugin->dbh);
+      stmt = sqlite3_next_stmt (plugin->dbh, NULL);
     }
+    result = sqlite3_close (plugin->dbh);
+  }
 #endif
   if (SQLITE_OK != result)
-      LOG_SQLITE (plugin, NULL,
-                  GNUNET_ERROR_TYPE_ERROR, 
-                  "sqlite3_close");
+    LOG_SQLITE (plugin, NULL, GNUNET_ERROR_TYPE_ERROR, "sqlite3_close");
 
   GNUNET_free_non_null (plugin->fn);
 }
@@ -451,34 +444,34 @@ database_shutdown (struct Plugin *plugin)
  * @param rid the ID of the row to delete
  */
 static int
-delete_by_rowid (struct Plugin* plugin, 
-                 unsigned long long rid)
+delete_by_rowid (struct Plugin *plugin, unsigned long long rid)
 {
-  if (SQLITE_OK !=
-      sqlite3_bind_int64 (plugin->delRow, 1, rid))
-    {
+  if (SQLITE_OK != sqlite3_bind_int64 (plugin->delRow, 1, rid))
+  {
+    LOG_SQLITE (plugin, NULL,
+                GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
+                "sqlite3_bind_XXXX");
+    if (SQLITE_OK != sqlite3_reset (plugin->delRow))
       LOG_SQLITE (plugin, NULL,
-                  GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK, "sqlite3_bind_XXXX");
-      if (SQLITE_OK != sqlite3_reset (plugin->delRow))
-        LOG_SQLITE (plugin, NULL,
-                    GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK, "sqlite3_reset");
-      return GNUNET_SYSERR;
-    }
+                  GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
+                  "sqlite3_reset");
+    return GNUNET_SYSERR;
+  }
   if (SQLITE_DONE != sqlite3_step (plugin->delRow))
-    {
+  {
+    LOG_SQLITE (plugin, NULL,
+                GNUNET_ERROR_TYPE_ERROR |
+                GNUNET_ERROR_TYPE_BULK, "sqlite3_step");
+    if (SQLITE_OK != sqlite3_reset (plugin->delRow))
       LOG_SQLITE (plugin, NULL,
                   GNUNET_ERROR_TYPE_ERROR |
-                  GNUNET_ERROR_TYPE_BULK, "sqlite3_step");
-      if (SQLITE_OK != sqlite3_reset (plugin->delRow))
-          LOG_SQLITE (plugin, NULL,
-                      GNUNET_ERROR_TYPE_ERROR |
-                      GNUNET_ERROR_TYPE_BULK, "sqlite3_reset");
-      return GNUNET_SYSERR;
-    }
+                  GNUNET_ERROR_TYPE_BULK, "sqlite3_reset");
+    return GNUNET_SYSERR;
+  }
   if (SQLITE_OK != sqlite3_reset (plugin->delRow))
     LOG_SQLITE (plugin, NULL,
-                GNUNET_ERROR_TYPE_ERROR |
-                GNUNET_ERROR_TYPE_BULK, "sqlite3_reset");
+                GNUNET_ERROR_TYPE_ERROR |
+                GNUNET_ERROR_TYPE_BULK, "sqlite3_reset");
   return GNUNET_OK;
 }
 
@@ -500,15 +493,14 @@ delete_by_rowid (struct Plugin* plugin,
  */
 static int
 sqlite_plugin_put (void *cls,
-                   const GNUNET_HashCode *key,
-                   uint32_t size,
-                   const void *data,
-                   enum GNUNET_BLOCK_Type type,
-                   uint32_t priority,
-                   uint32_t anonymity,
-                   uint32_t replication,
-                   struct GNUNET_TIME_Absolute expiration,
-                   char ** msg)
+                   const GNUNET_HashCode * key,
+                   uint32_t size,
+                   const void *data,
+                   enum GNUNET_BLOCK_Type type,
+                   uint32_t priority,
+                   uint32_t anonymity,
+                   uint32_t replication,
+                   struct GNUNET_TIME_Absolute expiration, char **msg)
 {
   struct Plugin *plugin = cls;
   int n;
@@ -521,13 +513,14 @@ sqlite_plugin_put (void *cls,
     return GNUNET_SYSERR;
 #if DEBUG_SQLITE
   GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG,
-                   "sqlite",
-                   "Storing in database block with type %u/key `%s'/priority %u/expiration in %llu ms (%lld).\n",
-                   type, 
-                   GNUNET_h2s(key),
-                   priority,
-                   (unsigned long long) GNUNET_TIME_absolute_get_remaining (expiration).rel_value,
-                   (long long) expiration.abs_value);
+                   "sqlite",
+                   "Storing in database block with type %u/key `%s'/priority %u/expiration in %llu ms (%lld).\n",
+                   type,
+                   GNUNET_h2s (key),
+                   priority,
+                   (unsigned long long)
+                   GNUNET_TIME_absolute_get_remaining (expiration).rel_value,
+                   (long long) expiration.abs_value);
 #endif
   GNUNET_CRYPTO_hash (data, size, &vhash);
   stmt = plugin->insertContent;
@@ -545,55 +538,54 @@ sqlite_plugin_put (void *cls,
        sqlite3_bind_blob (stmt, 8, &vhash, sizeof (GNUNET_HashCode),
                           SQLITE_TRANSIENT))
       || (SQLITE_OK !=
-          sqlite3_bind_blob (stmt, 9, data, size,
-                             SQLITE_TRANSIENT)))
-    {
-      LOG_SQLITE (plugin,
-                  msg,
-                  GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK, "sqlite3_bind_XXXX");
-      if (SQLITE_OK != sqlite3_reset (stmt))
-        LOG_SQLITE (plugin, NULL,
-                    GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK, "sqlite3_reset");
-      return GNUNET_SYSERR;
-    }
+          sqlite3_bind_blob (stmt, 9, data, size, SQLITE_TRANSIENT)))
+  {
+    LOG_SQLITE (plugin,
+                msg,
+                GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
+                "sqlite3_bind_XXXX");
+    if (SQLITE_OK != sqlite3_reset (stmt))
+      LOG_SQLITE (plugin, NULL,
+                  GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
+                  "sqlite3_reset");
+    return GNUNET_SYSERR;
+  }
   n = sqlite3_step (stmt);
   switch (n)
-    {
-    case SQLITE_DONE:
-      plugin->env->duc (plugin->env->cls,
-                        size + GNUNET_DATASTORE_ENTRY_OVERHEAD);
+  {
+  case SQLITE_DONE:
+    plugin->env->duc (plugin->env->cls, size + GNUNET_DATASTORE_ENTRY_OVERHEAD);
 #if DEBUG_SQLITE
-      GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG,
-                       "sqlite",
-                       "Stored new entry (%u bytes)\n",
-                       size + GNUNET_DATASTORE_ENTRY_OVERHEAD);
+    GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG,
+                     "sqlite",
+                     "Stored new entry (%u bytes)\n",
+                     size + GNUNET_DATASTORE_ENTRY_OVERHEAD);
 #endif
-      ret = GNUNET_OK;
-      break;
-    case SQLITE_BUSY:      
-      GNUNET_break (0);
-      LOG_SQLITE (plugin, msg,
-                  GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK, 
-                  "sqlite3_step");
-      ret = GNUNET_SYSERR;
-      break;
-    default:
-      LOG_SQLITE (plugin, msg,
-                  GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK, 
-                  "sqlite3_step");
-      if (SQLITE_OK != sqlite3_reset (stmt))
-        LOG_SQLITE (plugin, NULL,
-                    GNUNET_ERROR_TYPE_ERROR |
-                    GNUNET_ERROR_TYPE_BULK, "sqlite3_reset");
-      database_shutdown (plugin);
-      database_setup (plugin->env->cfg,
-                      plugin);
-      return GNUNET_SYSERR;    
-    }
+    ret = GNUNET_OK;
+    break;
+  case SQLITE_BUSY:
+    GNUNET_break (0);
+    LOG_SQLITE (plugin, msg,
+                GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
+                "sqlite3_step");
+    ret = GNUNET_SYSERR;
+    break;
+  default:
+    LOG_SQLITE (plugin, msg,
+                GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
+                "sqlite3_step");
+    if (SQLITE_OK != sqlite3_reset (stmt))
+      LOG_SQLITE (plugin, NULL,
+                  GNUNET_ERROR_TYPE_ERROR |
+                  GNUNET_ERROR_TYPE_BULK, "sqlite3_reset");
+    database_shutdown (plugin);
+    database_setup (plugin->env->cfg, plugin);
+    return GNUNET_SYSERR;
+  }
   if (SQLITE_OK != sqlite3_reset (stmt))
     LOG_SQLITE (plugin, NULL,
-                GNUNET_ERROR_TYPE_ERROR |
-                GNUNET_ERROR_TYPE_BULK, "sqlite3_reset");
+                GNUNET_ERROR_TYPE_ERROR |
+                GNUNET_ERROR_TYPE_BULK, "sqlite3_reset");
   return ret;
 }
 
@@ -623,52 +615,51 @@ sqlite_plugin_put (void *cls,
  */
 static int
 sqlite_plugin_update (void *cls,
-                      uint64_t uid,
-                      int delta, struct GNUNET_TIME_Absolute expire,
-                      char **msg)
+                      uint64_t uid,
+                      int delta, struct GNUNET_TIME_Absolute expire, char **msg)
 {
   struct Plugin *plugin = cls;
   int n;
 
-  if ( (SQLITE_OK !=
-        sqlite3_bind_int (plugin->updPrio, 1, delta)) ||
-       (SQLITE_OK !=
-        sqlite3_bind_int64 (plugin->updPrio, 2, expire.abs_value)) ||
-       (SQLITE_OK !=
-        sqlite3_bind_int64 (plugin->updPrio, 3, uid)) )
-    {
-      LOG_SQLITE (plugin, msg,
-                  GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK, "sqlite3_bind_XXXX");
-      if (SQLITE_OK != sqlite3_reset (plugin->updPrio))
-        LOG_SQLITE (plugin, NULL,
-                    GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK, "sqlite3_reset");
-      return GNUNET_SYSERR;
+  if ((SQLITE_OK !=
+       sqlite3_bind_int (plugin->updPrio, 1, delta)) ||
+      (SQLITE_OK !=
+       sqlite3_bind_int64 (plugin->updPrio, 2, expire.abs_value)) ||
+      (SQLITE_OK != sqlite3_bind_int64 (plugin->updPrio, 3, uid)))
+  {
+    LOG_SQLITE (plugin, msg,
+                GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
+                "sqlite3_bind_XXXX");
+    if (SQLITE_OK != sqlite3_reset (plugin->updPrio))
+      LOG_SQLITE (plugin, NULL,
+                  GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
+                  "sqlite3_reset");
+    return GNUNET_SYSERR;
 
-    }
+  }
   n = sqlite3_step (plugin->updPrio);
   if (SQLITE_OK != sqlite3_reset (plugin->updPrio))
     LOG_SQLITE (plugin, NULL,
-                GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK, "sqlite3_reset");
-   switch (n)
-    {
-    case SQLITE_DONE:
+                GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
+                "sqlite3_reset");
+  switch (n)
+  {
+  case SQLITE_DONE:
 #if DEBUG_SQLITE
-      GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG,
-                       "sqlite",
-                       "Block updated\n");
+    GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, "sqlite", "Block updated\n");
 #endif
-      return GNUNET_OK;
-    case SQLITE_BUSY:
-      LOG_SQLITE (plugin, msg,
-                  GNUNET_ERROR_TYPE_WARNING | GNUNET_ERROR_TYPE_BULK,
-                  "sqlite3_step");
-      return GNUNET_NO;
-    default:
-      LOG_SQLITE (plugin, msg,
-                  GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
-                  "sqlite3_step");
-      return GNUNET_SYSERR;
-    }
+    return GNUNET_OK;
+  case SQLITE_BUSY:
+    LOG_SQLITE (plugin, msg,
+                GNUNET_ERROR_TYPE_WARNING | GNUNET_ERROR_TYPE_BULK,
+                "sqlite3_step");
+    return GNUNET_NO;
+  default:
+    LOG_SQLITE (plugin, msg,
+                GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
+                "sqlite3_step");
+    return GNUNET_SYSERR;
+  }
 }
 
 
@@ -683,8 +674,7 @@ sqlite_plugin_update (void *cls,
  */
 static void
 execute_get (struct Plugin *plugin,
-             sqlite3_stmt *stmt,
-             PluginDatumProcessor proc, void *proc_cls)
+             sqlite3_stmt * stmt, PluginDatumProcessor proc, void *proc_cls)
 {
   int n;
   struct GNUNET_TIME_Absolute expiration;
@@ -694,80 +684,74 @@ execute_get (struct Plugin *plugin,
 
   n = sqlite3_step (stmt);
   switch (n)
+  {
+  case SQLITE_ROW:
+    size = sqlite3_column_bytes (stmt, 5);
+    rowid = sqlite3_column_int64 (stmt, 6);
+    if (sqlite3_column_bytes (stmt, 4) != sizeof (GNUNET_HashCode))
     {
-    case SQLITE_ROW:
-      size = sqlite3_column_bytes (stmt, 5);
-      rowid = sqlite3_column_int64 (stmt, 6);
-      if (sqlite3_column_bytes (stmt, 4) != sizeof (GNUNET_HashCode))
-        {
-          GNUNET_log_from (GNUNET_ERROR_TYPE_WARNING, 
-                           "sqlite",
-                           _("Invalid data in database.  Trying to fix (by deletion).\n"));
-          if (SQLITE_OK != sqlite3_reset (stmt))
-            LOG_SQLITE (plugin, NULL,
-                        GNUNET_ERROR_TYPE_ERROR |
-                        GNUNET_ERROR_TYPE_BULK, "sqlite3_reset");
-          if (GNUNET_OK == delete_by_rowid (plugin, rowid))
-            plugin->env->duc (plugin->env->cls,
-                              - (size + GNUNET_DATASTORE_ENTRY_OVERHEAD));        
-          break;
-        }
-      expiration.abs_value = sqlite3_column_int64 (stmt, 3);
-#if DEBUG_SQLITE
-      GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, 
-                       "sqlite",
-                       "Found reply in database with expiration %llu\n",
-                       (unsigned long long) expiration.abs_value);
-#endif
-      ret = proc (proc_cls,
-                  sqlite3_column_blob (stmt, 4) /* key */,
-                  size,
-                  sqlite3_column_blob (stmt, 5) /* data */, 
-                  sqlite3_column_int (stmt, 0) /* type */,
-                  sqlite3_column_int (stmt, 1) /* priority */,
-                  sqlite3_column_int (stmt, 2) /* anonymity */,
-                  expiration,
-                  rowid);
-      if (SQLITE_OK != sqlite3_reset (stmt))
-        LOG_SQLITE (plugin, NULL,
-                    GNUNET_ERROR_TYPE_ERROR |
-                    GNUNET_ERROR_TYPE_BULK, "sqlite3_reset");
-      if ( (GNUNET_NO == ret) &&
-           (GNUNET_OK == delete_by_rowid (plugin, rowid)) )
-        plugin->env->duc (plugin->env->cls,
-                          - (size + GNUNET_DATASTORE_ENTRY_OVERHEAD));  
-      return;
-    case SQLITE_DONE:
-      /* database must be empty */
-      if (SQLITE_OK != sqlite3_reset (stmt))
-        LOG_SQLITE (plugin, NULL,
-                    GNUNET_ERROR_TYPE_ERROR |
-                    GNUNET_ERROR_TYPE_BULK, "sqlite3_reset");
-      break;
-    case SQLITE_BUSY:    
-    case SQLITE_ERROR:
-    case SQLITE_MISUSE:
-    default:
-      LOG_SQLITE (plugin, NULL,
-                  GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK, 
-                  "sqlite3_step");
+      GNUNET_log_from (GNUNET_ERROR_TYPE_WARNING,
+                       "sqlite",
+                       _
+                       ("Invalid data in database.  Trying to fix (by deletion).\n"));
       if (SQLITE_OK != sqlite3_reset (stmt))
-        LOG_SQLITE (plugin, NULL,
-                    GNUNET_ERROR_TYPE_ERROR |
-                    GNUNET_ERROR_TYPE_BULK,
-                    "sqlite3_reset");
-      GNUNET_break (0);
-      database_shutdown (plugin);
-      database_setup (plugin->env->cfg,
-                      plugin);
+        LOG_SQLITE (plugin, NULL,
+                    GNUNET_ERROR_TYPE_ERROR |
+                    GNUNET_ERROR_TYPE_BULK, "sqlite3_reset");
+      if (GNUNET_OK == delete_by_rowid (plugin, rowid))
+        plugin->env->duc (plugin->env->cls,
+                          -(size + GNUNET_DATASTORE_ENTRY_OVERHEAD));
       break;
     }
+    expiration.abs_value = sqlite3_column_int64 (stmt, 3);
+#if DEBUG_SQLITE
+    GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG,
+                     "sqlite",
+                     "Found reply in database with expiration %llu\n",
+                     (unsigned long long) expiration.abs_value);
+#endif
+    ret = proc (proc_cls, sqlite3_column_blob (stmt, 4) /* key */ ,
+                size, sqlite3_column_blob (stmt, 5) /* data */ ,
+                sqlite3_column_int (stmt, 0) /* type */ ,
+                sqlite3_column_int (stmt, 1) /* priority */ ,
+                sqlite3_column_int (stmt, 2) /* anonymity */ ,
+                expiration, rowid);
+    if (SQLITE_OK != sqlite3_reset (stmt))
+      LOG_SQLITE (plugin, NULL,
+                  GNUNET_ERROR_TYPE_ERROR |
+                  GNUNET_ERROR_TYPE_BULK, "sqlite3_reset");
+    if ((GNUNET_NO == ret) && (GNUNET_OK == delete_by_rowid (plugin, rowid)))
+      plugin->env->duc (plugin->env->cls,
+                        -(size + GNUNET_DATASTORE_ENTRY_OVERHEAD));
+    return;
+  case SQLITE_DONE:
+    /* database must be empty */
+    if (SQLITE_OK != sqlite3_reset (stmt))
+      LOG_SQLITE (plugin, NULL,
+                  GNUNET_ERROR_TYPE_ERROR |
+                  GNUNET_ERROR_TYPE_BULK, "sqlite3_reset");
+    break;
+  case SQLITE_BUSY:
+  case SQLITE_ERROR:
+  case SQLITE_MISUSE:
+  default:
+    LOG_SQLITE (plugin, NULL,
+                GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
+                "sqlite3_step");
+    if (SQLITE_OK != sqlite3_reset (stmt))
+      LOG_SQLITE (plugin, NULL,
+                  GNUNET_ERROR_TYPE_ERROR |
+                  GNUNET_ERROR_TYPE_BULK, "sqlite3_reset");
+    GNUNET_break (0);
+    database_shutdown (plugin);
+    database_setup (plugin->env->cfg, plugin);
+    break;
+  }
   if (SQLITE_OK != sqlite3_reset (stmt))
     LOG_SQLITE (plugin, NULL,
-                GNUNET_ERROR_TYPE_ERROR |
-                GNUNET_ERROR_TYPE_BULK, "sqlite3_reset");
-  proc (proc_cls, NULL, 0, NULL, 0, 0, 0,           
-        GNUNET_TIME_UNIT_ZERO_ABS, 0);
+                GNUNET_ERROR_TYPE_ERROR |
+                GNUNET_ERROR_TYPE_BULK, "sqlite3_reset");
+  proc (proc_cls, NULL, 0, NULL, 0, 0, 0, GNUNET_TIME_UNIT_ZERO_ABS, 0);
 }
 
 
@@ -787,31 +771,28 @@ execute_get (struct Plugin *plugin,
  */
 static void
 sqlite_plugin_get_zero_anonymity (void *cls,
-                                  uint64_t offset,
-                                  enum GNUNET_BLOCK_Type type,
-                                  PluginDatumProcessor proc,
-                                  void *proc_cls)
+                                  uint64_t offset,
+                                  enum GNUNET_BLOCK_Type type,
+                                  PluginDatumProcessor proc, void *proc_cls)
 {
   struct Plugin *plugin = cls;
   sqlite3_stmt *stmt;
 
   GNUNET_assert (type != GNUNET_BLOCK_TYPE_ANY);
   stmt = plugin->selZeroAnon;
-  if ( (SQLITE_OK != sqlite3_bind_int (stmt, 1, type)) ||
-       (SQLITE_OK != sqlite3_bind_int64 (stmt, 2, offset)) )
-    {
+  if ((SQLITE_OK != sqlite3_bind_int (stmt, 1, type)) ||
+      (SQLITE_OK != sqlite3_bind_int64 (stmt, 2, offset)))
+  {
+    LOG_SQLITE (plugin, NULL,
+                GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
+                "sqlite3_bind_XXXX");
+    if (SQLITE_OK != sqlite3_reset (stmt))
       LOG_SQLITE (plugin, NULL,
-                  GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK, 
-                  "sqlite3_bind_XXXX");
-      if (SQLITE_OK != sqlite3_reset (stmt))
-        LOG_SQLITE (plugin, NULL,
-                    GNUNET_ERROR_TYPE_ERROR | 
-                    GNUNET_ERROR_TYPE_BULK, 
-                    "sqlite3_reset");
-      proc (proc_cls, NULL, 0, NULL, 0, 0, 0,       
-            GNUNET_TIME_UNIT_ZERO_ABS, 0);
-      return;
-    }
+                  GNUNET_ERROR_TYPE_ERROR |
+                  GNUNET_ERROR_TYPE_BULK, "sqlite3_reset");
+    proc (proc_cls, NULL, 0, NULL, 0, 0, 0, GNUNET_TIME_UNIT_ZERO_ABS, 0);
+    return;
+  }
   execute_get (plugin, stmt, proc, proc_cls);
 }
 
@@ -836,11 +817,11 @@ sqlite_plugin_get_zero_anonymity (void *cls,
  */
 static void
 sqlite_plugin_get_key (void *cls,
-                       uint64_t offset,
-                       const GNUNET_HashCode *key,
-                       const GNUNET_HashCode *vhash,
-                       enum GNUNET_BLOCK_Type type,
-                       PluginDatumProcessor proc, void *proc_cls)
+                       uint64_t offset,
+                       const GNUNET_HashCode * key,
+                       const GNUNET_HashCode * vhash,
+                       enum GNUNET_BLOCK_Type type,
+                       PluginDatumProcessor proc, void *proc_cls)
 {
   struct Plugin *plugin = cls;
   int ret;
@@ -855,48 +836,47 @@ sqlite_plugin_get_key (void *cls,
   GNUNET_snprintf (scratch, sizeof (scratch),
                    "SELECT count(*) FROM gn090 WHERE hash=?%s%s",
                    vhash == NULL ? "" : " AND vhash=?",
-                   type  == 0    ? "" : " AND type=?");
+                   type == 0 ? "" : " AND type=?");
   if (sq_prepare (plugin->dbh, scratch, &stmt) != SQLITE_OK)
-    {
-      LOG_SQLITE (plugin, NULL,
-                  GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK, "sqlite_prepare");
-      proc (proc_cls, NULL, 0, NULL, 0, 0, 0, GNUNET_TIME_UNIT_ZERO_ABS, 0);
-      return;
-    }
+  {
+    LOG_SQLITE (plugin, NULL,
+                GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
+                "sqlite_prepare");
+    proc (proc_cls, NULL, 0, NULL, 0, 0, 0, GNUNET_TIME_UNIT_ZERO_ABS, 0);
+    return;
+  }
   sqoff = 1;
   ret = sqlite3_bind_blob (stmt, sqoff++,
                            key, sizeof (GNUNET_HashCode), SQLITE_TRANSIENT);
   if ((vhash != NULL) && (ret == SQLITE_OK))
     ret = sqlite3_bind_blob (stmt, sqoff++,
-                             vhash,
-                             sizeof (GNUNET_HashCode), SQLITE_TRANSIENT);
+                             vhash, sizeof (GNUNET_HashCode), SQLITE_TRANSIENT);
   if ((type != 0) && (ret == SQLITE_OK))
     ret = sqlite3_bind_int (stmt, sqoff++, type);
   if (SQLITE_OK != ret)
-    {
-      LOG_SQLITE (plugin, NULL,
-                  GNUNET_ERROR_TYPE_ERROR, "sqlite_bind");
-      sqlite3_finalize (stmt);
-      proc (proc_cls, NULL, 0, NULL, 0, 0, 0, GNUNET_TIME_UNIT_ZERO_ABS, 0);
-      return;
-    }
+  {
+    LOG_SQLITE (plugin, NULL, GNUNET_ERROR_TYPE_ERROR, "sqlite_bind");
+    sqlite3_finalize (stmt);
+    proc (proc_cls, NULL, 0, NULL, 0, 0, 0, GNUNET_TIME_UNIT_ZERO_ABS, 0);
+    return;
+  }
   ret = sqlite3_step (stmt);
   if (ret != SQLITE_ROW)
-    {
-      LOG_SQLITE (plugin, NULL,
-                  GNUNET_ERROR_TYPE_ERROR| GNUNET_ERROR_TYPE_BULK, 
-                  "sqlite_step");
-      sqlite3_finalize (stmt);
-      proc (proc_cls, NULL, 0, NULL, 0, 0, 0, GNUNET_TIME_UNIT_ZERO_ABS, 0);
-      return;
-    }
+  {
+    LOG_SQLITE (plugin, NULL,
+                GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
+                "sqlite_step");
+    sqlite3_finalize (stmt);
+    proc (proc_cls, NULL, 0, NULL, 0, 0, 0, GNUNET_TIME_UNIT_ZERO_ABS, 0);
+    return;
+  }
   total = sqlite3_column_int (stmt, 0);
   sqlite3_finalize (stmt);
   if (0 == total)
-    {
-      proc (proc_cls, NULL, 0, NULL, 0, 0, 0, GNUNET_TIME_UNIT_ZERO_ABS, 0);
-      return;
-    }
+  {
+    proc (proc_cls, NULL, 0, NULL, 0, 0, 0, GNUNET_TIME_UNIT_ZERO_ABS, 0);
+    return;
+  }
   limit_off = (int) (offset % total);
   if (limit_off < 0)
     limit_off += total;
@@ -907,36 +887,33 @@ sqlite_plugin_get_key (void *cls,
                    vhash == NULL ? "" : " AND vhash=?",
                    type == 0 ? "" : " AND type=?");
   if (sq_prepare (plugin->dbh, scratch, &stmt) != SQLITE_OK)
-    {
-      LOG_SQLITE (plugin, NULL,
-                  GNUNET_ERROR_TYPE_ERROR |
-                  GNUNET_ERROR_TYPE_BULK, "sqlite_prepare");
-      proc (proc_cls, NULL, 0, NULL, 0, 0, 0, GNUNET_TIME_UNIT_ZERO_ABS, 0);
-      return;
-    }
+  {
+    LOG_SQLITE (plugin, NULL,
+                GNUNET_ERROR_TYPE_ERROR |
+                GNUNET_ERROR_TYPE_BULK, "sqlite_prepare");
+    proc (proc_cls, NULL, 0, NULL, 0, 0, 0, GNUNET_TIME_UNIT_ZERO_ABS, 0);
+    return;
+  }
   sqoff = 1;
   ret = sqlite3_bind_blob (stmt,
-                           sqoff++,
-                           key, 
-                           sizeof (GNUNET_HashCode),
-                           SQLITE_TRANSIENT);
+                           sqoff++,
+                           key, sizeof (GNUNET_HashCode), SQLITE_TRANSIENT);
   if ((vhash != NULL) && (ret == SQLITE_OK))
     ret = sqlite3_bind_blob (stmt,
-                             sqoff++,
-                             vhash,
-                             sizeof (GNUNET_HashCode), SQLITE_TRANSIENT);
+                             sqoff++,
+                             vhash, sizeof (GNUNET_HashCode), SQLITE_TRANSIENT);
   if ((type != 0) && (ret == SQLITE_OK))
     ret = sqlite3_bind_int (stmt, sqoff++, type);
   if (ret == SQLITE_OK)
     ret = sqlite3_bind_int64 (stmt, sqoff++, limit_off);
   if (ret != SQLITE_OK)
-    {
-      LOG_SQLITE (plugin, NULL,
-                  GNUNET_ERROR_TYPE_ERROR |
-                  GNUNET_ERROR_TYPE_BULK, "sqlite_bind");
-      proc (proc_cls, NULL, 0, NULL, 0, 0, 0, GNUNET_TIME_UNIT_ZERO_ABS, 0);
-      return;
-    }
+  {
+    LOG_SQLITE (plugin, NULL,
+                GNUNET_ERROR_TYPE_ERROR |
+                GNUNET_ERROR_TYPE_BULK, "sqlite_bind");
+    proc (proc_cls, NULL, 0, NULL, 0, 0, 0, GNUNET_TIME_UNIT_ZERO_ABS, 0);
+    return;
+  }
   execute_get (plugin, stmt, proc, proc_cls);
   sqlite3_finalize (stmt);
 }
@@ -948,12 +925,12 @@ sqlite_plugin_get_key (void *cls,
  */
 struct ReplCtx
 {
-  
+
   /**
    * Function to call for the result (or the NULL).
    */
   PluginDatumProcessor proc;
-  
+
   /**
    * Closure for proc.
    */
@@ -992,28 +969,24 @@ struct ReplCtx
  */
 static int
 repl_proc (void *cls,
-           const GNUNET_HashCode *key,
-           uint32_t size,
-           const void *data,
-           enum GNUNET_BLOCK_Type type,
-           uint32_t priority,
-           uint32_t anonymity,
-           struct GNUNET_TIME_Absolute expiration, 
-           uint64_t uid)
+           const GNUNET_HashCode * key,
+           uint32_t size,
+           const void *data,
+           enum GNUNET_BLOCK_Type type,
+           uint32_t priority,
+           uint32_t anonymity,
+           struct GNUNET_TIME_Absolute expiration, uint64_t uid)
 {
   struct ReplCtx *rc = cls;
   int ret;
 
   ret = rc->proc (rc->proc_cls,
-                  key,
-                  size, data, 
-                  type, priority, anonymity, expiration,
-                  uid);
+                  key, size, data, type, priority, anonymity, expiration, uid);
   if (key != NULL)
-    {
-      rc->uid = uid;
-      rc->have_uid = GNUNET_YES;
-    }
+  {
+    rc->uid = uid;
+    rc->have_uid = GNUNET_YES;
+  }
   return ret;
 }
 
@@ -1030,7 +1003,7 @@ repl_proc (void *cls,
  */
 static void
 sqlite_plugin_get_replication (void *cls,
-                               PluginDatumProcessor proc, void *proc_cls)
+                               PluginDatumProcessor proc, void *proc_cls)
 {
   struct Plugin *plugin = cls;
   struct ReplCtx rc;
@@ -1040,76 +1013,77 @@ sqlite_plugin_get_replication (void *cls,
 
 #if DEBUG_SQLITE
   GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG,
-                   "sqlite",
-                   "Getting random block based on replication order.\n");
+                   "sqlite",
+                   "Getting random block based on replication order.\n");
 #endif
   rc.have_uid = GNUNET_NO;
   rc.proc = proc;
   rc.proc_cls = proc_cls;
   stmt = plugin->maxRepl;
   if (SQLITE_ROW != sqlite3_step (stmt))
-    {
-      if (SQLITE_OK != sqlite3_reset (stmt))
-        LOG_SQLITE (plugin, NULL,
-                    GNUNET_ERROR_TYPE_ERROR |
-                    GNUNET_ERROR_TYPE_BULK, "sqlite3_reset");
-      /* DB empty */
-      proc (proc_cls, NULL, 0, NULL, 0, 0, 0, 
-            GNUNET_TIME_UNIT_ZERO_ABS, 0);
-      return;
-    }
+  {
+    if (SQLITE_OK != sqlite3_reset (stmt))
+      LOG_SQLITE (plugin, NULL,
+                  GNUNET_ERROR_TYPE_ERROR |
+                  GNUNET_ERROR_TYPE_BULK, "sqlite3_reset");
+    /* DB empty */
+    proc (proc_cls, NULL, 0, NULL, 0, 0, 0, GNUNET_TIME_UNIT_ZERO_ABS, 0);
+    return;
+  }
   repl = sqlite3_column_int (stmt, 0);
   if (SQLITE_OK != sqlite3_reset (stmt))
     LOG_SQLITE (plugin, NULL,
-                GNUNET_ERROR_TYPE_ERROR |
-                GNUNET_ERROR_TYPE_BULK, "sqlite3_reset");
+                GNUNET_ERROR_TYPE_ERROR |
+                GNUNET_ERROR_TYPE_BULK, "sqlite3_reset");
   stmt = plugin->selRepl;
   rvalue = GNUNET_CRYPTO_random_u64 (GNUNET_CRYPTO_QUALITY_WEAK, UINT64_MAX);
   if (SQLITE_OK != sqlite3_bind_int64 (stmt, 1, rvalue))
-    {
-      LOG_SQLITE (plugin, NULL,           
-                  GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK, "sqlite3_bind_XXXX");
-      if (SQLITE_OK != sqlite3_reset (stmt))
-        LOG_SQLITE (plugin, NULL,
-                    GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK, "sqlite3_reset");
-      proc (proc_cls, NULL, 0, NULL, 0, 0, 0, 
-            GNUNET_TIME_UNIT_ZERO_ABS, 0);
-      return;
-    }
+  {
+    LOG_SQLITE (plugin, NULL,
+                GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
+                "sqlite3_bind_XXXX");
+    if (SQLITE_OK != sqlite3_reset (stmt))
+      LOG_SQLITE (plugin, NULL,
+                  GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
+                  "sqlite3_reset");
+    proc (proc_cls, NULL, 0, NULL, 0, 0, 0, GNUNET_TIME_UNIT_ZERO_ABS, 0);
+    return;
+  }
   if (SQLITE_OK != sqlite3_bind_int (stmt, 2, repl))
-    {
-      LOG_SQLITE (plugin, NULL,           
-                  GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK, "sqlite3_bind_XXXX");
-      if (SQLITE_OK != sqlite3_reset (stmt))
-        LOG_SQLITE (plugin, NULL,
-                    GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK, "sqlite3_reset");
-      proc (proc_cls, NULL, 0, NULL, 0, 0, 0, 
-            GNUNET_TIME_UNIT_ZERO_ABS, 0);
-      return;
-    }
-  execute_get (plugin, stmt, &repl_proc, &rc); 
+  {
+    LOG_SQLITE (plugin, NULL,
+                GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
+                "sqlite3_bind_XXXX");
+    if (SQLITE_OK != sqlite3_reset (stmt))
+      LOG_SQLITE (plugin, NULL,
+                  GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
+                  "sqlite3_reset");
+    proc (proc_cls, NULL, 0, NULL, 0, 0, 0, GNUNET_TIME_UNIT_ZERO_ABS, 0);
+    return;
+  }
+  execute_get (plugin, stmt, &repl_proc, &rc);
   if (GNUNET_YES == rc.have_uid)
+  {
+    if (SQLITE_OK != sqlite3_bind_int64 (plugin->updRepl, 1, rc.uid))
     {
-      if (SQLITE_OK !=
-          sqlite3_bind_int64 (plugin->updRepl, 1, rc.uid))
-        {
-          LOG_SQLITE (plugin, NULL,
-                      GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK, "sqlite3_bind_XXXX");
-          if (SQLITE_OK != sqlite3_reset (plugin->updRepl))
-            LOG_SQLITE (plugin, NULL,
-                        GNUNET_ERROR_TYPE_ERROR |
-                        GNUNET_ERROR_TYPE_BULK, "sqlite3_reset");
-          return;
-        }
-      if (SQLITE_DONE != sqlite3_step (plugin->updRepl))        
-        LOG_SQLITE (plugin, NULL,
-                    GNUNET_ERROR_TYPE_ERROR |
-                    GNUNET_ERROR_TYPE_BULK, "sqlite3_step");
+      LOG_SQLITE (plugin, NULL,
+                  GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
+                  "sqlite3_bind_XXXX");
       if (SQLITE_OK != sqlite3_reset (plugin->updRepl))
-        LOG_SQLITE (plugin, NULL,
-                    GNUNET_ERROR_TYPE_ERROR |
-                    GNUNET_ERROR_TYPE_BULK, "sqlite3_reset");
+        LOG_SQLITE (plugin, NULL,
+                    GNUNET_ERROR_TYPE_ERROR |
+                    GNUNET_ERROR_TYPE_BULK, "sqlite3_reset");
+      return;
     }
+    if (SQLITE_DONE != sqlite3_step (plugin->updRepl))
+      LOG_SQLITE (plugin, NULL,
+                  GNUNET_ERROR_TYPE_ERROR |
+                  GNUNET_ERROR_TYPE_BULK, "sqlite3_step");
+    if (SQLITE_OK != sqlite3_reset (plugin->updRepl))
+      LOG_SQLITE (plugin, NULL,
+                  GNUNET_ERROR_TYPE_ERROR |
+                  GNUNET_ERROR_TYPE_BULK, "sqlite3_reset");
+  }
 }
 
 
@@ -1124,7 +1098,7 @@ sqlite_plugin_get_replication (void *cls,
  */
 static void
 sqlite_plugin_get_expiration (void *cls,
-                              PluginDatumProcessor proc, void *proc_cls)
+                              PluginDatumProcessor proc, void *proc_cls)
 {
   struct Plugin *plugin = cls;
   sqlite3_stmt *stmt;
@@ -1132,22 +1106,23 @@ sqlite_plugin_get_expiration (void *cls,
 
 #if DEBUG_SQLITE
   GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG,
-                   "sqlite",
-                   "Getting random block based on expiration and priority order.\n");
+                   "sqlite",
+                   "Getting random block based on expiration and priority order.\n");
 #endif
   now = GNUNET_TIME_absolute_get ();
   stmt = plugin->selExpi;
   if (SQLITE_OK != sqlite3_bind_int64 (stmt, 1, now.abs_value))
-    {
-      LOG_SQLITE (plugin, NULL,           
-                  GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK, "sqlite3_bind_XXXX");
-      if (SQLITE_OK != sqlite3_reset (stmt))
-        LOG_SQLITE (plugin, NULL,
-                    GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK, "sqlite3_reset");
-      proc (proc_cls, NULL, 0, NULL, 0, 0, 0, 
-            GNUNET_TIME_UNIT_ZERO_ABS, 0);
-      return;
-    }
+  {
+    LOG_SQLITE (plugin, NULL,
+                GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
+                "sqlite3_bind_XXXX");
+    if (SQLITE_OK != sqlite3_reset (stmt))
+      LOG_SQLITE (plugin, NULL,
+                  GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
+                  "sqlite3_reset");
+    proc (proc_cls, NULL, 0, NULL, 0, 0, 0, GNUNET_TIME_UNIT_ZERO_ABS, 0);
+    return;
+  }
   execute_get (plugin, stmt, proc, proc_cls);
 }
 
@@ -1157,10 +1132,11 @@ sqlite_plugin_get_expiration (void *cls,
  *
  * @param cls our plugin context
  */
-static void 
+static void
 sqlite_plugin_drop (void *cls)
 {
   struct Plugin *plugin = cls;
+
   plugin->drop_on_shutdown = GNUNET_YES;
 }
 
@@ -1179,48 +1155,40 @@ sqlite_plugin_estimate_size (void *cls)
   sqlite3_stmt *stmt;
   uint64_t pages;
   uint64_t page_size;
+
 #if ENULL_DEFINED
   char *e;
 #endif
 
   if (SQLITE_VERSION_NUMBER < 3006000)
-    {
-      GNUNET_log_from (GNUNET_ERROR_TYPE_WARNING,
-                       "datastore-sqlite",
-                       _("sqlite version to old to determine size, assuming zero\n"));
-      return 0;
-    }
-  CHECK (SQLITE_OK ==
-         sqlite3_exec (plugin->dbh,
-                       "VACUUM", NULL, NULL, ENULL));
-  CHECK (SQLITE_OK ==
-         sqlite3_exec (plugin->dbh,
-                       "PRAGMA auto_vacuum=INCREMENTAL", NULL, NULL, ENULL));
+  {
+    GNUNET_log_from (GNUNET_ERROR_TYPE_WARNING,
+                     "datastore-sqlite",
+                     _
+                     ("sqlite version to old to determine size, assuming zero\n"));
+    return 0;
+  }
+  CHECK (SQLITE_OK == sqlite3_exec (plugin->dbh, "VACUUM", NULL, NULL, ENULL));
   CHECK (SQLITE_OK ==
-         sq_prepare (plugin->dbh,
-                     "PRAGMA page_count",
-                     &stmt));
-  if (SQLITE_ROW ==
-      sqlite3_step (stmt))
+         sqlite3_exec (plugin->dbh,
+                       "PRAGMA auto_vacuum=INCREMENTAL", NULL, NULL, ENULL));
+  CHECK (SQLITE_OK == sq_prepare (plugin->dbh, "PRAGMA page_count", &stmt));
+  if (SQLITE_ROW == sqlite3_step (stmt))
     pages = sqlite3_column_int64 (stmt, 0);
   else
     pages = 0;
   sqlite3_finalize (stmt);
-  CHECK (SQLITE_OK ==
-         sq_prepare (plugin->dbh,
-                     "PRAGMA page_size",
-                     &stmt));
-  CHECK (SQLITE_ROW ==
-         sqlite3_step (stmt));
+  CHECK (SQLITE_OK == sq_prepare (plugin->dbh, "PRAGMA page_size", &stmt));
+  CHECK (SQLITE_ROW == sqlite3_step (stmt));
   page_size = sqlite3_column_int64 (stmt, 0);
   sqlite3_finalize (stmt);
   GNUNET_log (GNUNET_ERROR_TYPE_INFO,
-              _("Using sqlite page utilization to estimate payload (%llu pages of size %llu bytes)\n"),
-              (unsigned long long) pages,
-              (unsigned long long) page_size);
-  return  pages * page_size;
+              _
+              ("Using sqlite page utilization to estimate payload (%llu pages of size %llu bytes)\n"),
+              (unsigned long long) pages, (unsigned long long) page_size);
+  return pages * page_size;
 }
-                                         
+
 
 /**
  * Entry point for the plugin.
@@ -1236,15 +1204,14 @@ libgnunet_plugin_datastore_sqlite_init (void *cls)
   struct GNUNET_DATASTORE_PluginFunctions *api;
 
   if (plugin.env != NULL)
-    return NULL; /* can only initialize once! */
-  memset (&plugin, 0, sizeof(struct Plugin));
+    return NULL;                /* can only initialize once! */
+  memset (&plugin, 0, sizeof (struct Plugin));
   plugin.env = env;
-  if (GNUNET_OK !=
-      database_setup (env->cfg, &plugin))
-    {
-      database_shutdown (&plugin);
-      return NULL;
-    }
+  if (GNUNET_OK != database_setup (env->cfg, &plugin))
+  {
+    database_shutdown (&plugin);
+    return NULL;
+  }
   api = GNUNET_malloc (sizeof (struct GNUNET_DATASTORE_PluginFunctions));
   api->cls = &plugin;
   api->estimate_size = &sqlite_plugin_estimate_size;
@@ -1276,8 +1243,7 @@ libgnunet_plugin_datastore_sqlite_done (void *cls)
 
 #if DEBUG_SQLITE
   GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG,
-                   "sqlite",
-                   "sqlite plugin is done\n");
+                   "sqlite", "sqlite plugin is done\n");
 #endif
 
   fn = NULL;
@@ -1285,24 +1251,20 @@ libgnunet_plugin_datastore_sqlite_done (void *cls)
     fn = GNUNET_strdup (plugin->fn);
 #if DEBUG_SQLITE
   GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG,
-                   "sqlite",
-                   "Shutting down database\n");
+                   "sqlite", "Shutting down database\n");
 #endif
   database_shutdown (plugin);
-  plugin->env = NULL; 
+  plugin->env = NULL;
   GNUNET_free (api);
   if (fn != NULL)
-    {
-      if (0 != UNLINK(fn))
-        GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING,
-                                  "unlink",
-                                  fn);
-      GNUNET_free (fn);
-    }
+  {
+    if (0 != UNLINK (fn))
+      GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING, "unlink", fn);
+    GNUNET_free (fn);
+  }
 #if DEBUG_SQLITE
   GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG,
-                   "sqlite",
-                   "sqlite plugin is finished\n");
+                   "sqlite", "sqlite plugin is finished\n");
 #endif
   return NULL;
 }