sqlite-based datastore backend More...

#include "platform.h"
#include "gnunet_datastore_plugin.h"
#include "gnunet_sq_lib.h"
#include <sqlite3.h>

Include dependency graph for plugin_datastore_sqlite.c:

Data Structures
struct	Plugin
	Handle for a plugin. More...

struct	ReplCtx
	Context for #repl_iter() function. More...

Macros
#define	MAX_ITEM_SIZE 65536
	We allocate items on the stack at times. More...

#define	BUSY_TIMEOUT_MS 250
	After how many ms "busy" should a DB operation fail for good? A low value makes sure that we are more responsive to requests (especially PUTs). More...

#define	LOG_SQLITE(db, level, cmd)
	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). More...

#define	LOG_SQLITE_MSG(db, msg, level, cmd)
	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). More...

#define	ENULL &e

#define	ENULL_DEFINED 1

#define	CHECK(a)

#define	RESULT_COLUMNS "repl, type, prio, anonLevel, expire, hash, value, _ROWID_"

Functions
static int	sq_prepare (sqlite3 dbh, const char zSql, sqlite3_stmt **ppStmt)
	Prepare a SQL statement. More...

static void	create_indices (sqlite3 *dbh)
	Create our database indices. More...

static int	database_setup (const struct GNUNET_CONFIGURATION_Handle cfg, struct Plugin plugin)
	Initialize the database connections and associated data structures (create tables and indices as needed as well). More...

static void	database_shutdown (struct Plugin *plugin)
	Shutdown database connection and associate data structures. More...

static int	delete_by_rowid (struct Plugin *plugin, uint64_t rid)
	Delete the database entry with the given row identifier. More...

static void	sqlite_plugin_put (void cls, const struct GNUNET_HashCode key, bool absent, 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, PluginPutCont cont, void cont_cls)
	Store an item in the datastore. More...

static void	execute_get (struct Plugin plugin, sqlite3_stmt stmt, PluginDatumProcessor proc, void *proc_cls)
	Execute statement that gets a row and call the callback with the result. More...

static void	sqlite_plugin_get_zero_anonymity (void cls, uint64_t next_uid, enum GNUNET_BLOCK_Type type, PluginDatumProcessor proc, void proc_cls)
	Select a subset of the items in the datastore and call the given processor for the item. More...

static void	sqlite_plugin_get_key (void cls, uint64_t next_uid, bool random, const struct GNUNET_HashCode key, enum GNUNET_BLOCK_Type type, PluginDatumProcessor proc, void *proc_cls)
	Get results for a particular key in the datastore. More...

static int	repl_proc (void cls, const struct 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, uint64_t uid)
	Wrapper for the processor for sqlite_plugin_get_replication(). More...

static void	sqlite_plugin_get_replication (void cls, PluginDatumProcessor proc, void proc_cls)
	Get a random item for replication. More...

static void	sqlite_plugin_get_expiration (void cls, PluginDatumProcessor proc, void proc_cls)
	Get a random item that has expired or has low priority. More...

static void	sqlite_plugin_get_keys (void cls, PluginKeyProcessor proc, void proc_cls)
	Get all of the keys in the datastore. More...

static void	sqlite_plugin_drop (void *cls)
	Drop database. More...

static void	sqlite_plugin_remove_key (void cls, const struct GNUNET_HashCode key, uint32_t size, const void data, PluginRemoveCont cont, void cont_cls)
	Remove a particular key in the datastore. More...

static void	sqlite_plugin_estimate_size (void cls, unsigned long long estimate)
	Get an estimate of how much space the database is currently using. More...

void *	libgnunet_plugin_datastore_sqlite_init (void *cls)
	Entry point for the plugin. More...

void *	libgnunet_plugin_datastore_sqlite_done (void *cls)
	Exit point from the plugin. More...

Detailed Description

sqlite-based datastore backend

Author: Christian Grothoff

Definition in file plugin_datastore_sqlite.c.

Macro Definition Documentation

◆ MAX_ITEM_SIZE

#define MAX_ITEM_SIZE 65536

We allocate items on the stack at times.

To prevent a stack overflow, we impose a limit on the maximum size for the data per item. 64k should be enough.

Definition at line 38 of file plugin_datastore_sqlite.c.

◆ BUSY_TIMEOUT_MS

#define BUSY_TIMEOUT_MS 250

After how many ms "busy" should a DB operation fail for good? A low value makes sure that we are more responsive to requests (especially PUTs).

A high value guarantees a higher success rate (SELECTs in iterate can take several seconds despite LIMIT=1).

The default value of 250ms should ensure that users do not experience huge latencies while at the same time allowing operations to succeed with reasonable probability.

Definition at line 50 of file plugin_datastore_sqlite.c.

◆ LOG_SQLITE

#define LOG_SQLITE	(	db,
		level,
		cmd
	)

Value:

  do                                                              \
  {                                                               \
    GNUNET_log_from (level,                                       \
                     "sqlite",                                    \
                     _ ("`%s' failed at %s:%d with error: %s\n"), \
                     cmd,                                         \
                     __FILE__,                                    \
                     __LINE__,                                    \
                     sqlite3_errmsg (db->dbh));                   \
  } while (0)

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).

Definition at line 58 of file plugin_datastore_sqlite.c.

◆ LOG_SQLITE_MSG

#define LOG_SQLITE_MSG	(	db,
		msg,
		level,
		cmd
	)

Value:

  do                                                              \
  {                                                               \
    GNUNET_log_from (level,                                       \
                     "sqlite",                                    \
                     _ ("`%s' failed at %s:%d with error: %s\n"), \
                     cmd,                                         \
                     __FILE__,                                    \
                     __LINE__,                                    \
                     sqlite3_errmsg (db->dbh));                   \
    GNUNET_asprintf (msg,                                         \
                     _ ("`%s' failed at %s:%u with error: %s"),   \
                     cmd,                                         \
                     __FILE__,                                    \
                     __LINE__,                                    \
                     sqlite3_errmsg (db->dbh));                   \
  } while (0)

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).

Definition at line 76 of file plugin_datastore_sqlite.c.

◆ ENULL

#define ENULL &e

Definition at line 249 of file plugin_datastore_sqlite.c.

◆ ENULL_DEFINED

#define ENULL_DEFINED 1

Definition at line 250 of file plugin_datastore_sqlite.c.

◆ CHECK

#define CHECK ( a )

Value:

  if (! (a))                                         \
  {                                                  \
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "%s\n", e); \
    sqlite3_free (e);                                \
    e = NULL;                                        \
  }

Definition at line 251 of file plugin_datastore_sqlite.c.

◆ RESULT_COLUMNS

#define RESULT_COLUMNS "repl, type, prio, anonLevel, expire, hash, value, _ROWID_"

Function Documentation

◆ sq_prepare()

static int sq_prepare	(	sqlite3 *	dbh,
		const char *	zSql,
		sqlite3_stmt **	ppStmt
	)

static

Prepare a SQL statement.

Parameters

dbh	handle to the database
zSql	SQL statement, UTF-8 encoded
ppStmt	set to the prepared statement

