peerstore: indentation

1 files changed, 157 insertions, 153 deletions

diff --git a/src/peerstore/plugin_peerstore_sqlite.c b/src/peerstore/plugin_peerstore_sqlite.c
index 2726eef3d..588fae73c 100644
--- a/src/peerstore/plugin_peerstore_sqlite.c
+++ b/src/peerstore/plugin_peerstore_sqlite.c
@@ -121,19 +121,24 @@ struct Plugin
  * @return number of deleted records
  */
 static int
-peerstore_sqlite_delete_records(void *cls,
-    const char *sub_system,
-    const struct GNUNET_PeerIdentity *peer,
-    const char *key)
+peerstore_sqlite_delete_records (void *cls, const char *sub_system,
+                                 const struct GNUNET_PeerIdentity *peer,
+                                 const char *key)
 {
   struct Plugin *plugin = cls;
   sqlite3_stmt *stmt = plugin->delete_peerstoredata;
 
-  if((SQLITE_OK != sqlite3_bind_text(stmt, 1, sub_system, strlen(sub_system) + 1, SQLITE_STATIC))
-      || (SQLITE_OK != sqlite3_bind_blob(stmt, 2, peer, sizeof(struct GNUNET_PeerIdentity), SQLITE_STATIC))
-      || (SQLITE_OK != sqlite3_bind_text(stmt, 3, key, strlen(key) + 1, SQLITE_STATIC)))
+  if ((SQLITE_OK !=
+       sqlite3_bind_text (stmt, 1, sub_system, strlen (sub_system) + 1,
+                          SQLITE_STATIC)) ||
+      (SQLITE_OK !=
+       sqlite3_bind_blob (stmt, 2, peer, sizeof (struct GNUNET_PeerIdentity),
+                          SQLITE_STATIC)) ||
+      (SQLITE_OK !=
+       sqlite3_bind_text (stmt, 3, key, strlen (key) + 1, SQLITE_STATIC)))
   {
-    LOG_SQLITE (plugin, GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK, "sqlite3_bind");
+    LOG_SQLITE (plugin, GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
+                "sqlite3_bind");
   }
   else if (SQLITE_DONE != sqlite3_step (stmt))
   {
@@ -146,9 +151,10 @@ peerstore_sqlite_delete_records(void *cls,
                 "sqlite3_reset");
     return 0;
   }
-  return sqlite3_changes(plugin->dbh);
+  return sqlite3_changes (plugin->dbh);
 }
 
+
 /**
  * Delete expired records (expiry < now)
  *
@@ -157,15 +163,16 @@ peerstore_sqlite_delete_records(void *cls,
  * @return number of records deleted
  */
 static int
-peerstore_sqlite_expire_records(void *cls,
-    struct GNUNET_TIME_Absolute now)
+peerstore_sqlite_expire_records (void *cls, struct GNUNET_TIME_Absolute now)
 {
   struct Plugin *plugin = cls;
   sqlite3_stmt *stmt = plugin->expire_peerstoredata;
 
-  if(SQLITE_OK != sqlite3_bind_int64(stmt, 1, (sqlite3_uint64)now.abs_value_us))
+  if (SQLITE_OK !=
+      sqlite3_bind_int64 (stmt, 1, (sqlite3_uint64) now.abs_value_us))
   {
-    LOG_SQLITE (plugin, GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK, "sqlite3_bind");
+    LOG_SQLITE (plugin, GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
+                "sqlite3_bind");
   }
   else if (SQLITE_DONE != sqlite3_step (stmt))
   {
@@ -178,10 +185,10 @@ peerstore_sqlite_expire_records(void *cls,
                 "sqlite3_reset");
     return 0;
   }
-  return sqlite3_changes(plugin->dbh);
-
+  return sqlite3_changes (plugin->dbh);
 }
 
+
 /**
  * Iterate over the records given an optional peer id
  * and/or key.
@@ -195,11 +202,11 @@ peerstore_sqlite_expire_records(void *cls,
  * @return #GNUNET_OK on success, #GNUNET_SYSERR on error
  */
 static int
