X-Git-Url: https://git.librecmc.org/?a=blobdiff_plain;f=src%2Fpeerstore%2Fplugin_peerstore_sqlite.c;h=2cd7e22cf1ad1e0dd9fcb2fc1394f0e27e93c7e1;hb=f249a80a2b1e52b24969782e8afb30b86c373ae2;hp=1ae8301b2a5c418270bb8f16dc57095d15a37dda;hpb=7eb684ec9f93d52ebae09729fcf01c16580b5cb9;p=oweals%2Fgnunet.git diff --git a/src/peerstore/plugin_peerstore_sqlite.c b/src/peerstore/plugin_peerstore_sqlite.c index 1ae8301b2..2cd7e22cf 100644 --- a/src/peerstore/plugin_peerstore_sqlite.c +++ b/src/peerstore/plugin_peerstore_sqlite.c @@ -1,6 +1,6 @@ /* * This file is part of GNUnet - * (C) 2013 Christian Grothoff (and other contributing authors) + * Copyright (C) 2013 GNUnet e.V. * * GNUnet is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published @@ -14,8 +14,8 @@ * * 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. + * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + * Boston, MA 02110-1301, USA. */ /** @@ -97,8 +97,107 @@ struct Plugin */ sqlite3_stmt *select_peerstoredata_by_all; + /** + * Precompiled SQL for deleting expired + * records from peerstoredata + */ + sqlite3_stmt *expire_peerstoredata; + + /** + * Precompiled SQL for deleting records + * with given key + */ + sqlite3_stmt *delete_peerstoredata; + }; +/** + * Delete records with the given key + * + * @param cls closure (internal context for the plugin) + * @param sub_system name of sub system + * @param peer Peer identity (can be NULL) + * @param key entry key string (can be NULL) + * @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) +{ + 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))) + { + LOG_SQLITE (plugin, GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK, + "sqlite3_bind"); + } + else if (SQLITE_DONE != sqlite3_step (stmt)) + { + LOG_SQLITE (plugin, GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK, + "sqlite3_step"); + } + if (SQLITE_OK != sqlite3_reset (stmt)) + { + LOG_SQLITE (plugin, GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK, + "sqlite3_reset"); + return 0; + } + return sqlite3_changes (plugin->dbh); +} + + +/** + * Delete expired records (expiry < now) + * + * @param cls closure (internal context for the plugin) + * @param now time to use as reference + * @param cont continuation called with the number of records expired + * @param cont_cls continuation closure + * @return #GNUNET_OK on success, #GNUNET_SYSERR on error and cont is not + * called + */ +static int +peerstore_sqlite_expire_records (void *cls, struct GNUNET_TIME_Absolute now, + GNUNET_PEERSTORE_Continuation cont, + void *cont_cls) +{ + struct Plugin *plugin = cls; + sqlite3_stmt *stmt = plugin->expire_peerstoredata; + + 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"); + } + else if (SQLITE_DONE != sqlite3_step (stmt)) + { + LOG_SQLITE (plugin, GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK, + "sqlite3_step"); + } + if (SQLITE_OK != sqlite3_reset (stmt)) + { + LOG_SQLITE (plugin, GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK, + "sqlite3_reset"); + return GNUNET_SYSERR; + } + if (NULL != cont) + { + cont (cont_cls, sqlite3_changes (plugin->dbh)); + } + return GNUNET_OK; +} + + /** * Iterate over the records given an optional peer id * and/or key. @@ -107,16 +206,18 @@ struct Plugin * @param sub_system name of sub system * @param peer Peer identity (can be NULL) * @param key entry key string (can be NULL) - * @param iter function to call with the result + * @param iter function to call asynchronously with the results, terminated + * by a NULL result * @param iter_cls closure for @a iter - * @return #GNUNET_OK on success, #GNUNET_SYSERR on error + * @return #GNUNET_OK on success, #GNUNET_SYSERR on error and iter is not + * called */ 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; @@ -124,55 +225,76 @@ peerstore_sqlite_iterate_records (void *cls, int sret; struct GNUNET_PEERSTORE_Record *ret; - 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, 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_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))) { - 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); + iter (iter_cls, ret, NULL); + GNUNET_free (ret->expiry); + GNUNET_free (ret); } if (SQLITE_DONE != sret) { @@ -181,49 +303,64 @@ 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) - return GNUNET_SYSERR; + if (NULL != iter) + { + iter (iter_cls, NULL, err ? "sqlite error" : NULL); + } return GNUNET_OK; } + /** * Store a record in the peerstore. * Key is the combination of sub system and peer identity. * One key can store multiple values. * * @param cls closure (internal context for the plugin) - * @param peer peer identity * @param sub_system name of the GNUnet sub system responsible + * @param peer peer identity + * @param key record key string * @param value value to be stored * @param size size of value to be stored - * @return #GNUNET_OK on success, else #GNUNET_SYSERR + * @param expiry absolute time after which the record is (possibly) deleted + * @param options options related to the store operation + * @param cont continuation called when record is stored + * @param cont_cls continuation closure + * @return #GNUNET_OK on success, else #GNUNET_SYSERR and cont is not called */ static int -peerstore_sqlite_store_record(void *cls, - const char *sub_system, - const struct GNUNET_PeerIdentity *peer, - const char *key, - const void *value, - size_t size, - struct GNUNET_TIME_Absolute expiry) +peerstore_sqlite_store_record (void *cls, const char *sub_system, + const struct GNUNET_PeerIdentity *peer, + const char *key, const void *value, size_t size, + struct GNUNET_TIME_Absolute expiry, + enum GNUNET_PEERSTORE_StoreOption options, + GNUNET_PEERSTORE_Continuation cont, + void *cont_cls) { struct Plugin *plugin = cls; sqlite3_stmt *stmt = plugin->insert_peerstoredata; - //FIXME: check if value exists with the same key first - - 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_int64)expiry.abs_value_us)) + if (GNUNET_PEERSTORE_STOREOPTION_REPLACE == options) + { + 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)) 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, @@ -235,7 +372,10 @@ peerstore_sqlite_store_record(void *cls, "sqlite3_reset"); return GNUNET_SYSERR; } - + if (NULL != cont) + { + cont (cont_cls, GNUNET_OK); + } return GNUNET_OK; } @@ -248,20 +388,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 * @@ -271,22 +410,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) +{ + 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); +} + + /** * Initialize the database connections and associated * data structures (create tables and indices @@ -304,8 +458,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)) @@ -319,66 +473,67 @@ 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=NORMAL"); + sql_exec (plugin->dbh, "PRAGMA synchronous=OFF"); sql_exec (plugin->dbh, "PRAGMA legacy_file_format=OFF"); sql_exec (plugin->dbh, "PRAGMA auto_vacuum=INCREMENTAL"); 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 INTEGER NOT 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)) + { + 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); - + "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. @@ -389,19 +544,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. * @@ -428,10 +584,12 @@ libgnunet_plugin_peerstore_sqlite_init (void *cls) api->cls = &plugin; api->store_record = &peerstore_sqlite_store_record; api->iterate_records = &peerstore_sqlite_iterate_records; - LOG(GNUNET_ERROR_TYPE_DEBUG, "Sqlite plugin is running\n"); + api->expire_records = &peerstore_sqlite_expire_records; + LOG (GNUNET_ERROR_TYPE_DEBUG, "Sqlite plugin is running\n"); return api; } + /** * Exit point from the plugin. * @@ -449,7 +607,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 */