X-Git-Url: https://git.librecmc.org/?a=blobdiff_plain;f=src%2Fdatacache%2Fplugin_datacache_sqlite.c;h=5567077d3fd8738ca4ff39f20e477d62b885d481;hb=2105059516320800eaa8fff1196b58f29a50ba7c;hp=34aa6136303d97be5ef45af2290e20abbc4eda85;hpb=3d7fefedc9ba60bd8e8448efe8b628446d958536;p=oweals%2Fgnunet.git diff --git a/src/datacache/plugin_datacache_sqlite.c b/src/datacache/plugin_datacache_sqlite.c index 34aa61363..5567077d3 100644 --- a/src/datacache/plugin_datacache_sqlite.c +++ b/src/datacache/plugin_datacache_sqlite.c @@ -1,6 +1,6 @@ /* This file is part of GNUnet - (C) 2006, 2009 Christian Grothoff (and other contributing authors) + Copyright (C) 2006, 2009, 2015 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. */ /** @@ -58,30 +58,52 @@ struct Plugin * Filename used for the DB. */ char *fn; + + /** + * Number of key-value pairs in the database. + */ + unsigned int num_items; }; /** - * Log an error message at log-level 'level' that indicates - * a failure of the command 'cmd' on file 'filename' - * with the message given by strerror(errno). + * Log an error message at log-level @a level that indicates + * a failure of the command @a cmd with the error from the database @a db + * + * @param db database handle + * @param level log level + * @param cmd failed command */ #define LOG_SQLITE(db, level, cmd) do { LOG (level, _("`%s' failed at %s:%d with error: %s\n"), cmd, __FILE__, __LINE__, sqlite3_errmsg(db)); } while(0) +/** + * Execute SQL statement. + * + * @param db database handle + * @param cmd SQL command to execute + */ #define SQLITE3_EXEC(db, cmd) do { emsg = NULL; if (SQLITE_OK != sqlite3_exec(db, cmd, NULL, NULL, &emsg)) { LOG (GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK, _("`%s' failed at %s:%d with error: %s\n"), "sqlite3_exec", __FILE__, __LINE__, emsg); sqlite3_free(emsg); } } while(0) /** * @brief Prepare a SQL statement + * + * @param dbh database handle + * @param zsql SQL statement text + * @param[out] ppStmt set to the prepared statement + * @return 0 on success */ static int -sq_prepare (sqlite3 * dbh, const char *zSql, /* SQL statement, UTF-8 encoded */ - sqlite3_stmt ** ppStmt) +sq_prepare (sqlite3 *dbh, + const char *zSql, /* SQL statement, UTF-8 encoded */ + sqlite3_stmt **ppStmt) { /* OUT: Statement handle */ char *dummy; - return sqlite3_prepare (dbh, zSql, strlen (zSql), ppStmt, + return sqlite3_prepare (dbh, + zSql, strlen (zSql), + ppStmt, (const char **) &dummy); } @@ -89,20 +111,21 @@ sq_prepare (sqlite3 * dbh, const char *zSql, /* SQL statement, UTF-8 encoded /** * Store an item in the datastore. * - * @param cls closure (our "struct Plugin") - * @param key key to store data under - * @param size number of bytes in data + * @param cls closure (our `struct Plugin`) + * @param key key to store @a data under + * @param size number of bytes in @a data * @param data data to store * @param type type of the value * @param discard_time when to discard the value in any case - * @param path_info_len number of entries in 'path_info' - * @param path_info array of peers that have processed the request + * @param path_info_len number of entries in @a path_info + * @param path_info array of peers that have processed the request * @return 0 if duplicate, -1 on error, number of bytes used otherwise */ static ssize_t sqlite_plugin_put (void *cls, const struct GNUNET_HashCode *key, - size_t size, const char *data, + size_t size, + const char *data, enum GNUNET_BLOCK_Type type, struct GNUNET_TIME_Absolute discard_time, unsigned int path_info_len, @@ -113,8 +136,9 @@ sqlite_plugin_put (void *cls, int64_t dval; LOG (GNUNET_ERROR_TYPE_DEBUG, - "Processing `%s' of %u bytes with key `%4s' and expiration %s\n", - "PUT", (unsigned int) size, GNUNET_h2s (key), + "Processing PUT of %u bytes with key `%4s' and expiration %s\n", + (unsigned int) size, + GNUNET_h2s (key), GNUNET_STRINGS_relative_time_to_string (GNUNET_TIME_absolute_get_remaining (discard_time), GNUNET_YES)); dval = (int64_t) discard_time.abs_value_us; if (dval < 0) @@ -124,7 +148,8 @@ sqlite_plugin_put (void *cls, "INSERT INTO ds090 (type, expire, key, value, path) VALUES (?, ?, ?, ?, ?)", &stmt) != SQLITE_OK) { - LOG_SQLITE (plugin->dbh, GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK, + LOG_SQLITE (plugin->dbh, + GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK, "sq_prepare"); return -1; } @@ -135,27 +160,31 @@ sqlite_plugin_put (void *cls, key, sizeof (struct GNUNET_HashCode), SQLITE_TRANSIENT)) || (SQLITE_OK != sqlite3_bind_blob (stmt, 4, - data, size, + data, size, SQLITE_TRANSIENT)) || - (SQLITE_OK != sqlite3_bind_blob (stmt, 5, - path_info, - path_info_len * sizeof (struct GNUNET_PeerIdentity), + (SQLITE_OK != sqlite3_bind_blob (stmt, 5, + path_info, + path_info_len * sizeof (struct GNUNET_PeerIdentity), SQLITE_TRANSIENT))) { - LOG_SQLITE (plugin->dbh, GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK, + LOG_SQLITE (plugin->dbh, + GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK, "sqlite3_bind_xxx"); sqlite3_finalize (stmt); return -1; } if (SQLITE_DONE != sqlite3_step (stmt)) { - LOG_SQLITE (plugin->dbh, GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK, + LOG_SQLITE (plugin->dbh, + GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK, "sqlite3_step"); sqlite3_finalize (stmt); return -1; } + plugin->num_items++; if (SQLITE_OK != sqlite3_finalize (stmt)) - LOG_SQLITE (plugin->dbh, GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK, + LOG_SQLITE (plugin->dbh, + GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK, "sqlite3_finalize"); return size + OVERHEAD; } @@ -165,16 +194,18 @@ sqlite_plugin_put (void *cls, * Iterate over the results for a particular key * in the datastore. * - * @param cls closure (our "struct Plugin") + * @param cls closure (our `struct Plugin`) * @param key * @param type entries of which type are relevant? * @param iter maybe NULL (to just count) - * @param iter_cls closure for iter + * @param iter_cls closure for @a iter * @return the number of results found */ static unsigned int -sqlite_plugin_get (void *cls, const struct GNUNET_HashCode * key, - enum GNUNET_BLOCK_Type type, GNUNET_DATACACHE_Iterator iter, +sqlite_plugin_get (void *cls, + const struct GNUNET_HashCode *key, + enum GNUNET_BLOCK_Type type, + GNUNET_DATACACHE_Iterator iter, void *iter_cls) { struct Plugin *plugin = cls; @@ -192,14 +223,16 @@ sqlite_plugin_get (void *cls, const struct GNUNET_HashCode * key, const struct GNUNET_PeerIdentity *path; now = GNUNET_TIME_absolute_get (); - LOG (GNUNET_ERROR_TYPE_DEBUG, "Processing `%s' for key `%4s'\n", "GET", + LOG (GNUNET_ERROR_TYPE_DEBUG, + "Processing GET for key `%4s'\n", GNUNET_h2s (key)); if (sq_prepare (plugin->dbh, "SELECT count(*) FROM ds090 WHERE key=? AND type=? AND expire >= ?", &stmt) != SQLITE_OK) { - LOG_SQLITE (plugin->dbh, GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK, + LOG_SQLITE (plugin->dbh, + GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK, "sq_prepare"); return 0; } @@ -211,7 +244,8 @@ sqlite_plugin_get (void *cls, const struct GNUNET_HashCode * key, (SQLITE_OK != sqlite3_bind_int (stmt, 2, type)) || (SQLITE_OK != sqlite3_bind_int64 (stmt, 3, now.abs_value_us))) { - LOG_SQLITE (plugin->dbh, GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK, + LOG_SQLITE (plugin->dbh, + GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK, "sqlite3_bind_xxx"); sqlite3_finalize (stmt); return 0; @@ -223,17 +257,17 @@ sqlite_plugin_get (void *cls, const struct GNUNET_HashCode * key, "sqlite_step"); sqlite3_finalize (stmt); LOG (GNUNET_ERROR_TYPE_DEBUG, - "No content found when processing `%s' for key `%4s'\n", "GET", + "No content found when processing GET for key `%4s'\n", GNUNET_h2s (key)); return 0; } total = sqlite3_column_int (stmt, 0); sqlite3_finalize (stmt); - if ((total == 0) || (iter == NULL)) + if ((0 == total) || (NULL == iter)) { if (0 == total) LOG (GNUNET_ERROR_TYPE_DEBUG, - "No content found when processing `%s' for key `%4s'\n", "GET", + "No content found when processing GET for key `%4s'\n", GNUNET_h2s (key)); return total; } @@ -248,17 +282,21 @@ sqlite_plugin_get (void *cls, const struct GNUNET_HashCode * key, off); if (sq_prepare (plugin->dbh, scratch, &stmt) != SQLITE_OK) { - LOG_SQLITE (plugin->dbh, GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK, + LOG_SQLITE (plugin->dbh, + GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK, "sq_prepare"); return cnt; } if ((SQLITE_OK != - sqlite3_bind_blob (stmt, 1, key, sizeof (struct GNUNET_HashCode), + sqlite3_bind_blob (stmt, 1, + key, + sizeof (struct GNUNET_HashCode), SQLITE_TRANSIENT)) || (SQLITE_OK != sqlite3_bind_int (stmt, 2, type)) || (SQLITE_OK != sqlite3_bind_int64 (stmt, 3, now.abs_value_us))) { - LOG_SQLITE (plugin->dbh, GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK, + LOG_SQLITE (plugin->dbh, + GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK, "sqlite3_bind_xxx"); sqlite3_finalize (stmt); return cnt; @@ -284,9 +322,17 @@ sqlite_plugin_get (void *cls, const struct GNUNET_HashCode * key, exp = GNUNET_TIME_UNIT_FOREVER_ABS; cnt++; LOG (GNUNET_ERROR_TYPE_DEBUG, - "Found %u-byte result when processing `%s' for key `%4s'\n", - (unsigned int) size, "GET", GNUNET_h2s (key)); - if (GNUNET_OK != iter (iter_cls, key, size, dat, type, exp, psize, path)) + "Found %u-byte result when processing GET for key `%4s'\n", + (unsigned int) size, + GNUNET_h2s (key)); + if (GNUNET_OK != iter (iter_cls, + key, + size, + dat, + type, + exp, + psize, + path)) { sqlite3_finalize (stmt); break; @@ -301,8 +347,8 @@ sqlite_plugin_get (void *cls, const struct GNUNET_HashCode * key, * Delete the entry with the lowest expiration value * from the datacache right now. * - * @param cls closure (our "struct Plugin") - * @return GNUNET_OK on success, GNUNET_SYSERR on error + * @param cls closure (our `struct Plugin`) + * @return #GNUNET_OK on success, #GNUNET_SYSERR on error */ static int sqlite_plugin_del (void *cls) @@ -314,15 +360,17 @@ sqlite_plugin_del (void *cls) sqlite3_stmt *dstmt; struct GNUNET_HashCode hc; - LOG (GNUNET_ERROR_TYPE_DEBUG, "Processing `%s'\n", "DEL"); + LOG (GNUNET_ERROR_TYPE_DEBUG, + "Processing DEL\n"); stmt = NULL; dstmt = NULL; - if (sq_prepare - (plugin->dbh, - "SELECT _ROWID_,key,value FROM ds090 ORDER BY expire ASC LIMIT 1", - &stmt) != SQLITE_OK) + if (SQLITE_OK != + sq_prepare (plugin->dbh, + "SELECT _ROWID_,key,value FROM ds090 ORDER BY expire ASC LIMIT 1", + &stmt)) { - LOG_SQLITE (plugin->dbh, GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK, + LOG_SQLITE (plugin->dbh, + GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK, "sq_prepare"); if (stmt != NULL) (void) sqlite3_finalize (stmt); @@ -330,22 +378,26 @@ sqlite_plugin_del (void *cls) } if (SQLITE_ROW != sqlite3_step (stmt)) { - LOG_SQLITE (plugin->dbh, GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK, + LOG_SQLITE (plugin->dbh, + GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK, "sqlite3_step"); (void) sqlite3_finalize (stmt); return GNUNET_SYSERR; } rowid = sqlite3_column_int64 (stmt, 0); GNUNET_assert (sqlite3_column_bytes (stmt, 1) == sizeof (struct GNUNET_HashCode)); - memcpy (&hc, sqlite3_column_blob (stmt, 1), sizeof (struct GNUNET_HashCode)); + GNUNET_memcpy (&hc, sqlite3_column_blob (stmt, 1), sizeof (struct GNUNET_HashCode)); dsize = sqlite3_column_bytes (stmt, 2); if (SQLITE_OK != sqlite3_finalize (stmt)) - LOG_SQLITE (plugin->dbh, GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK, + LOG_SQLITE (plugin->dbh, + GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK, "sqlite3_step"); - if (sq_prepare (plugin->dbh, "DELETE FROM ds090 WHERE _ROWID_=?", &dstmt) != - SQLITE_OK) + if (SQLITE_OK != + sq_prepare (plugin->dbh, + "DELETE FROM ds090 WHERE _ROWID_=?", &dstmt)) { - LOG_SQLITE (plugin->dbh, GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK, + LOG_SQLITE (plugin->dbh, + GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK, "sq_prepare"); if (stmt != NULL) (void) sqlite3_finalize (stmt); @@ -353,31 +405,241 @@ sqlite_plugin_del (void *cls) } if (SQLITE_OK != sqlite3_bind_int64 (dstmt, 1, rowid)) { - LOG_SQLITE (plugin->dbh, GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK, + LOG_SQLITE (plugin->dbh, + GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK, "sqlite3_bind"); (void) sqlite3_finalize (dstmt); return GNUNET_SYSERR; } - if (sqlite3_step (dstmt) != SQLITE_DONE) + if (SQLITE_DONE != sqlite3_step (dstmt)) { - LOG_SQLITE (plugin->dbh, GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK, + LOG_SQLITE (plugin->dbh, + GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK, "sqlite3_step"); (void) sqlite3_finalize (dstmt); return GNUNET_SYSERR; } - plugin->env->delete_notify (plugin->env->cls, &hc, dsize + OVERHEAD); + plugin->num_items--; + plugin->env->delete_notify (plugin->env->cls, + &hc, + dsize + OVERHEAD); if (SQLITE_OK != sqlite3_finalize (dstmt)) - LOG_SQLITE (plugin->dbh, GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK, + LOG_SQLITE (plugin->dbh, + GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK, "sqlite3_finalize"); return GNUNET_OK; } +/** + * Obtain a random key-value pair from the datacache. + * + * @param cls closure (our `struct Plugin`) + * @param iter maybe NULL (to just count) + * @param iter_cls closure for @a iter + * @return the number of results found, zero (datacache empty) or one + */ +static unsigned int +sqlite_plugin_get_random (void *cls, + GNUNET_DATACACHE_Iterator iter, + void *iter_cls) +{ + struct Plugin *plugin = cls; + sqlite3_stmt *stmt; + struct GNUNET_TIME_Absolute exp; + unsigned int size; + const char *dat; + unsigned int off; + unsigned int psize; + unsigned int type; + char scratch[256]; + int64_t ntime; + const struct GNUNET_PeerIdentity *path; + const struct GNUNET_HashCode *key; + + if (0 == plugin->num_items) + return 0; + if (NULL == iter) + return 1; + off = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_NONCE, + plugin->num_items); + GNUNET_snprintf (scratch, + sizeof (scratch), + "SELECT value,expire,path,key,type FROM ds090 ORDER BY key LIMIT 1 OFFSET %u", + off); + if (SQLITE_OK != + sq_prepare (plugin->dbh, scratch, &stmt)) + { + LOG_SQLITE (plugin->dbh, + GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK, + "sq_prepare"); + return 0; + } + if (SQLITE_ROW != sqlite3_step (stmt)) + { + GNUNET_break (0); + sqlite3_finalize (stmt); + return 0; + } + size = sqlite3_column_bytes (stmt, 0); + dat = sqlite3_column_blob (stmt, 0); + exp.abs_value_us = sqlite3_column_int64 (stmt, 1); + psize = sqlite3_column_bytes (stmt, 2); + if (0 != psize % sizeof (struct GNUNET_PeerIdentity)) + { + GNUNET_break (0); + psize = 0; + } + psize /= sizeof (struct GNUNET_PeerIdentity); + if (0 != psize) + path = sqlite3_column_blob (stmt, 2); + else + path = NULL; + + GNUNET_assert (sizeof (struct GNUNET_HashCode) == + sqlite3_column_bytes (stmt, 3)); + key = sqlite3_column_blob (stmt, 3); + type = sqlite3_column_int (stmt, 4); + + ntime = (int64_t) exp.abs_value_us; + if (ntime == INT64_MAX) + exp = GNUNET_TIME_UNIT_FOREVER_ABS; + LOG (GNUNET_ERROR_TYPE_DEBUG, + "Found %u-byte result with key %s when processing GET-RANDOM\n", + (unsigned int) size, + GNUNET_h2s (key)); + (void) iter (iter_cls, + key, + size, + dat, + type, + exp, + psize, + path); + sqlite3_finalize (stmt); + return 1; +} + + +/** + * Iterate over the results that are "close" to a particular key in + * the datacache. "close" is defined as numerically larger than @a + * key (when interpreted as a circular address space), with small + * distance. + * + * @param cls closure (internal context for the plugin) + * @param key area of the keyspace to look into + * @param num_results number of results that should be returned to @a iter + * @param iter maybe NULL (to just count) + * @param iter_cls closure for @a iter + * @return the number of results found + */ +static unsigned int +sqlite_plugin_get_closest (void *cls, + const struct GNUNET_HashCode *key, + unsigned int num_results, + GNUNET_DATACACHE_Iterator iter, + void *iter_cls) +{ + struct Plugin *plugin = cls; + sqlite3_stmt *stmt; + struct GNUNET_TIME_Absolute now; + struct GNUNET_TIME_Absolute exp; + unsigned int size; + const char *dat; + unsigned int cnt; + unsigned int psize; + unsigned int type; + int64_t ntime; + const struct GNUNET_PeerIdentity *path; + + now = GNUNET_TIME_absolute_get (); + LOG (GNUNET_ERROR_TYPE_DEBUG, + "Processing GET_CLOSEST for key `%4s'\n", + GNUNET_h2s (key)); + if (SQLITE_OK != + sq_prepare (plugin->dbh, + "SELECT value,expire,path,type,key FROM ds090 WHERE key>=? AND expire >= ? ORDER BY KEY ASC LIMIT ?", + &stmt)) + { + LOG_SQLITE (plugin->dbh, + GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK, + "sq_prepare"); + return 0; + } + ntime = (int64_t) now.abs_value_us; + GNUNET_assert (ntime >= 0); + if ((SQLITE_OK != + sqlite3_bind_blob (stmt, + 1, + key, + sizeof (struct GNUNET_HashCode), + SQLITE_TRANSIENT)) || + (SQLITE_OK != sqlite3_bind_int64 (stmt, 2, now.abs_value_us)) || + (SQLITE_OK != sqlite3_bind_int (stmt, 3, num_results)) ) + { + LOG_SQLITE (plugin->dbh, + GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK, + "sqlite3_bind_xxx"); + sqlite3_finalize (stmt); + return 0; + } + cnt = 0; + while (SQLITE_ROW == sqlite3_step (stmt)) + { + if (sizeof (struct GNUNET_HashCode) != + sqlite3_column_bytes (stmt, 4)) + { + GNUNET_break (0); + break; + } + size = sqlite3_column_bytes (stmt, 0); + dat = sqlite3_column_blob (stmt, 0); + exp.abs_value_us = sqlite3_column_int64 (stmt, 1); + psize = sqlite3_column_bytes (stmt, 2); + type = sqlite3_column_int (stmt, 3); + key = sqlite3_column_blob (stmt, 4); + if (0 != psize % sizeof (struct GNUNET_PeerIdentity)) + { + GNUNET_break (0); + psize = 0; + } + psize /= sizeof (struct GNUNET_PeerIdentity); + if (0 != psize) + path = sqlite3_column_blob (stmt, 2); + else + path = NULL; + ntime = (int64_t) exp.abs_value_us; + if (ntime == INT64_MAX) + exp = GNUNET_TIME_UNIT_FOREVER_ABS; + cnt++; + LOG (GNUNET_ERROR_TYPE_DEBUG, + "Found %u-byte result at %s when processing GET_CLOSE\n", + (unsigned int) size, + GNUNET_h2s (key)); + if (GNUNET_OK != iter (iter_cls, + key, + size, + dat, + type, + exp, + psize, + path)) + { + sqlite3_finalize (stmt); + break; + } + } + sqlite3_finalize (stmt); + return cnt; +} + + /** * Entry point for the plugin. * - * @param cls closure (the "struct GNUNET_DATACACHE_PluginEnvironmnet") - * @return the plugin's closure (our "struct Plugin") + * @param cls closure (the `struct GNUNET_DATACACHE_PluginEnvironment`) + * @return the plugin's closure (our `struct Plugin`) */ void * libgnunet_plugin_datacache_sqlite_init (void *cls) @@ -422,7 +684,6 @@ libgnunet_plugin_datacache_sqlite_init (void *cls) SQLITE3_EXEC (dbh, "PRAGMA locking_mode=EXCLUSIVE"); SQLITE3_EXEC (dbh, "PRAGMA journal_mode=OFF"); SQLITE3_EXEC (dbh, "PRAGMA synchronous=OFF"); - SQLITE3_EXEC (dbh, "PRAGMA count_changes=OFF"); SQLITE3_EXEC (dbh, "PRAGMA page_size=4092"); if (GNUNET_YES == GNUNET_CONFIGURATION_get_value_yesno (env->cfg, @@ -438,16 +699,19 @@ libgnunet_plugin_datacache_sqlite_init (void *cls) " path BLOB DEFAULT '')"); SQLITE3_EXEC (dbh, "CREATE INDEX idx_hashidx ON ds090 (key,type,expire)"); SQLITE3_EXEC (dbh, "CREATE INDEX idx_expire ON ds090 (expire)"); - plugin = GNUNET_malloc (sizeof (struct Plugin)); + plugin = GNUNET_new (struct Plugin); plugin->env = env; plugin->dbh = dbh; plugin->fn = fn_utf8; - api = GNUNET_malloc (sizeof (struct GNUNET_DATACACHE_PluginFunctions)); + api = GNUNET_new (struct GNUNET_DATACACHE_PluginFunctions); api->cls = plugin; api->get = &sqlite_plugin_get; api->put = &sqlite_plugin_put; api->del = &sqlite_plugin_del; - LOG (GNUNET_ERROR_TYPE_INFO, _("Sqlite datacache running\n")); + api->get_random = &sqlite_plugin_get_random; + api->get_closest = &sqlite_plugin_get_closest; + LOG (GNUNET_ERROR_TYPE_INFO, + "Sqlite datacache running\n"); return api; } @@ -455,7 +719,7 @@ libgnunet_plugin_datacache_sqlite_init (void *cls) /** * Exit point from the plugin. * - * @param cls closure (our "struct Plugin") + * @param cls closure (our `struct Plugin`) * @return NULL */ void * @@ -472,36 +736,42 @@ libgnunet_plugin_datacache_sqlite_done (void *cls) #if !WINDOWS || defined(__CYGWIN__) if ( (NULL != plugin->fn) && (0 != UNLINK (plugin->fn)) ) - LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_WARNING, "unlink", plugin->fn); + LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_WARNING, + "unlink", + plugin->fn); GNUNET_free_non_null (plugin->fn); #endif result = sqlite3_close (plugin->dbh); #if SQLITE_VERSION_NUMBER >= 3007000 - if (result == SQLITE_BUSY) + if (SQLITE_BUSY == result) { LOG (GNUNET_ERROR_TYPE_WARNING, - _ - ("Tried to close sqlite without finalizing all prepared statements.\n")); + _("Tried to close sqlite without finalizing all prepared statements.\n")); stmt = sqlite3_next_stmt (plugin->dbh, NULL); - while (stmt != NULL) + while (NULL != stmt) { - LOG (GNUNET_ERROR_TYPE_DEBUG, "Closing statement %p\n", stmt); result = sqlite3_finalize (stmt); if (result != SQLITE_OK) - 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); stmt = sqlite3_next_stmt (plugin->dbh, NULL); } result = sqlite3_close (plugin->dbh); } #endif if (SQLITE_OK != result) - LOG_SQLITE (plugin->dbh, GNUNET_ERROR_TYPE_ERROR, "sqlite3_close"); + LOG_SQLITE (plugin->dbh, + GNUNET_ERROR_TYPE_ERROR, + "sqlite3_close"); #if WINDOWS && !defined(__CYGWIN__) if ( (NULL != plugin->fn) && (0 != UNLINK (plugin->fn)) ) - LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_WARNING, "unlink", plugin->fn); + LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_WARNING, + "unlink", + plugin->fn); GNUNET_free_non_null (plugin->fn); #endif GNUNET_free (plugin);