-peerstore_sqlite_iterate_records (void *cls,
-    const char *sub_system,
-    const struct GNUNET_PeerIdentity *peer,
-    const char *key,
-    GNUNET_PEERSTORE_Processor iter, void *iter_cls)
+peerstore_sqlite_iterate_records (void *cls, const char *sub_system,
+                                  const struct GNUNET_PeerIdentity *peer,
+                                  const char *key,
+                                  GNUNET_PEERSTORE_Processor iter,
+                                  void *iter_cls)
 {
   struct Plugin *plugin = cls;
   sqlite3_stmt *stmt;
@@ -207,59 +214,76 @@ peerstore_sqlite_iterate_records (void *cls,
   int sret;
   struct GNUNET_PEERSTORE_Record *ret;
 
-  LOG(GNUNET_ERROR_TYPE_DEBUG, "Executing iterate request on sqlite db.\n");
-  if(NULL == peer && NULL == key)
+  LOG (GNUNET_ERROR_TYPE_DEBUG, "Executing iterate request on sqlite db.\n");
+  if (NULL == peer && NULL == key)
   {
     stmt = plugin->select_peerstoredata;
-    err = (SQLITE_OK != sqlite3_bind_text(stmt, 1, sub_system, strlen(sub_system) + 1, SQLITE_STATIC));
+    err =
+        (SQLITE_OK !=
+         sqlite3_bind_text (stmt, 1, sub_system, strlen (sub_system) + 1,
+                            SQLITE_STATIC));
   }
-  else if(NULL == key)
+  else if (NULL == key)
   {
     stmt = plugin->select_peerstoredata_by_pid;
-    err = (SQLITE_OK != sqlite3_bind_text(stmt, 1, sub_system, strlen(sub_system) + 1, SQLITE_STATIC))
-        || (SQLITE_OK != sqlite3_bind_blob(stmt, 2, peer, sizeof(struct GNUNET_PeerIdentity), SQLITE_STATIC));
+    err =
+        (SQLITE_OK !=
+         sqlite3_bind_text (stmt, 1, sub_system, strlen (sub_system) + 1,
+                            SQLITE_STATIC)) ||
+        (SQLITE_OK !=
+         sqlite3_bind_blob (stmt, 2, peer, sizeof (struct GNUNET_PeerIdentity),
+                            SQLITE_STATIC));
   }
-  else if(NULL == peer)
+  else if (NULL == peer)
   {
     stmt = plugin->select_peerstoredata_by_key;
-    err = (SQLITE_OK != sqlite3_bind_text(stmt, 1, sub_system, strlen(sub_system) + 1, SQLITE_STATIC))
-        || (SQLITE_OK != sqlite3_bind_text(stmt, 2, key, strlen(key) + 1, SQLITE_STATIC));
+    err =
+        (SQLITE_OK !=
+         sqlite3_bind_text (stmt, 1, sub_system, strlen (sub_system) + 1,
+                            SQLITE_STATIC)) ||
+        (SQLITE_OK !=
+         sqlite3_bind_text (stmt, 2, key, strlen (key) + 1, SQLITE_STATIC));
   }
   else
   {
     stmt = plugin->select_peerstoredata_by_all;
-    err = (SQLITE_OK != sqlite3_bind_text(stmt, 1, sub_system, strlen(sub_system) + 1, SQLITE_STATIC))
-            || (SQLITE_OK != sqlite3_bind_blob(stmt, 2, peer, sizeof(struct GNUNET_PeerIdentity), SQLITE_STATIC))
-            || (SQLITE_OK != sqlite3_bind_text(stmt, 3, key, strlen(key) + 1, SQLITE_STATIC));
+    err =
+        (SQLITE_OK !=
+         sqlite3_bind_text (stmt, 1, sub_system, strlen (sub_system) + 1,
+                            SQLITE_STATIC)) ||
+        (SQLITE_OK !=
+         sqlite3_bind_blob (stmt, 2, peer, sizeof (struct GNUNET_PeerIdentity),
+                            SQLITE_STATIC)) ||
+        (SQLITE_OK !=
+         sqlite3_bind_text (stmt, 3, key, strlen (key) + 1, SQLITE_STATIC));
   }
 
   if (err)
   {
     LOG_SQLITE (plugin, GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
-    "sqlite3_bind_XXXX");
+                "sqlite3_bind_XXXX");
     if (SQLITE_OK != sqlite3_reset (stmt))
-      LOG_SQLITE (plugin,
-      GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
-      "sqlite3_reset");
+      LOG_SQLITE (plugin, GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
+                  "sqlite3_reset");
     return GNUNET_SYSERR;
   }
   while (SQLITE_ROW == (sret = sqlite3_step (stmt)))
   {
-    LOG(GNUNET_ERROR_TYPE_DEBUG, "Returning a matched record.\n");
-    ret = GNUNET_new(struct GNUNET_PEERSTORE_Record);
-    ret->sub_system = (char *)sqlite3_column_text(stmt, 0);
-    ret->peer = (struct GNUNET_PeerIdentity *)sqlite3_column_blob(stmt, 1);
-    ret->key = (char *)sqlite3_column_text(stmt, 2);
-    ret->value = (void *)sqlite3_column_blob(stmt, 3);
-    ret->value_size = sqlite3_column_bytes(stmt, 3);
-    ret->expiry = GNUNET_new(struct GNUNET_TIME_Absolute);
-    ret->expiry->abs_value_us = (uint64_t)sqlite3_column_int64(stmt, 4);
+    LOG (GNUNET_ERROR_TYPE_DEBUG, "Returning a matched record.\n");
+    ret = GNUNET_new (struct GNUNET_PEERSTORE_Record);
+
+    ret->sub_system = (char *) sqlite3_column_text (stmt, 0);
+    ret->peer = (struct GNUNET_PeerIdentity *) sqlite3_column_blob (stmt, 1);
+    ret->key = (char *) sqlite3_column_text (stmt, 2);
+    ret->value = (void *) sqlite3_column_blob (stmt, 3);
+    ret->value_size = sqlite3_column_bytes (stmt, 3);
+    ret->expiry = GNUNET_new (struct GNUNET_TIME_Absolute);
+
+    ret->expiry->abs_value_us = (uint64_t) sqlite3_column_int64 (stmt, 4);
     if (NULL != iter)
-      iter (iter_cls,
-          ret,
-          NULL);
-    GNUNET_free(ret->expiry);
-    GNUNET_free(ret);
+      iter (iter_cls, ret, NULL);
+    GNUNET_free (ret->expiry);
+    GNUNET_free (ret);
   }
   if (SQLITE_DONE != sret)
   {
@@ -268,16 +292,16 @@ peerstore_sqlite_iterate_records (void *cls,
   }
   if (SQLITE_OK != sqlite3_reset (stmt))
   {
-    LOG_SQLITE (plugin,
-    GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
-    "sqlite3_reset");
+    LOG_SQLITE (plugin, GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
+                "sqlite3_reset");
     err = 1;
   }
-  if(err)
+  if (err)
     return GNUNET_SYSERR;
   return GNUNET_OK;
 }
 
+
 /**
  * Store a record in the peerstore.
  * Key is the combination of sub system and peer identity.
@@ -294,29 +318,32 @@ peerstore_sqlite_iterate_records (void *cls,
  * @return #GNUNET_OK on success, else #GNUNET_SYSERR
  */
 static int
-peerstore_sqlite_store_record (void *cls,
-                               const char *sub_system,
+peerstore_sqlite_store_record (void *cls, const char *sub_system,
                                const struct GNUNET_PeerIdentity *peer,
-                               const char *key,
-                               const void *value,
-                               size_t size,
+                               const char *key, const void *value, size_t size,
                                struct GNUNET_TIME_Absolute expiry,
                                enum GNUNET_PEERSTORE_StoreOption options)
 {
   struct Plugin *plugin = cls;
   sqlite3_stmt *stmt = plugin->insert_peerstoredata;
 
-  if(GNUNET_PEERSTORE_STOREOPTION_REPLACE == options)
+  if (GNUNET_PEERSTORE_STOREOPTION_REPLACE == options)
   {
-    peerstore_sqlite_delete_records(cls, sub_system, peer, key);
+    peerstore_sqlite_delete_records (cls, sub_system, peer, key);
   }
-  if(SQLITE_OK != sqlite3_bind_text(stmt, 1, sub_system, strlen(sub_system) + 1, SQLITE_STATIC)
-      || SQLITE_OK != sqlite3_bind_blob(stmt, 2, peer, sizeof(struct GNUNET_PeerIdentity), SQLITE_STATIC)
-      || SQLITE_OK != sqlite3_bind_text(stmt, 3, key, strlen(key) + 1, SQLITE_STATIC)
-      || SQLITE_OK != sqlite3_bind_blob(stmt, 4, value, size, SQLITE_STATIC)
-      || SQLITE_OK != sqlite3_bind_int64(stmt, 5, (sqlite3_uint64)expiry.abs_value_us))
+  if (SQLITE_OK !=
+      sqlite3_bind_text (stmt, 1, sub_system, strlen (sub_system) + 1,
+                         SQLITE_STATIC) ||
+      SQLITE_OK != sqlite3_bind_blob (stmt, 2, peer,
+                                      sizeof (struct GNUNET_PeerIdentity),
+                                      SQLITE_STATIC) ||
+      SQLITE_OK != sqlite3_bind_text (stmt, 3, key, strlen (key) + 1,
+                                      SQLITE_STATIC) ||
+      SQLITE_OK != sqlite3_bind_blob (stmt, 4, value, size, SQLITE_STATIC) ||
+      SQLITE_OK != sqlite3_bind_int64 (stmt, 5,
+                                       (sqlite3_uint64) expiry.abs_value_us))
     LOG_SQLITE (plugin, GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
-                    "sqlite3_bind");
+                "sqlite3_bind");
   else if (SQLITE_DONE != sqlite3_step (stmt))
   {
     LOG_SQLITE (plugin, GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
@@ -328,7 +355,6 @@ peerstore_sqlite_store_record (void *cls,
                 "sqlite3_reset");
     return GNUNET_SYSERR;
   }
-
   return GNUNET_OK;
 }
 
@@ -341,20 +367,19 @@ peerstore_sqlite_store_record (void *cls,
  * @return 0 on success
  */
 static int
-sql_exec (sqlite3 *dbh, const char *sql)
+sql_exec (sqlite3 * dbh, const char *sql)
 {
   int result;
 
   result = sqlite3_exec (dbh, sql, NULL, NULL, NULL);
-  LOG (GNUNET_ERROR_TYPE_DEBUG,
-       "Executed `%s' / %d\n", sql, result);
+  LOG (GNUNET_ERROR_TYPE_DEBUG, "Executed `%s' / %d\n", sql, result);
   if (result != SQLITE_OK)
-    LOG (GNUNET_ERROR_TYPE_ERROR,
-   _("Error executing SQL query: %s\n  %s\n"),
-   sqlite3_errmsg (dbh), sql);
+    LOG (GNUNET_ERROR_TYPE_ERROR, _("Error executing SQL query: %s\n  %s\n"),
+         sqlite3_errmsg (dbh), sql);
   return result;
 }
 
+
 /**
  * @brief Prepare a SQL statement
  *
@@ -364,37 +389,37 @@ sql_exec (sqlite3 *dbh, const char *sql)
  * @return 0 on success
  */
 static int
-sql_prepare (sqlite3 *dbh, const char *sql, sqlite3_stmt **stmt)
+sql_prepare (sqlite3 * dbh, const char *sql, sqlite3_stmt ** stmt)
 {
   char *tail;
   int result;
 
-  result = sqlite3_prepare_v2 (dbh, sql, strlen (sql), stmt,
-                               (const char **) &tail);
-  LOG (GNUNET_ERROR_TYPE_DEBUG,
-       "Prepared `%s' / %p: %d\n", sql, *stmt, result);
+  result =
+      sqlite3_prepare_v2 (dbh, sql, strlen (sql), stmt, (const char **) &tail);
+  LOG (GNUNET_ERROR_TYPE_DEBUG, "Prepared `%s' / %p: %d\n", sql, *stmt, result);
   if (result != SQLITE_OK)
-    LOG (GNUNET_ERROR_TYPE_ERROR,
-   _("Error preparing SQL query: %s\n  %s\n"),
-   sqlite3_errmsg (dbh), sql);
+    LOG (GNUNET_ERROR_TYPE_ERROR, _("Error preparing SQL query: %s\n  %s\n"),
+         sqlite3_errmsg (dbh), sql);
   return result;
 }
 
+
 /**
  * sqlite3 custom function for comparison of uint64_t values
  * since it is not supported by default
  */
-void sqlite3_lessthan(sqlite3_context* ctx, int dummy,
-    sqlite3_value** values)
+void
+sqlite3_lessthan (sqlite3_context * ctx, int dummy, sqlite3_value ** values)
 {
   uint64_t v1;
   uint64_t v2;
 
-  v1 = (uint64_t)sqlite3_value_int64(values[0]);
-  v2 = (uint64_t)sqlite3_value_int64(values[1]);
-  sqlite3_result_int(ctx, v1 < v2);
+  v1 = (uint64_t) sqlite3_value_int64 (values[0]);
+  v2 = (uint64_t) sqlite3_value_int64 (values[1]);
+  sqlite3_result_int (ctx, v1 < v2);
 }
 
+
 /**
  * Initialize the database connections and associated
  * data structures (create tables and indices
@@ -412,8 +437,8 @@ database_setup (struct Plugin *plugin)
       GNUNET_CONFIGURATION_get_value_filename (plugin->cfg, "peerstore-sqlite",
                                                "FILENAME", &filename))
   {
-    GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR,
-             "peerstore-sqlite", "FILENAME");
+    GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR, "peerstore-sqlite",
+                               "FILENAME");
     return GNUNET_SYSERR;
   }
   if (GNUNET_OK != GNUNET_DISK_file_test (filename))
@@ -427,16 +452,13 @@ database_setup (struct Plugin *plugin)
   }
   /* filename should be UTF-8-encoded. If it isn't, it's a bug */
   plugin->fn = filename;
-
   /* Open database and precompile statements */
   if (SQLITE_OK != sqlite3_open (plugin->fn, &plugin->dbh))
   {
-    LOG (GNUNET_ERROR_TYPE_ERROR,
-   _("Unable to initialize SQLite: %s.\n"),
-   sqlite3_errmsg (plugin->dbh));
+    LOG (GNUNET_ERROR_TYPE_ERROR, _("Unable to initialize SQLite: %s.\n"),
+         sqlite3_errmsg (plugin->dbh));
     return GNUNET_SYSERR;
   }
-
   sql_exec (plugin->dbh, "PRAGMA temp_store=MEMORY");
   sql_exec (plugin->dbh, "PRAGMA synchronous=OFF");
   sql_exec (plugin->dbh, "PRAGMA legacy_file_format=OFF");
@@ -444,73 +466,54 @@ database_setup (struct Plugin *plugin)
   sql_exec (plugin->dbh, "PRAGMA encoding=\"UTF-8\"");
   sql_exec (plugin->dbh, "PRAGMA count_changes=OFF");
   sql_exec (plugin->dbh, "PRAGMA page_size=4096");
-
   sqlite3_busy_timeout (plugin->dbh, BUSY_TIMEOUT_MS);
-
   /* Create tables */
-
   sql_exec (plugin->dbh,
-      "CREATE TABLE IF NOT EXISTS peerstoredata (\n"
-      "  sub_system TEXT NOT NULL,\n"
-      "  peer_id BLOB NOT NULL,\n"
-      "  key TEXT NOT NULL,\n"
-      "  value BLOB NULL,\n"
-      "  expiry sqlite3_uint64 NOT NULL"
-      ");");
-
-  sqlite3_create_function(plugin->dbh, "UINT64_LT", 2, SQLITE_UTF8, NULL, &sqlite3_lessthan, NULL, NULL);
-
+            "CREATE TABLE IF NOT EXISTS peerstoredata (\n"
+            "  sub_system TEXT NOT NULL,\n" "  peer_id BLOB NOT NULL,\n"
+            "  key TEXT NOT NULL,\n" "  value BLOB NULL,\n"
+            "  expiry sqlite3_uint64 NOT NULL" ");");
+  sqlite3_create_function (plugin->dbh, "UINT64_LT", 2, SQLITE_UTF8, NULL,
+                           &sqlite3_lessthan, NULL, NULL);
   /* Create Indices */
   if (SQLITE_OK !=
-      sqlite3_exec(plugin->dbh,
-        "CREATE INDEX IF NOT EXISTS peerstoredata_key_index ON peerstoredata (sub_system, peer_id, key)",
-        NULL, NULL, NULL))
+      sqlite3_exec (plugin->dbh,
+                    "CREATE INDEX IF NOT EXISTS peerstoredata_key_index ON peerstoredata (sub_system, peer_id, key)",
+                    NULL, NULL, NULL))
   {
-    LOG (GNUNET_ERROR_TYPE_ERROR,
-     _("Unable to create indices: %s.\n"),
-     sqlite3_errmsg (plugin->dbh));
-      return GNUNET_SYSERR;
+    LOG (GNUNET_ERROR_TYPE_ERROR, _("Unable to create indices: %s.\n"),
+         sqlite3_errmsg (plugin->dbh));
+    return GNUNET_SYSERR;
   }
-
   /* Prepare statements */
 
   sql_prepare (plugin->dbh,
-      "INSERT INTO peerstoredata (sub_system, peer_id, key, value, expiry) VALUES (?,?,?,?,?);",
-      &plugin->insert_peerstoredata);
-  sql_prepare(plugin->dbh,
-      "SELECT * FROM peerstoredata"
-      " WHERE sub_system = ?",
-      &plugin->select_peerstoredata);
-  sql_prepare(plugin->dbh,
-      "SELECT * FROM peerstoredata"
-      " WHERE sub_system = ?"
-      " AND peer_id = ?",
-      &plugin->select_peerstoredata_by_pid);
-  sql_prepare(plugin->dbh,
-      "SELECT * FROM peerstoredata"
-      " WHERE sub_system = ?"
-      " AND key = ?",
-      &plugin->select_peerstoredata_by_key);
-  sql_prepare(plugin->dbh,
-      "SELECT * FROM peerstoredata"
-      " WHERE sub_system = ?"
-      " AND peer_id = ?"
-      " AND key = ?",
-      &plugin->select_peerstoredata_by_all);
-  sql_prepare(plugin->dbh,
-      "DELETE FROM peerstoredata"
-      " WHERE UINT64_LT(expiry, ?)",
-      &plugin->expire_peerstoredata);
-  sql_prepare(plugin->dbh,
-      "DELETE FROM peerstoredata"
-      " WHERE sub_system = ?"
-      " AND peer_id = ?"
-      " AND key = ?",
-      &plugin->delete_peerstoredata);
-
+               "INSERT INTO peerstoredata (sub_system, peer_id, key, value, expiry) VALUES (?,?,?,?,?);",
+               &plugin->insert_peerstoredata);
+  sql_prepare (plugin->dbh,
+               "SELECT * FROM peerstoredata" " WHERE sub_system = ?",
+               &plugin->select_peerstoredata);
+  sql_prepare (plugin->dbh,
+               "SELECT * FROM peerstoredata" " WHERE sub_system = ?"
+               " AND peer_id = ?", &plugin->select_peerstoredata_by_pid);
+  sql_prepare (plugin->dbh,
+               "SELECT * FROM peerstoredata" " WHERE sub_system = ?"
+               " AND key = ?", &plugin->select_peerstoredata_by_key);
+  sql_prepare (plugin->dbh,
+               "SELECT * FROM peerstoredata" " WHERE sub_system = ?"
+               " AND peer_id = ?" " AND key = ?",
+               &plugin->select_peerstoredata_by_all);
+  sql_prepare (plugin->dbh,
+               "DELETE FROM peerstoredata" " WHERE UINT64_LT(expiry, ?)",
+               &plugin->expire_peerstoredata);
+  sql_prepare (plugin->dbh,
+               "DELETE FROM peerstoredata" " WHERE sub_system = ?"
+               " AND peer_id = ?" " AND key = ?",
+               &plugin->delete_peerstoredata);
   return GNUNET_OK;
 }
 
+
 /**
  * Shutdown database connection and associate data
  * structures.
@@ -521,19 +524,20 @@ database_shutdown (struct Plugin *plugin)
 {
   int result;
   sqlite3_stmt *stmt;
+
   while (NULL != (stmt = sqlite3_next_stmt (plugin->dbh, NULL)))
   {
     result = sqlite3_finalize (stmt);
     if (SQLITE_OK != result)
-      LOG (GNUNET_ERROR_TYPE_WARNING,
-           "Failed to close statement %p: %d\n", stmt, result);
+      LOG (GNUNET_ERROR_TYPE_WARNING, "Failed to close statement %p: %d\n",
+           stmt, result);
   }
   if (SQLITE_OK != sqlite3_close (plugin->dbh))
     LOG_SQLITE (plugin, GNUNET_ERROR_TYPE_ERROR, "sqlite3_close");
-
   GNUNET_free_non_null (plugin->fn);
 }
 
+
 /**
  * Entry point for the plugin.
  *
@@ -561,10 +565,11 @@ libgnunet_plugin_peerstore_sqlite_init (void *cls)
   api->store_record = &peerstore_sqlite_store_record;
   api->iterate_records = &peerstore_sqlite_iterate_records;
   api->expire_records = &peerstore_sqlite_expire_records;
-  LOG(GNUNET_ERROR_TYPE_DEBUG, "Sqlite plugin is running\n");
+  LOG (GNUNET_ERROR_TYPE_DEBUG, "Sqlite plugin is running\n");
   return api;
 }
 
+
 /**
  * Exit point from the plugin.
  *
@@ -582,7 +587,6 @@ libgnunet_plugin_peerstore_sqlite_done (void *cls)
   GNUNET_free (api);
   LOG (GNUNET_ERROR_TYPE_DEBUG, "Sqlite plugin is finished\n");
   return NULL;
-
 }
 
 /* end of plugin_peerstore_sqlite.c */