Returns: 0 on success

Definition at line 181 of file plugin_datastore_sqlite.c.

 {
   char *dummy;
   int result;
  
   result = sqlite3_prepare_v2 (dbh,
                                zSql,
                                strlen (zSql),
                                ppStmt,
                                (const char **) &dummy);
   GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG,
                    "sqlite",
                    "Prepared `%s' / %p: %d\n",
                    zSql,
                    *ppStmt,
                    result);
   return result;
 }

References dummy, GNUNET_ERROR_TYPE_DEBUG, GNUNET_log_from, and result.

Referenced by database_setup(), sqlite_plugin_estimate_size(), and sqlite_plugin_get_keys().

Here is the caller graph for this function:

◆ create_indices()

static void create_indices ( sqlite3 * dbh )

static

Create our database indices.

Parameters

dbh	handle to the database

Definition at line 207 of file plugin_datastore_sqlite.c.

 {
   /* create indices */
   if (
     0 !=
     (SQLITE_OK !=
      sqlite3_exec (dbh,
                    "CREATE INDEX IF NOT EXISTS idx_hash ON gn091 (hash)",
                    NULL,
                    NULL,
                    NULL))
     + (SQLITE_OK !=
        sqlite3_exec (
          dbh,
          "CREATE INDEX IF NOT EXISTS idx_anon_type ON gn091 (anonLevel ASC,type)",
          NULL,
          NULL,
          NULL))
     + (SQLITE_OK !=
        sqlite3_exec (dbh,
                      "CREATE INDEX IF NOT EXISTS idx_expire ON gn091 (expire ASC)",
                      NULL,
                      NULL,
                      NULL))
     + (SQLITE_OK !=
        sqlite3_exec (
          dbh,
          "CREATE INDEX IF NOT EXISTS idx_repl_rvalue ON gn091 (repl,rvalue)",
          NULL,
          NULL,
          NULL)))
     GNUNET_log_from (GNUNET_ERROR_TYPE_ERROR,
                      "sqlite",
                      "Failed to create indices: %s\n",
                      sqlite3_errmsg (dbh));
 }

References GNUNET_ERROR_TYPE_ERROR, and GNUNET_log_from.

Referenced by database_setup().

Here is the caller graph for this function:

◆ database_setup()

static int database_setup	(	const struct GNUNET_CONFIGURATION_Handle *	cfg,
		struct Plugin *	plugin
	)

static

Initialize the database connections and associated data structures (create tables and indices as needed as well).

Parameters

cfg	our configuration
plugin	the plugin context (state for this module)

Returns: GNUNET_OK on success

Definition at line 271 of file plugin_datastore_sqlite.c.

 {
   sqlite3_stmt *stmt;
   char *afsdir;
  
 #if ENULL_DEFINED
   char *e;
 #endif
  
   if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_filename (cfg,
                                                             "datastore-sqlite",
                                                             "FILENAME",
                                                             &afsdir))
   {
     GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR,
                                "datastore-sqlite",
                                "FILENAME");
     return GNUNET_SYSERR;
   }
   if (GNUNET_OK != GNUNET_DISK_file_test (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! */
     if (NULL != plugin->env->duc)
       plugin->env->duc (plugin->env->cls, 0);
   }
   /* afsdir should be UTF-8-encoded. If it isn't, it's a bug */
   plugin->fn = afsdir;
  
   /* Open database and precompile statements */
   if (SQLITE_OK != sqlite3_open (plugin->fn, &plugin->dbh))
   {
     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));
   CHECK (
     SQLITE_OK ==
     sqlite3_exec (plugin->dbh, "PRAGMA synchronous=OFF", NULL, NULL, ENULL));
   CHECK (SQLITE_OK == sqlite3_exec (plugin->dbh,
                                     "PRAGMA legacy_file_format=OFF",
                                     NULL,
                                     NULL,
                                     ENULL));
   CHECK (SQLITE_OK == sqlite3_exec (plugin->dbh,
                                     "PRAGMA auto_vacuum=INCREMENTAL",
                                     NULL,
                                     NULL,
                                     ENULL));
   CHECK (SQLITE_OK == sqlite3_exec (plugin->dbh,
                                     "PRAGMA locking_mode=EXCLUSIVE",
                                     NULL,
                                     NULL,
                                     ENULL));
   CHECK (
     SQLITE_OK ==
     sqlite3_exec (plugin->dbh, "PRAGMA page_size=4096", NULL, NULL, ENULL));
  
   CHECK (SQLITE_OK == sqlite3_busy_timeout (plugin->dbh, BUSY_TIMEOUT_MS));
  
  
   /* We have to do it here, because otherwise precompiling SQL might fail */
   CHECK (SQLITE_OK ==
          sq_prepare (plugin->dbh,
                      "SELECT 1 FROM sqlite_master WHERE tbl_name = 'gn091'",
                      &stmt));
  
   /* FIXME: SQLite does not have unsigned integers! This is ok for the type column because
    * we only test equality on it and can cast it to/from uint32_t. For repl, prio, and anonLevel
    * we do math or inequality tests, so we can't handle the entire range of uint32_t.
    * This will also cause problems for expiration times after 294247-01-10-04:00:54 UTC.
    */if ((SQLITE_DONE == sqlite3_step (stmt)) &&
       (SQLITE_OK != sqlite3_exec (plugin->dbh,
                                   "CREATE TABLE gn091 ("
                                   "  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)))
   {
     LOG_SQLITE (plugin, GNUNET_ERROR_TYPE_ERROR, "sqlite3_exec");
     sqlite3_finalize (stmt);
     return GNUNET_SYSERR;
   }
   sqlite3_finalize (stmt);
   create_indices (plugin->dbh);
  
 #define RESULT_COLUMNS \
   "repl, type, prio, anonLevel, expire, hash, value, _ROWID_"
   if (
     (SQLITE_OK != sq_prepare (plugin->dbh,
                               "UPDATE gn091 "
                               "SET prio = prio + ?, "
                               "repl = repl + ?, "
                               "expire = MAX(expire, ?) "
                               "WHERE hash = ? AND vhash = ?",
                               &plugin->update)) ||
     (SQLITE_OK != sq_prepare (plugin->dbh,
                               "UPDATE gn091 "
                               "SET repl = MAX (0, repl - 1) WHERE _ROWID_ = ?",
                               &plugin->updRepl)) ||
     (SQLITE_OK != sq_prepare (plugin->dbh,
                               "SELECT " RESULT_COLUMNS " FROM gn091 "
                               "WHERE repl=?2 AND "
                               " (rvalue>=?1 OR "
                               "  NOT EXISTS (SELECT 1 FROM gn091 "
                               "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 gn091",
                               &plugin->maxRepl)) ||
     (SQLITE_OK !=
      sq_prepare (plugin->dbh,
                  "SELECT " RESULT_COLUMNS " FROM gn091 "
                  "WHERE NOT EXISTS (SELECT 1 FROM gn091 WHERE expire < ?1 LIMIT 1) OR (expire < ?1) "
                  "ORDER BY expire ASC LIMIT 1",
                  &plugin->selExpi)) ||
     (SQLITE_OK != sq_prepare (plugin->dbh,
                               "SELECT " RESULT_COLUMNS " FROM gn091 "
                               "WHERE _ROWID_ >= ? AND "
                               "anonLevel = 0 AND "
                               "type = ? "
                               "ORDER BY _ROWID_ ASC LIMIT 1",
                               &plugin->selZeroAnon)) ||
     (SQLITE_OK !=
      sq_prepare (plugin->dbh,
                  "INSERT INTO gn091 (repl, type, prio, anonLevel, expire, rvalue, hash, vhash, value) "
                  "VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)",
                  &plugin->insertContent)) ||
     (SQLITE_OK != sq_prepare (plugin->dbh,
                               "SELECT " RESULT_COLUMNS " FROM gn091 "
                               "WHERE _ROWID_ >= ?1 "
                               "ORDER BY _ROWID_ ASC LIMIT 1",
                               &plugin->get[0])) ||
     (SQLITE_OK != sq_prepare (plugin->dbh,
                               "SELECT " RESULT_COLUMNS " FROM gn091 "
                               "WHERE _ROWID_ >= ?1 AND "
                               "type = ?4 "
                               "ORDER BY _ROWID_ ASC LIMIT 1",
                               &plugin->get[1])) ||
     (SQLITE_OK != sq_prepare (plugin->dbh,
                               "SELECT " RESULT_COLUMNS " FROM gn091 "
                               "WHERE _ROWID_ >= ?1 AND "
                               "hash = ?3 "
                               "ORDER BY _ROWID_ ASC LIMIT 1",
                               &plugin->get[2])) ||
     (SQLITE_OK != sq_prepare (plugin->dbh,
                               "SELECT " RESULT_COLUMNS " FROM gn091 "
                               "WHERE _ROWID_ >= ?1 AND "
                               "hash = ?3 AND "
                               "type = ?4 "
                               "ORDER BY _ROWID_ ASC LIMIT 1",
                               &plugin->get[3])) ||
     (SQLITE_OK != sq_prepare (plugin->dbh,
                               "SELECT " RESULT_COLUMNS " FROM gn091 "
                               "WHERE _ROWID_ >= ?1 AND "
                               "rvalue >= ?2 "
                               "ORDER BY _ROWID_ ASC LIMIT 1",
                               &plugin->get[4])) ||
     (SQLITE_OK != sq_prepare (plugin->dbh,
                               "SELECT " RESULT_COLUMNS " FROM gn091 "
                               "WHERE _ROWID_ >= ?1 AND "
                               "rvalue >= ?2 AND "
                               "type = ?4 "
                               "ORDER BY _ROWID_ ASC LIMIT 1",
                               &plugin->get[5])) ||
     (SQLITE_OK != sq_prepare (plugin->dbh,
                               "SELECT " RESULT_COLUMNS " FROM gn091 "
                               "WHERE _ROWID_ >= ?1 AND "
                               "rvalue >= ?2 AND "
                               "hash = ?3 "
                               "ORDER BY _ROWID_ ASC LIMIT 1",
                               &plugin->get[6])) ||
     (SQLITE_OK != sq_prepare (plugin->dbh,
                               "SELECT " RESULT_COLUMNS " FROM gn091 "
                               "WHERE _ROWID_ >= ?1 AND "
                               "rvalue >= ?2 AND "
                               "hash = ?3 AND "
                               "type = ?4 "
                               "ORDER BY _ROWID_ ASC LIMIT 1",
                               &plugin->get[7])) ||
     (SQLITE_OK != sq_prepare (plugin->dbh,
                               "DELETE FROM gn091 WHERE _ROWID_ = ?",
                               &plugin->delRow)) ||
     (SQLITE_OK != sq_prepare (plugin->dbh,
                               "DELETE FROM gn091 "
                               "WHERE hash = ? AND "
                               "value = ? ",
                               &plugin->remove)) ||
     false)
   {
     LOG_SQLITE (plugin, GNUNET_ERROR_TYPE_ERROR, "precompiling");
     return GNUNET_SYSERR;
   }
   return GNUNET_OK;
 }

References _, BUSY_TIMEOUT_MS, cfg, CHECK, create_indices(), e, ENULL, GNUNET_break, GNUNET_CONFIGURATION_get_value_filename(), GNUNET_DISK_directory_create_for_file(), GNUNET_DISK_file_test(), GNUNET_ERROR_TYPE_ERROR, GNUNET_free, GNUNET_log_config_missing(), GNUNET_log_from, GNUNET_OK, GNUNET_SYSERR, LOG_SQLITE, plugin, RESULT_COLUMNS, and sq_prepare().

Referenced by execute_get(), libgnunet_plugin_datastore_sqlite_init(), and sqlite_plugin_put().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ database_shutdown()

static void database_shutdown ( struct Plugin * plugin )

static

Shutdown database connection and associate data structures.

Parameters

plugin the plugin context (state for this module)

Definition at line 495 of file plugin_datastore_sqlite.c.

 {
   int result;
  
 #if SQLITE_VERSION_NUMBER >= 3007000
   sqlite3_stmt *stmt;
 #endif
  
   if (NULL != plugin->remove)
     sqlite3_finalize (plugin->remove);
   if (NULL != plugin->delRow)
     sqlite3_finalize (plugin->delRow);
   if (NULL != plugin->update)
     sqlite3_finalize (plugin->update);
   if (NULL != plugin->updRepl)
     sqlite3_finalize (plugin->updRepl);
   if (NULL != plugin->selRepl)
     sqlite3_finalize (plugin->selRepl);
   if (NULL != plugin->maxRepl)
     sqlite3_finalize (plugin->maxRepl);
   if (NULL != plugin->selExpi)
     sqlite3_finalize (plugin->selExpi);
   if (NULL != plugin->selZeroAnon)
     sqlite3_finalize (plugin->selZeroAnon);
   if (NULL != plugin->insertContent)
     sqlite3_finalize (plugin->insertContent);
   for (int i = 0; i < 8; ++i)
     if (NULL != plugin->get[i])
       sqlite3_finalize (plugin->get[i]);
   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 (NULL != stmt)
     {
       GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG,
                        "sqlite",
                        "Closing statement %p\n",
                        stmt);
       result = sqlite3_finalize (stmt);
       if (result != SQLITE_OK)
         GNUNET_log_from (GNUNET_ERROR_TYPE_WARNING,
                          "sqlite",
                          "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, GNUNET_ERROR_TYPE_ERROR, "sqlite3_close");
   GNUNET_free (plugin->fn);
 }

References _, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_ERROR_TYPE_WARNING, GNUNET_free, GNUNET_log_from, LOG_SQLITE, plugin, and result.

Referenced by execute_get(), libgnunet_plugin_datastore_sqlite_done(), libgnunet_plugin_datastore_sqlite_init(), and sqlite_plugin_put().

Here is the caller graph for this function:

◆ delete_by_rowid()

static int delete_by_rowid	(	struct Plugin *	plugin,
		uint64_t	rid
	)

static

Delete the database entry with the given row identifier.

Parameters

plugin	the plugin context (state for this module)
rid	the ID of the row to delete

Definition at line 566 of file plugin_datastore_sqlite.c.

 {
   struct GNUNET_SQ_QueryParam params[] = { GNUNET_SQ_query_param_uint64 (&rid),
                                            GNUNET_SQ_query_param_end };
  
   if (GNUNET_OK != GNUNET_SQ_bind (plugin->delRow, params))
     return GNUNET_SYSERR;
   if (SQLITE_DONE != sqlite3_step (plugin->delRow))
   {
     LOG_SQLITE (plugin,
                 GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
                 "sqlite3_step");
     GNUNET_SQ_reset (plugin->dbh, plugin->delRow);
     return GNUNET_SYSERR;
   }
   GNUNET_SQ_reset (plugin->dbh, plugin->delRow);
   return GNUNET_OK;
 }

References GNUNET_ERROR_TYPE_BULK, GNUNET_ERROR_TYPE_ERROR, GNUNET_OK, GNUNET_SQ_bind(), GNUNET_SQ_query_param_end, GNUNET_SQ_query_param_uint64(), GNUNET_SQ_reset(), GNUNET_SYSERR, LOG_SQLITE, and plugin.

Referenced by execute_get().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ sqlite_plugin_put()

static void sqlite_plugin_put	(	void *	cls,
		const struct GNUNET_HashCode *	key,
		bool	absent,
		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,
		PluginPutCont	cont,
		void *	cont_cls
	)

static

Store an item in the datastore.

Parameters

cls	closure
key	key for the item
absent	true if the key was not found in the bloom filter
size	number of bytes in data
data	content stored
type	type of the content
priority	priority of the content
anonymity	anonymity-level for the content
replication	replication-level for the content
expiration	expiration time for the content
cont	continuation called with success or failure status
cont_cls	continuation closure

Definition at line 603 of file plugin_datastore_sqlite.c.

 {
   struct Plugin *plugin = cls;
   struct GNUNET_HashCode vhash;
   char *msg = NULL;
  
   GNUNET_CRYPTO_hash (data, size, &vhash);
  
   if (! absent)
   {
     struct GNUNET_SQ_QueryParam params[] =
     { GNUNET_SQ_query_param_uint32 (&priority),
       GNUNET_SQ_query_param_uint32 (&replication),
       GNUNET_SQ_query_param_absolute_time (&expiration),
       GNUNET_SQ_query_param_auto_from_type (key),
       GNUNET_SQ_query_param_auto_from_type (&vhash),
       GNUNET_SQ_query_param_end };
  
     if (GNUNET_OK != GNUNET_SQ_bind (plugin->update, params))
     {
       cont (cont_cls, key, size, GNUNET_SYSERR, _ ("sqlite bind failure"));
       return;
     }
     if (SQLITE_DONE != sqlite3_step (plugin->update))
     {
       LOG_SQLITE_MSG (plugin,
                       &msg,
                       GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
                       "sqlite3_step");
       cont (cont_cls, key, size, GNUNET_SYSERR, msg);
       GNUNET_free (msg);
       return;
     }
     int changes = sqlite3_changes (plugin->dbh);
     GNUNET_SQ_reset (plugin->dbh, plugin->update);
     if (0 != changes)
     {
       cont (cont_cls, key, size, GNUNET_NO, NULL);
       return;
     }
   }
  
   uint64_t rvalue;
   uint32_t type32 = (uint32_t) type;
   struct GNUNET_SQ_QueryParam params[] =
   { GNUNET_SQ_query_param_uint32 (&replication),
     GNUNET_SQ_query_param_uint32 (&type32),
     GNUNET_SQ_query_param_uint32 (&priority),
     GNUNET_SQ_query_param_uint32 (&anonymity),
     GNUNET_SQ_query_param_absolute_time (&expiration),
     GNUNET_SQ_query_param_uint64 (&rvalue),
     GNUNET_SQ_query_param_auto_from_type (key),
     GNUNET_SQ_query_param_auto_from_type (&vhash),
     GNUNET_SQ_query_param_fixed_size (data, size),
     GNUNET_SQ_query_param_end };
   int n;
   int ret;
   sqlite3_stmt *stmt;
  
   if (size > MAX_ITEM_SIZE)
   {
     cont (cont_cls, key, size, GNUNET_SYSERR, _ ("Data too large"));
     return;
   }
   GNUNET_log_from (
     GNUNET_ERROR_TYPE_DEBUG,
     "sqlite",
     "Storing in database block with type %u/key `%s'/priority %u/expiration in %s (%s).\n",
     type,
     GNUNET_h2s (key),
     priority,
     GNUNET_STRINGS_relative_time_to_string (GNUNET_TIME_absolute_get_remaining (
                                               expiration),
                                             GNUNET_YES),
     GNUNET_STRINGS_absolute_time_to_string (expiration));
   stmt = plugin->insertContent;
   rvalue = GNUNET_CRYPTO_random_u64 (GNUNET_CRYPTO_QUALITY_WEAK, UINT64_MAX);
   if (GNUNET_OK != GNUNET_SQ_bind (stmt, params))
   {
     cont (cont_cls, key, size, GNUNET_SYSERR, NULL);
     return;
   }
   n = sqlite3_step (stmt);
   switch (n)
   {
   case SQLITE_DONE:
     if (NULL != plugin->env->duc)
       plugin->env->duc (plugin->env->cls,
                         size + GNUNET_DATASTORE_ENTRY_OVERHEAD);
     GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG,
                      "sqlite",
                      "Stored new entry (%u bytes)\n",
                      size + GNUNET_DATASTORE_ENTRY_OVERHEAD);
     ret = GNUNET_OK;
     break;
  
   case SQLITE_BUSY:
     GNUNET_break (0);
     LOG_SQLITE_MSG (plugin,
                     &msg,
                     GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
                     "sqlite3_step");
     ret = GNUNET_SYSERR;
     break;
  
   default:
     LOG_SQLITE_MSG (plugin,
                     &msg,
                     GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
                     "sqlite3_step");
     GNUNET_SQ_reset (plugin->dbh, stmt);
     database_shutdown (plugin);
     database_setup (plugin->env->cfg, plugin);
     cont (cont_cls, key, size, GNUNET_SYSERR, msg);
     GNUNET_free (msg);
     return;
   }
   GNUNET_SQ_reset (plugin->dbh, stmt);
   cont (cont_cls, key, size, ret, msg);
   GNUNET_free (msg);
 }

References _, anonymity, data, database_setup(), database_shutdown(), expiration, GNUNET_break, GNUNET_CRYPTO_hash(), GNUNET_CRYPTO_QUALITY_WEAK, GNUNET_CRYPTO_random_u64(), GNUNET_DATASTORE_ENTRY_OVERHEAD, GNUNET_ERROR_TYPE_BULK, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_free, GNUNET_h2s(), GNUNET_log_from, GNUNET_NO, GNUNET_OK, GNUNET_SQ_bind(), GNUNET_SQ_query_param_absolute_time(), GNUNET_SQ_query_param_auto_from_type, GNUNET_SQ_query_param_end, GNUNET_SQ_query_param_fixed_size(), GNUNET_SQ_query_param_uint32(), GNUNET_SQ_query_param_uint64(), GNUNET_SQ_reset(), GNUNET_STRINGS_absolute_time_to_string(), GNUNET_STRINGS_relative_time_to_string(), GNUNET_SYSERR, GNUNET_TIME_absolute_get_remaining(), GNUNET_YES, key, LOG_SQLITE_MSG, MAX_ITEM_SIZE, msg, plugin, replication, ret, size, and type.

Referenced by libgnunet_plugin_datastore_sqlite_init().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ execute_get()

static void execute_get	(	struct Plugin *	plugin,
		sqlite3_stmt *	stmt,
		PluginDatumProcessor	proc,
		void *	proc_cls
	)

static

Execute statement that gets a row and call the callback with the result.

Resets the statement afterwards.

Parameters

plugin	the plugin
stmt	the statement
proc	processor to call
proc_cls	closure for proc

Definition at line 747 of file plugin_datastore_sqlite.c.

 {
   int n;
   struct GNUNET_TIME_Absolute expiration;
   uint32_t replication;
   uint32_t type;
   uint32_t priority;
   uint32_t anonymity;
   uint64_t rowid;
   void *value;
   size_t value_size;
   struct GNUNET_HashCode key;
   int ret;
   struct GNUNET_SQ_ResultSpec rs[] =
   { GNUNET_SQ_result_spec_uint32 (&replication),
     GNUNET_SQ_result_spec_uint32 (&type),
     GNUNET_SQ_result_spec_uint32 (&priority),
     GNUNET_SQ_result_spec_uint32 (&anonymity),
     GNUNET_SQ_result_spec_absolute_time (&expiration),
     GNUNET_SQ_result_spec_auto_from_type (&key),
     GNUNET_SQ_result_spec_variable_size (&value, &value_size),
     GNUNET_SQ_result_spec_uint64 (&rowid),
     GNUNET_SQ_result_spec_end };
  
   n = sqlite3_step (stmt);
   switch (n)
   {
   case SQLITE_ROW:
     if (GNUNET_OK != GNUNET_SQ_extract_result (stmt, rs))
     {
       GNUNET_break (0);
       break;
     }
     GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG,
                      "sqlite",
                      "Found reply in database with expiration %s\n",
                      GNUNET_STRINGS_absolute_time_to_string (expiration));
     ret = proc (proc_cls,
                 &key,
                 value_size,
                 value,
                 type,
                 priority,
                 anonymity,
                 replication,
                 expiration,
                 rowid);
     GNUNET_SQ_cleanup_result (rs);
     GNUNET_SQ_reset (plugin->dbh, stmt);
     if ((GNUNET_NO == ret) && (GNUNET_OK == delete_by_rowid (plugin, rowid)) &&
         (NULL != plugin->env->duc))
       plugin->env->duc (plugin->env->cls,
                         -(value_size + GNUNET_DATASTORE_ENTRY_OVERHEAD));
     return;
  
   case SQLITE_DONE:
     /* database must be empty */
     break;
  
   case SQLITE_BUSY:
   case SQLITE_ERROR:
   case SQLITE_MISUSE:
   default:
     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");
     GNUNET_break (0);
     proc (proc_cls, NULL, 0, NULL, 0, 0, 0, 0, GNUNET_TIME_UNIT_ZERO_ABS, 0);
     database_shutdown (plugin);
     database_setup (plugin->env->cfg, plugin);
     return;
   }
   GNUNET_SQ_reset (plugin->dbh, stmt);
   proc (proc_cls, NULL, 0, NULL, 0, 0, 0, 0, GNUNET_TIME_UNIT_ZERO_ABS, 0);
 }

References anonymity, database_setup(), database_shutdown(), delete_by_rowid(), expiration, GNUNET_break, GNUNET_DATASTORE_ENTRY_OVERHEAD, GNUNET_ERROR_TYPE_BULK, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_log_from, GNUNET_NO, GNUNET_OK, GNUNET_SQ_cleanup_result(), GNUNET_SQ_extract_result(), GNUNET_SQ_reset(), GNUNET_SQ_result_spec_absolute_time(), GNUNET_SQ_result_spec_auto_from_type, GNUNET_SQ_result_spec_end, GNUNET_SQ_result_spec_uint32(), GNUNET_SQ_result_spec_uint64(), GNUNET_SQ_result_spec_variable_size(), GNUNET_STRINGS_absolute_time_to_string(), GNUNET_TIME_UNIT_ZERO_ABS, key, LOG_SQLITE, plugin, replication, ret, type, and value.

Referenced by sqlite_plugin_get_expiration(), sqlite_plugin_get_key(), sqlite_plugin_get_replication(), and sqlite_plugin_get_zero_anonymity().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ sqlite_plugin_get_zero_anonymity()

static void sqlite_plugin_get_zero_anonymity	(	void *	cls,
		uint64_t	next_uid,
		enum GNUNET_BLOCK_Type	type,
		PluginDatumProcessor	proc,
		void *	proc_cls
	)

static

Select a subset of the items in the datastore and call the given processor for the item.

Parameters

cls	our plugin context
next_uid	return the result with lowest uid >= next_uid
type	entries of which type should be considered? Must not be zero (ANY).
proc	function to call on the matching value; will be called with NULL if no value matches
proc_cls	closure for proc

Definition at line 844 of file plugin_datastore_sqlite.c.

 {
   struct Plugin *plugin = cls;
   uint32_t type32 = type;
   struct GNUNET_SQ_QueryParam params[] = { GNUNET_SQ_query_param_uint64 (
                                              &next_uid),
                                            GNUNET_SQ_query_param_uint32 (
                                              &type32),
                                            GNUNET_SQ_query_param_end };
  
   GNUNET_assert (type != GNUNET_BLOCK_TYPE_ANY);
   if (GNUNET_OK != GNUNET_SQ_bind (plugin->selZeroAnon, params))
   {
     proc (proc_cls, NULL, 0, NULL, 0, 0, 0, 0, GNUNET_TIME_UNIT_ZERO_ABS, 0);
     return;
   }
   execute_get (plugin, plugin->selZeroAnon, proc, proc_cls);
 }

References execute_get(), GNUNET_assert, GNUNET_BLOCK_TYPE_ANY, GNUNET_OK, GNUNET_SQ_bind(), GNUNET_SQ_query_param_end, GNUNET_SQ_query_param_uint32(), GNUNET_SQ_query_param_uint64(), GNUNET_TIME_UNIT_ZERO_ABS, plugin, and type.

Referenced by libgnunet_plugin_datastore_sqlite_init().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ sqlite_plugin_get_key()

static void sqlite_plugin_get_key	(	void *	cls,
		uint64_t	next_uid,
		bool	random,
		const struct GNUNET_HashCode *	key,
		enum GNUNET_BLOCK_Type	type,
		PluginDatumProcessor	proc,
		void *	proc_cls
	)

static

Get results for a particular key in the datastore.

Parameters

cls	closure
next_uid	return the result with lowest uid >= next_uid
random	if true, return a random result instead of using next_uid
key	maybe NULL (to match all entries)
type	entries of which type are relevant? Use 0 for any type.
proc	function to call on the matching value; will be called with NULL if nothing matches
proc_cls	closure for proc

Definition at line 882 of file plugin_datastore_sqlite.c.

 {
   struct Plugin *plugin = cls;
   uint64_t rvalue;
   int use_rvalue = random;
   uint32_t type32 = (uint32_t) type;
   int use_type = GNUNET_BLOCK_TYPE_ANY != type;
   int use_key = NULL != key;
   sqlite3_stmt *stmt = plugin->get[use_rvalue * 4 + use_key * 2 + use_type];
   struct GNUNET_SQ_QueryParam params[] =
   { GNUNET_SQ_query_param_uint64 (&next_uid),
     GNUNET_SQ_query_param_uint64 (&rvalue),
     GNUNET_SQ_query_param_auto_from_type (key),
     GNUNET_SQ_query_param_uint32 (&type32),
     GNUNET_SQ_query_param_end };
  
   /* SQLite doesn't like it when you try to bind a parameter greater than the
    * last numbered parameter, but unused parameters in the middle are OK.
    */
   if (! use_type)
   {
     params[3] = (struct GNUNET_SQ_QueryParam) GNUNET_SQ_query_param_end;
     if (! use_key)
     {
       params[2] = (struct GNUNET_SQ_QueryParam) GNUNET_SQ_query_param_end;
       if (! use_rvalue)
         params[1] = (struct GNUNET_SQ_QueryParam) GNUNET_SQ_query_param_end;
     }
   }
   if (random)
   {
     rvalue = GNUNET_CRYPTO_random_u64 (GNUNET_CRYPTO_QUALITY_WEAK, UINT64_MAX);
     next_uid = 0;
   }
   else
     rvalue = 0;
  
   if (GNUNET_OK != GNUNET_SQ_bind (stmt, params))
   {
     proc (proc_cls, NULL, 0, NULL, 0, 0, 0, 0, GNUNET_TIME_UNIT_ZERO_ABS, 0);
     return;
   }
   execute_get (plugin, stmt, proc, proc_cls);
 }

References execute_get(), GNUNET_BLOCK_TYPE_ANY, GNUNET_CRYPTO_QUALITY_WEAK, GNUNET_CRYPTO_random_u64(), GNUNET_OK, GNUNET_SQ_bind(), GNUNET_SQ_query_param_auto_from_type, GNUNET_SQ_query_param_end, GNUNET_SQ_query_param_uint32(), GNUNET_SQ_query_param_uint64(), GNUNET_TIME_UNIT_ZERO_ABS, key, plugin, and type.

Referenced by libgnunet_plugin_datastore_sqlite_init().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ repl_proc()

static int repl_proc	(	void *	cls,
		const struct 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,
		uint64_t	uid
	)

static

Wrapper for the processor for sqlite_plugin_get_replication().

Decrements the replication counter and calls the original processor.

Parameters

cls	closure
key	key for the content
size	number of bytes in data
data	content stored
type	type of the content
priority	priority of the content
anonymity	anonymity-level for the content
replication	replication-level for the content
expiration	expiration time for the content
uid	unique identifier for the datum; maybe 0 if no unique identifier is available

Returns: GNUNET_OK for normal return, GNUNET_NO to delete the item

Definition at line 981 of file plugin_datastore_sqlite.c.

 {
   struct ReplCtx *rc = cls;
   int ret;
  
   if (GNUNET_SYSERR == rc->have_uid)
     rc->have_uid = GNUNET_NO;
   ret = rc->proc (rc->proc_cls,
                   key,
                   size,
                   data,
                   type,
                   priority,
                   anonymity,
                   replication,
                   expiration,
                   uid);
   if (NULL != key)
   {
     rc->uid = uid;
     rc->have_uid = GNUNET_YES;
   }
   return ret;
 }

References anonymity, data, expiration, GNUNET_NO, GNUNET_SYSERR, GNUNET_YES, ReplCtx::have_uid, key, ReplCtx::proc, ReplCtx::proc_cls, replication, ret, size, type, and ReplCtx::uid.

Referenced by sqlite_plugin_get_replication().

Here is the caller graph for this function:

◆ sqlite_plugin_get_replication()

static void sqlite_plugin_get_replication	(	void *	cls,
		PluginDatumProcessor	proc,
		void *	proc_cls
	)

static

Get a random item for replication.

Returns a single random item from those with the highest replication counters. The item's replication counter is decremented by one IF it was positive before. Call proc with all values ZERO or NULL if the datastore is empty.

Parameters

cls	closure
proc	function to call the value (once only).
proc_cls	closure for proc

Definition at line 1027 of file plugin_datastore_sqlite.c.

 {
   struct Plugin *plugin = cls;
   struct ReplCtx rc;
   uint64_t rvalue = 0;
   uint32_t repl;
   struct GNUNET_SQ_QueryParam params_sel_repl[] =
   { GNUNET_SQ_query_param_uint64 (&rvalue),
     GNUNET_SQ_query_param_uint32 (&repl),
     GNUNET_SQ_query_param_end };
   struct GNUNET_SQ_QueryParam params_upd_repl[] =
   { GNUNET_SQ_query_param_uint64 (&rc.uid), GNUNET_SQ_query_param_end };
  
   GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG,
                    "datastore-sqlite",
                    "Getting random block based on replication order.\n");
   if (SQLITE_ROW != sqlite3_step (plugin->maxRepl))
   {
     GNUNET_SQ_reset (plugin->dbh, plugin->maxRepl);
     /* DB empty */
     proc (proc_cls, NULL, 0, NULL, 0, 0, 0, 0, GNUNET_TIME_UNIT_ZERO_ABS, 0);
     return;
   }
   repl = sqlite3_column_int (plugin->maxRepl, 0);
   GNUNET_SQ_reset (plugin->dbh, plugin->maxRepl);
   rvalue = GNUNET_CRYPTO_random_u64 (GNUNET_CRYPTO_QUALITY_WEAK, UINT64_MAX);
   if (GNUNET_OK != GNUNET_SQ_bind (plugin->selRepl, params_sel_repl))
   {
     proc (proc_cls, NULL, 0, NULL, 0, 0, 0, 0, GNUNET_TIME_UNIT_ZERO_ABS, 0);
     return;
   }
   rc.have_uid = GNUNET_SYSERR;
   rc.proc = proc;
   rc.proc_cls = proc_cls;
   execute_get (plugin, plugin->selRepl, &repl_proc, &rc);
   if (GNUNET_YES == rc.have_uid)
   {
     if (GNUNET_OK != GNUNET_SQ_bind (plugin->updRepl, params_upd_repl))
     {
       proc (proc_cls, NULL, 0, NULL, 0, 0, 0, 0, GNUNET_TIME_UNIT_ZERO_ABS, 0);
       return;
     }
     if (SQLITE_DONE != sqlite3_step (plugin->updRepl))
       LOG_SQLITE (plugin,
                   GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
                   "sqlite3_step");
     GNUNET_SQ_reset (plugin->dbh, plugin->updRepl);
   }
   if (GNUNET_SYSERR == rc.have_uid)
   {
     /* proc was not called at all so far, do it now. */
     proc (proc_cls, NULL, 0, NULL, 0, 0, 0, 0, GNUNET_TIME_UNIT_ZERO_ABS, 0);
   }
 }

References execute_get(), GNUNET_CRYPTO_QUALITY_WEAK, GNUNET_CRYPTO_random_u64(), GNUNET_ERROR_TYPE_BULK, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_log_from, GNUNET_OK, GNUNET_SQ_bind(), GNUNET_SQ_query_param_end, GNUNET_SQ_query_param_uint32(), GNUNET_SQ_query_param_uint64(), GNUNET_SQ_reset(), GNUNET_SYSERR, GNUNET_TIME_UNIT_ZERO_ABS, GNUNET_YES, ReplCtx::have_uid, LOG_SQLITE, plugin, ReplCtx::proc, ReplCtx::proc_cls, repl_proc(), and ReplCtx::uid.

Referenced by libgnunet_plugin_datastore_sqlite_init().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ sqlite_plugin_get_expiration()

static void sqlite_plugin_get_expiration	(	void *	cls,
		PluginDatumProcessor	proc,
		void *	proc_cls
	)

static

Get a random item that has expired or has low priority.

Call proc with all values ZERO or NULL if the datastore is empty.

Parameters

cls	closure
proc	function to call the value (once only).
proc_cls	closure for proc

Definition at line 1094 of file plugin_datastore_sqlite.c.

 {
   struct Plugin *plugin = cls;
   sqlite3_stmt *stmt;
   struct GNUNET_TIME_Absolute now = { 0 };
   struct GNUNET_SQ_QueryParam params[] = { GNUNET_SQ_query_param_absolute_time (
                                              &now),
                                            GNUNET_SQ_query_param_end };
  
   GNUNET_log_from (
     GNUNET_ERROR_TYPE_DEBUG,
     "sqlite",
     "Getting random block based on expiration and priority order.\n");
   now = GNUNET_TIME_absolute_get ();
   stmt = plugin->selExpi;
   if (GNUNET_OK != GNUNET_SQ_bind (stmt, params))
   {
     proc (proc_cls, NULL, 0, NULL, 0, 0, 0, 0, GNUNET_TIME_UNIT_ZERO_ABS, 0);
     return;
   }
   execute_get (plugin, stmt, proc, proc_cls);
 }

References execute_get(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_log_from, GNUNET_OK, GNUNET_SQ_bind(), GNUNET_SQ_query_param_absolute_time(), GNUNET_SQ_query_param_end, GNUNET_TIME_absolute_get(), GNUNET_TIME_UNIT_ZERO_ABS, and plugin.

Referenced by libgnunet_plugin_datastore_sqlite_init().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ sqlite_plugin_get_keys()

static void sqlite_plugin_get_keys	(	void *	cls,
		PluginKeyProcessor	proc,
		void *	proc_cls
	)

static

Get all of the keys in the datastore.

Parameters

cls	closure
proc	function to call on each key
proc_cls	closure for proc

Definition at line 1128 of file plugin_datastore_sqlite.c.

 {
   struct Plugin *plugin = cls;
   struct GNUNET_HashCode key;
   struct GNUNET_SQ_ResultSpec results[] =
   { GNUNET_SQ_result_spec_auto_from_type (&key), GNUNET_SQ_result_spec_end };
   sqlite3_stmt *stmt;
   int ret;
  
   GNUNET_assert (NULL != proc);
   if (SQLITE_OK != sq_prepare (plugin->dbh, "SELECT hash FROM gn091", &stmt))
   {
     LOG_SQLITE (plugin,
                 GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
                 "sqlite_prepare");
     proc (proc_cls, NULL, 0);
     return;
   }
   while (SQLITE_ROW == (ret = sqlite3_step (stmt)))
   {
     if (GNUNET_OK == GNUNET_SQ_extract_result (stmt, results))
       proc (proc_cls, &key, 1);
     else
       GNUNET_break (0);
   }
   if (SQLITE_DONE != ret)
     LOG_SQLITE (plugin, GNUNET_ERROR_TYPE_ERROR, "sqlite_step");
   sqlite3_finalize (stmt);
   proc (proc_cls, NULL, 0);
 }

References GNUNET_assert, GNUNET_break, GNUNET_ERROR_TYPE_BULK, GNUNET_ERROR_TYPE_ERROR, GNUNET_OK, GNUNET_SQ_extract_result(), GNUNET_SQ_result_spec_auto_from_type, GNUNET_SQ_result_spec_end, key, LOG_SQLITE, plugin, results, ret, and sq_prepare().

Referenced by libgnunet_plugin_datastore_sqlite_init().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ sqlite_plugin_drop()

static void sqlite_plugin_drop ( void * cls )

static

Drop database.

Parameters

cls	our plugin context

Definition at line 1166 of file plugin_datastore_sqlite.c.

 {
   struct Plugin *plugin = cls;
  
   plugin->drop_on_shutdown = GNUNET_YES;
 }

References GNUNET_YES, and plugin.

Referenced by libgnunet_plugin_datastore_sqlite_init().

Here is the caller graph for this function:

◆ sqlite_plugin_remove_key()

static void sqlite_plugin_remove_key	(	void *	cls,
		const struct GNUNET_HashCode *	key,
		uint32_t	size,
		const void *	data,
		PluginRemoveCont	cont,
		void *	cont_cls
	)

static

Remove a particular key in the datastore.

Parameters

cls	closure
key	key for the content
size	number of bytes in data
data	content stored
cont	continuation called with success or failure status
cont_cls	continuation closure for cont

Definition at line 1185 of file plugin_datastore_sqlite.c.

 {
   struct Plugin *plugin = cls;
   struct GNUNET_SQ_QueryParam params[] =
   { GNUNET_SQ_query_param_auto_from_type (key),
     GNUNET_SQ_query_param_fixed_size (data, size),
     GNUNET_SQ_query_param_end };
  
   if (GNUNET_OK != GNUNET_SQ_bind (plugin->remove, params))
   {
     cont (cont_cls, key, size, GNUNET_SYSERR, "bind failed");
     return;
   }
   if (SQLITE_DONE != sqlite3_step (plugin->remove))
   {
     LOG_SQLITE (plugin,
                 GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
                 "sqlite3_step");
     GNUNET_SQ_reset (plugin->dbh, plugin->remove);
     cont (cont_cls, key, size, GNUNET_SYSERR, "sqlite3_step failed");
     return;
   }
   int changes = sqlite3_changes (plugin->dbh);
   GNUNET_SQ_reset (plugin->dbh, plugin->remove);
   if (0 == changes)
   {
     cont (cont_cls, key, size, GNUNET_NO, NULL);
     return;
   }
   if (NULL != plugin->env->duc)
     plugin->env->duc (plugin->env->cls,
                       -(size + GNUNET_DATASTORE_ENTRY_OVERHEAD));
   cont (cont_cls, key, size, GNUNET_OK, NULL);
 }

References data, GNUNET_DATASTORE_ENTRY_OVERHEAD, GNUNET_ERROR_TYPE_BULK, GNUNET_ERROR_TYPE_ERROR, GNUNET_NO, GNUNET_OK, GNUNET_SQ_bind(), GNUNET_SQ_query_param_auto_from_type, GNUNET_SQ_query_param_end, GNUNET_SQ_query_param_fixed_size(), GNUNET_SQ_reset(), GNUNET_SYSERR, key, LOG_SQLITE, plugin, and size.

Referenced by libgnunet_plugin_datastore_sqlite_init().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ sqlite_plugin_estimate_size()

static void sqlite_plugin_estimate_size	(	void *	cls,
		unsigned long long *	estimate
	)

static

Get an estimate of how much space the database is currently using.

Parameters

cls	the `struct Plugin`

Returns: the size of the database on disk (estimate)

Definition at line 1234 of file plugin_datastore_sqlite.c.

 {
   struct Plugin *plugin = cls;
   sqlite3_stmt *stmt;
   uint64_t pages;
   uint64_t page_size;
  
 #if ENULL_DEFINED
   char *e;
 #endif
  
   if (NULL == estimate)
     return;
   if (SQLITE_VERSION_NUMBER < 3006000)
   {
     GNUNET_log_from (
       GNUNET_ERROR_TYPE_WARNING,
       "datastore-sqlite",
       _ ("sqlite version to old to determine size, assuming zero\n"));
     *estimate = 0;
     return;
   }
   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));
   if (SQLITE_OK != sq_prepare (plugin->dbh, "PRAGMA page_count", &stmt))
   {
     GNUNET_log_from (
       GNUNET_ERROR_TYPE_WARNING,
       "datastore-sqlite",
       _("error preparing statement\n"));
     return;
   }
   if (SQLITE_ROW == sqlite3_step (stmt))
     pages = sqlite3_column_int64 (stmt, 0);
   else
     pages = 0;
   sqlite3_finalize (stmt);
   if (SQLITE_OK != sq_prepare (plugin->dbh, "PRAGMA page_size", &stmt))
   {
     GNUNET_log_from (
       GNUNET_ERROR_TYPE_WARNING,
       "datastore-sqlite",
       _("error preparing statement\n"));
     return;
   }
   if (SQLITE_ROW != sqlite3_step (stmt))
   {
     GNUNET_log_from (
       GNUNET_ERROR_TYPE_WARNING,
       "datastore-sqlite",
       _("error stepping\n"));
     return;
   }
   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);
   *estimate = pages * page_size;
 }

References _, CHECK, e, ENULL, GNUNET_ERROR_TYPE_INFO, GNUNET_ERROR_TYPE_WARNING, GNUNET_log, GNUNET_log_from, plugin, and sq_prepare().

Referenced by libgnunet_plugin_datastore_sqlite_init().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ libgnunet_plugin_datastore_sqlite_init()

void* libgnunet_plugin_datastore_sqlite_init ( void * cls )

Entry point for the plugin.

Parameters

cls	the `struct GNUNET_DATASTORE_PluginEnvironment *`

Returns: NULL on error, othrewise the plugin context

Definition at line 1310 of file plugin_datastore_sqlite.c.

 {
   static struct Plugin plugin;
   struct GNUNET_DATASTORE_PluginEnvironment *env = cls;
   struct GNUNET_DATASTORE_PluginFunctions *api;
  
   if (NULL != plugin.env)
     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;
   }
   api = GNUNET_new (struct GNUNET_DATASTORE_PluginFunctions);
   api->cls = &plugin;
   api->estimate_size = &sqlite_plugin_estimate_size;
   api->put = &sqlite_plugin_put;
   api->get_key = &sqlite_plugin_get_key;
   api->get_replication = &sqlite_plugin_get_replication;
   api->get_expiration = &sqlite_plugin_get_expiration;
   api->get_zero_anonymity = &sqlite_plugin_get_zero_anonymity;
   api->get_keys = &sqlite_plugin_get_keys;
   api->drop = &sqlite_plugin_drop;
   api->remove_key = &sqlite_plugin_remove_key;
   GNUNET_log_from (GNUNET_ERROR_TYPE_INFO,
                    "sqlite",
                    _ ("Sqlite database running\n"));
   return api;
 }

Here is the call graph for this function:

◆ libgnunet_plugin_datastore_sqlite_done()

void* libgnunet_plugin_datastore_sqlite_done ( void * cls )

Exit point from the plugin.

Parameters

cls	the plugin context (as returned by "init")

Returns: always NULL

Definition at line 1350 of file plugin_datastore_sqlite.c.

 {
   char *fn;
   struct GNUNET_DATASTORE_PluginFunctions *api = cls;
   struct Plugin *plugin = api->cls;
  
   GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG,
                    "sqlite",
                    "sqlite plugin is done\n");
   fn = NULL;
   if (plugin->drop_on_shutdown)
     fn = GNUNET_strdup (plugin->fn);
   database_shutdown (plugin);
   plugin->env = NULL;
   GNUNET_free (api);
   if (NULL != fn)
   {
     if (0 != unlink (fn))
       GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING, "unlink", fn);
     GNUNET_free (fn);
   }
   return NULL;
 }

References Plugin::api, GNUNET_BLOCK_PluginFunctions::cls, GNUNET_DATASTORE_PluginFunctions::cls, database_shutdown(), Plugin::fn, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_WARNING, GNUNET_free, GNUNET_log_from, GNUNET_log_strerror_file, GNUNET_strdup, and plugin.

Here is the call graph for this function:

Data Structures

Macros

Functions

Detailed Description

Macro Definition Documentation

◆ MAX_ITEM_SIZE

◆ BUSY_TIMEOUT_MS

◆ LOG_SQLITE

◆ LOG_SQLITE_MSG

◆ ENULL

◆ ENULL_DEFINED

◆ CHECK

◆ RESULT_COLUMNS

Function Documentation

◆ sq_prepare()

◆ create_indices()

◆ database_setup()

◆ database_shutdown()

◆ delete_by_rowid()

◆ sqlite_plugin_put()

◆ execute_get()

◆ sqlite_plugin_get_zero_anonymity()

◆ sqlite_plugin_get_key()

◆ repl_proc()

◆ sqlite_plugin_get_replication()

◆ sqlite_plugin_get_expiration()

◆ sqlite_plugin_get_keys()

◆ sqlite_plugin_drop()

◆ sqlite_plugin_remove_key()

◆ sqlite_plugin_estimate_size()

◆ libgnunet_plugin_datastore_sqlite_init()

◆ libgnunet_plugin_datastore_sqlite_done()