X-Git-Url: https://git.librecmc.org/?a=blobdiff_plain;f=src%2Fpeerstore%2Fplugin_peerstore_sqlite.c;h=2cd7e22cf1ad1e0dd9fcb2fc1394f0e27e93c7e1;hb=14848b88f7b0d6f0f35ae8d89304062a96fe03cc;hp=ac6d3093118c675e0f908be5eb8bc4ee7331f910;hpb=db2ee15ca4302b0e7fa78e318833cd136265b746;p=oweals%2Fgnunet.git diff --git a/src/peerstore/plugin_peerstore_sqlite.c b/src/peerstore/plugin_peerstore_sqlite.c index ac6d30931..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. */ /** @@ -90,147 +90,277 @@ struct Plugin /** * Precompiled SQL for selecting from peerstoredata */ - sqlite3_stmt *select_peerstoredata_by_ss; + sqlite3_stmt *select_peerstoredata_by_key; /** * Precompiled SQL for selecting from peerstoredata */ - sqlite3_stmt *select_peerstoredata_by_both; + 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; }; /** - * The given 'sqlite' statement has been prepared to be run. - * It will return a record which should be given to the iterator. - * Runs the statement and parses the returned record. + * Delete records with the given key * - * @param plugin plugin context - * @param stmt to run (and then clean up) - * @param iter iterator to call with the result - * @param iter_cls closure for @a iter - * @return #GNUNET_OK on success, #GNUNET_NO if there were no results, #GNUNET_SYSERR on error + * @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 -get_record_and_call_iterator (struct Plugin *plugin, - sqlite3_stmt *stmt, - GNUNET_PEERSTORE_RecordIterator iter, void *iter_cls) +peerstore_sqlite_delete_records (void *cls, const char *sub_system, + const struct GNUNET_PeerIdentity *peer, + const char *key) { - int ret; - int sret; - const struct GNUNET_PeerIdentity *pid; - const char *sub_system; - const void *value; - size_t value_size; - - ret = GNUNET_NO; - if (SQLITE_ROW == (sret = sqlite3_step (stmt))) + 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))) { - pid = sqlite3_column_blob(stmt, 0); - sub_system = (const char*) sqlite3_column_text(stmt, 1); - value = sqlite3_column_blob(stmt, 2); - value_size = sqlite3_column_bytes(stmt, 2); - if (NULL != iter) - iter (iter_cls, pid, sub_system, value, value_size); - ret = GNUNET_YES; + LOG_SQLITE (plugin, GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK, + "sqlite3_bind"); } - else + else if (SQLITE_DONE != sqlite3_step (stmt)) { - if (SQLITE_DONE != sret) - LOG_SQLITE (plugin, GNUNET_ERROR_TYPE_ERROR, "sqlite_step"); + 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 ret; + { + 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 sub system. + * and/or key. * * @param cls closure (internal context for the plugin) + * @param sub_system name of sub system * @param peer Peer identity (can be NULL) - * @param sub_system name of sub system (can be NULL) - * @param iter function to call with the result + * @param key entry key string (can be NULL) + * @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_NO if there were no results, #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 struct GNUNET_PeerIdentity *peer, - const char *sub_system, - GNUNET_PEERSTORE_RecordIterator 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; int err = 0; + int sret; + struct GNUNET_PEERSTORE_Record *ret; - if(NULL == sub_system && NULL == peer) + LOG (GNUNET_ERROR_TYPE_DEBUG, "Executing iterate request on sqlite db.\n"); + if (NULL == peer && NULL == key) + { stmt = plugin->select_peerstoredata; - else if(NULL == sub_system) + err = + (SQLITE_OK != + sqlite3_bind_text (stmt, 1, sub_system, strlen (sub_system) + 1, + SQLITE_STATIC)); + } + else if (NULL == key) { stmt = plugin->select_peerstoredata_by_pid; - err = (SQLITE_OK != sqlite3_bind_blob(stmt, 1, 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_ss; - err = (SQLITE_OK != sqlite3_bind_text(stmt, 1, sub_system, strlen(sub_system) + 1, SQLITE_STATIC)); + 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)); } else { - stmt = plugin->select_peerstoredata_by_both; + stmt = plugin->select_peerstoredata_by_all; err = - (SQLITE_OK != sqlite3_bind_blob(stmt, 1, peer, sizeof(struct GNUNET_PeerIdentity), SQLITE_STATIC)) - || (SQLITE_OK != sqlite3_bind_text(stmt, 2, sub_system, strlen(sub_system) + 1, SQLITE_STATIC)); + (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; } - return get_record_and_call_iterator (plugin, stmt, iter, iter_cls); + 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); + if (NULL != iter) + iter (iter_cls, ret, NULL); + GNUNET_free (ret->expiry); + GNUNET_free (ret); + } + if (SQLITE_DONE != sret) + { + LOG_SQLITE (plugin, GNUNET_ERROR_TYPE_ERROR, "sqlite_step"); + err = 1; + } + if (SQLITE_OK != sqlite3_reset (stmt)) + { + LOG_SQLITE (plugin, GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK, + "sqlite3_reset"); + err = 1; + } + 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) +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)) + 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, @@ -242,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; } @@ -255,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 * @@ -278,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 @@ -311,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)) @@ -326,57 +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" - ");"); - + "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) VALUES (?,?,?,?);", - &plugin->insert_peerstoredata); - sql_prepare(plugin->dbh, - "SELECT peer_id, sub_system, value FROM peerstoredata", - &plugin->select_peerstoredata); - sql_prepare(plugin->dbh, - "SELECT peer_id, sub_system, value FROM peerstoredata WHERE peer_id = ?", - &plugin->select_peerstoredata_by_pid); - sql_prepare(plugin->dbh, - "SELECT peer_id, sub_system, value FROM peerstoredata WHERE sub_system = ?", - &plugin->select_peerstoredata_by_ss); - sql_prepare(plugin->dbh, - "SELECT peer_id, sub_system, value FROM peerstoredata WHERE peer_id = ? AND sub_system = ?", - &plugin->select_peerstoredata_by_both); - + "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. @@ -387,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. * @@ -426,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. * @@ -447,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 */