plugin_datastore_sqlite.c File Reference

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:

Go to the source code of this file.

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.
#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).
#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).
#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).
#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.
static void	create_indices (sqlite3 *dbh)
	Create our database indices.
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).
static void	database_shutdown (struct Plugin *plugin)
	Shutdown database connection and associate data structures.
static int	delete_by_rowid (struct Plugin *plugin, uint64_t rid)
	Delete the database entry with the given row identifier.
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.
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.
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.
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.
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().
static void	sqlite_plugin_get_replication (void *cls, PluginDatumProcessor proc, void *proc_cls)
	Get a random item for replication.
static void	sqlite_plugin_get_expiration (void *cls, PluginDatumProcessor proc, void *proc_cls)
	Get a random item that has expired or has low priority.
static void	sqlite_plugin_get_keys (void *cls, PluginKeyProcessor proc, void *proc_cls)
	Get all of the keys in the datastore.
static void	sqlite_plugin_drop (void *cls)
	Drop database.
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.
static void	sqlite_plugin_estimate_size (void *cls, unsigned long long *estimate)
	Get an estimate of how much space the database is currently using.
void *	libgnunet_plugin_datastore_sqlite_init (void *cls)
	Entry point for the plugin.
void *	libgnunet_plugin_datastore_sqlite_done (void *cls)
	Exit point from the plugin.

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.

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

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.

        {                                                               \
          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)

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.

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

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, GNUNET_TESTING_PluginFunctions::cls, create_indices(), 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;
      }
    }
  }
 
  {
    // FIXME Refactor?
    uint64_t rvalue;
    uint32_t type32 = (uint32_t) type;
    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);
    {
      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 };
      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, GNUNET_TESTING_PluginFunctions::cls, 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 755 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, GNUNET_TESTING_PluginFunctions::cls, 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 852 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 890 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];
  if (random)
  {
    rvalue = GNUNET_CRYPTO_random_u64 (GNUNET_CRYPTO_QUALITY_WEAK, UINT64_MAX);
    next_uid = 0;
  }
  else
    rvalue = 0;
  {  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 (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 990 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 1036 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_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);
  {
    struct GNUNET_SQ_QueryParam params_sel_repl[] =
    { GNUNET_SQ_query_param_uint64 (&rvalue),
      GNUNET_SQ_query_param_uint32 (&repl),
      GNUNET_SQ_query_param_end };
    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 1105 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 1139 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 1177 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 1196 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 GNUNET_TESTING_PluginFunctions::cls, 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 1247 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, 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 1326 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;
}

References _, GNUNET_DATASTORE_PluginEnvironment::cls, GNUNET_DATASTORE_PluginFunctions::cls, database_setup(), database_shutdown(), GNUNET_DATASTORE_PluginFunctions::drop, env, GNUNET_DATASTORE_PluginFunctions::estimate_size, GNUNET_DATASTORE_PluginFunctions::get_expiration, GNUNET_DATASTORE_PluginFunctions::get_key, GNUNET_DATASTORE_PluginFunctions::get_keys, GNUNET_DATASTORE_PluginFunctions::get_replication, GNUNET_DATASTORE_PluginFunctions::get_zero_anonymity, GNUNET_ERROR_TYPE_INFO, GNUNET_log_from, GNUNET_new, GNUNET_OK, plugin, GNUNET_DATASTORE_PluginFunctions::put, GNUNET_DATASTORE_PluginFunctions::remove_key, sqlite_plugin_drop(), sqlite_plugin_estimate_size(), sqlite_plugin_get_expiration(), sqlite_plugin_get_key(), sqlite_plugin_get_keys(), sqlite_plugin_get_replication(), sqlite_plugin_get_zero_anonymity(), sqlite_plugin_put(), and sqlite_plugin_remove_key().

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 1369 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: