plugin_peerstore_sqlite.c File Reference

sqlite-based peerstore backend More...

#include "platform.h"
#include "gnunet_peerstore_plugin.h"
#include "gnunet_peerstore_service.h"
#include "gnunet_sq_lib.h"
#include <sqlite3.h>

Include dependency graph for plugin_peerstore_sqlite.c:

Go to the source code of this file.

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

Macros
#define	BUSY_TIMEOUT_MS   1000
	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(kind, ...)   GNUNET_log_from (kind, "peerstore-sqlite", __VA_ARGS__)

Functions
static int	peerstore_sqlite_delete_records (void *cls, const char *sub_system, const struct GNUNET_PeerIdentity *peer, const char *key)
	Delete records with the given key. More...
static int	peerstore_sqlite_expire_records (void *cls, struct GNUNET_TIME_Absolute now, GNUNET_PEERSTORE_Continuation cont, void *cont_cls)
	Delete expired records (expiry < now) More...
static int	peerstore_sqlite_iterate_records (void *cls, const char *sub_system, const struct GNUNET_PeerIdentity *peer, const char *key, uint64_t serial, uint64_t limit, GNUNET_PEERSTORE_PluginProcessor iter, void *iter_cls)
	Iterate over the records given an optional peer id and/or key. More...
static int	peerstore_sqlite_store_record (void *cls, const char *sub_system, const struct GNUNET_PeerIdentity *peer, const char *key, const void *value, size_t size, struct GNUNET_TIME_Absolute expiry, enum GNUNET_PEERSTORE_StoreOption options, GNUNET_PEERSTORE_Continuation cont, void *cont_cls)
	Store a record in the peerstore. More...
static int	sql_exec (sqlite3 *dbh, const char *sql)
	Prepare a SQL statement. More...
static int	sql_prepare (sqlite3 *dbh, const char *sql, sqlite3_stmt **stmt)
	Prepare a SQL statement. More...
static int	database_setup (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...
void *	libgnunet_plugin_peerstore_sqlite_init (void *cls)
	Entry point for the plugin. More...
void *	libgnunet_plugin_peerstore_sqlite_done (void *cls)
	Exit point from the plugin. More...

Detailed Description

sqlite-based peerstore backend

Author

Omar Tarabai

Christian Grothoff

Definition in file plugin_peerstore_sqlite.c.

Macro Definition Documentation

BUSY_TIMEOUT_MS

#define BUSY_TIMEOUT_MS   1000

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 1s should ensure that users do not experience huge latencies while at the same time allowing operations to succeed with reasonable probability.

Definition at line 45 of file plugin_peerstore_sqlite.c.

LOG_SQLITE

#define LOG_SQLITE	(		db,
			level,
			cmd
	)

Value:

                                                         do { GNUNET_log_from (level, \
                                                         "peerstore-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 52 of file plugin_peerstore_sqlite.c.

LOG

#define LOG	(		kind,
			...
	)		GNUNET_log_from (kind, "peerstore-sqlite", __VA_ARGS__)

Definition at line 61 of file plugin_peerstore_sqlite.c.

Function Documentation

peerstore_sqlite_delete_records()

static int peerstore_sqlite_delete_records ( void *  cls, const char *  sub_system, const struct GNUNET_PeerIdentity *  peer, const char *  key  )

static

Delete records with the given key.

Parameters

cls	closure (internal context for the plugin)
sub_system	name of sub system
peer	Peer identity (can be NULL)
key	entry key string (can be NULL)

Returns

number of deleted records, #GNUNE_SYSERR on error

Definition at line 132 of file plugin_peerstore_sqlite.c.

{
  struct Plugin *plugin = cls;
  sqlite3_stmt *stmt = plugin->delete_peerstoredata;
  struct GNUNET_SQ_QueryParam params[] = {
    GNUNET_SQ_query_param_string (sub_system),
    GNUNET_SQ_query_param_auto_from_type (peer),
    GNUNET_SQ_query_param_string (key),
    GNUNET_SQ_query_param_end
  };
  int ret;
 
  if (GNUNET_OK !=
      GNUNET_SQ_bind (stmt,
                      params))
  {
    LOG_SQLITE (plugin,
                GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
                "sqlite3_bind");
    GNUNET_SQ_reset (plugin->dbh,
                     stmt);
    return GNUNET_SYSERR;
  }
  if (SQLITE_DONE !=
      sqlite3_step (stmt))
  {
    LOG_SQLITE (plugin,
                GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
                "sqlite3_step");
    ret = GNUNET_SYSERR;
  }
  else
  {
    ret = sqlite3_changes (plugin->dbh);
  }
  GNUNET_SQ_reset (plugin->dbh,
                   stmt);
  return ret;
}

References GNUNET_ERROR_TYPE_BULK, GNUNET_ERROR_TYPE_ERROR, GNUNET_OK, GNUNET_SQ_bind(), GNUNET_SQ_query_param_auto_from_type, GNUNET_SQ_query_param_end, GNUNET_SQ_query_param_string(), GNUNET_SQ_reset(), GNUNET_SYSERR, key, LOG_SQLITE, plugin, and ret.

Referenced by peerstore_sqlite_store_record().

Here is the call graph for this function:

Here is the caller graph for this function:

peerstore_sqlite_expire_records()

static int peerstore_sqlite_expire_records ( void *  cls, struct GNUNET_TIME_Absolute  now, GNUNET_PEERSTORE_Continuation  cont, void *  cont_cls  )

static

Delete expired records (expiry < now)

Parameters

cls	closure (internal context for the plugin)
now	time to use as reference
cont	continuation called with the number of records expired
cont_cls	continuation closure

Returns

GNUNET_OK on success, GNUNET_SYSERR on error and cont is not called

Definition at line 187 of file plugin_peerstore_sqlite.c.

{
  struct Plugin *plugin = cls;
  sqlite3_stmt *stmt = plugin->expire_peerstoredata;
  struct GNUNET_SQ_QueryParam params[] = {
    GNUNET_SQ_query_param_absolute_time (&now),
    GNUNET_SQ_query_param_end
  };
 
  if (GNUNET_OK !=
      GNUNET_SQ_bind (stmt,
                      params))
  {
    LOG_SQLITE (plugin,
                GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
                "sqlite3_bind");
    GNUNET_SQ_reset (plugin->dbh,
                     stmt);
    return GNUNET_SYSERR;
  }
  if (SQLITE_DONE != sqlite3_step (stmt))
  {
    LOG_SQLITE (plugin,
                GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
                "sqlite3_step");
    GNUNET_SQ_reset (plugin->dbh,
                     stmt);
    return GNUNET_SYSERR;
  }
  if (NULL != cont)
    cont (cont_cls,
          sqlite3_changes (plugin->dbh));
  GNUNET_SQ_reset (plugin->dbh,
                   stmt);
  return GNUNET_OK;
}

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

Referenced by libgnunet_plugin_peerstore_sqlite_init().

Here is the call graph for this function:

Here is the caller graph for this function:

peerstore_sqlite_iterate_records()

static int peerstore_sqlite_iterate_records ( void *  cls, const char *  sub_system, const struct GNUNET_PeerIdentity *  peer, const char *  key, uint64_t  serial, uint64_t  limit, GNUNET_PEERSTORE_PluginProcessor  iter, void *  iter_cls  )

static

Iterate over the records given an optional peer id and/or key.

Parameters

cls	closure (internal context for the plugin)
sub_system	name of sub system
peer	Peer identity (can be NULL)
key	entry key string (can be NULL)
iter	function to call asynchronously with the results, terminated by a NULL result
iter_cls	closure for iter

Returns

GNUNET_OK on success, GNUNET_SYSERR on error and iter is not called

Definition at line 242 of file plugin_peerstore_sqlite.c.

{
  struct Plugin *plugin = cls;
  sqlite3_stmt *stmt;
  int err = 0;
  int sret;
  int ret;
  uint64_t seq;
  struct GNUNET_PEERSTORE_Record rec;
 
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Executing iterate request on sqlite db.\n");
  if (NULL == peer)
  {
    if (NULL == key)
    {
      struct GNUNET_SQ_QueryParam params[] = {
        GNUNET_SQ_query_param_string (sub_system),
        GNUNET_SQ_query_param_uint64 (&serial),
        GNUNET_SQ_query_param_uint64 (&limit),
        GNUNET_SQ_query_param_end
      };
 
      stmt = plugin->select_peerstoredata;
      err = GNUNET_SQ_bind (stmt,
                            params);
    }
    else
    {
      struct GNUNET_SQ_QueryParam params[] = {
        GNUNET_SQ_query_param_string (sub_system),
        GNUNET_SQ_query_param_string (key),
        GNUNET_SQ_query_param_uint64 (&serial),
        GNUNET_SQ_query_param_uint64 (&limit),
        GNUNET_SQ_query_param_end
      };
 
      stmt = plugin->select_peerstoredata_by_key;
      err = GNUNET_SQ_bind (stmt,
                            params);
    }
  }
  else
  {
    if (NULL == key)
    {
      struct GNUNET_SQ_QueryParam params[] = {
        GNUNET_SQ_query_param_string (sub_system),
        GNUNET_SQ_query_param_auto_from_type (peer),
        GNUNET_SQ_query_param_uint64 (&serial),
        GNUNET_SQ_query_param_uint64 (&limit),
        GNUNET_SQ_query_param_end
      };
 
      stmt = plugin->select_peerstoredata_by_pid;
      err = GNUNET_SQ_bind (stmt,
                            params);
    }
    else
    {
      struct GNUNET_SQ_QueryParam params[] = {
        GNUNET_SQ_query_param_string (sub_system),
        GNUNET_SQ_query_param_auto_from_type (peer),
        GNUNET_SQ_query_param_string (key),
        GNUNET_SQ_query_param_uint64 (&serial),
        GNUNET_SQ_query_param_uint64 (&limit),
        GNUNET_SQ_query_param_end
      };
 
      stmt = plugin->select_peerstoredata_by_all;
      err = GNUNET_SQ_bind (stmt,
                            params);
    }
  }
 
  if (GNUNET_OK != err)
  {
    LOG_SQLITE (plugin,
                GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
                "sqlite3_bind_XXXX");
    GNUNET_SQ_reset (plugin->dbh,
                     stmt);
    return GNUNET_SYSERR;
  }
 
  err = 0;
  ret = GNUNET_OK;
  for (uint64_t i = 0; i < limit; i++)
  {
    sret = sqlite3_step (stmt);
    if (SQLITE_DONE == sret)
    {
      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                  "Iteration done (no results)\n");
      ret = GNUNET_NO;
      break;
    }
    if (SQLITE_ROW != sret)
    {
      LOG_SQLITE (plugin,
                  GNUNET_ERROR_TYPE_ERROR,
                  "sqlite_step");
      ret = GNUNET_SYSERR;
      break;
    }
    {
      struct GNUNET_SQ_ResultSpec rs[] = {
        GNUNET_SQ_result_spec_uint64 (&seq),
        GNUNET_SQ_result_spec_string (&rec.sub_system),
        GNUNET_SQ_result_spec_auto_from_type (&rec.peer),
        GNUNET_SQ_result_spec_string (&rec.key),
        GNUNET_SQ_result_spec_variable_size (&rec.value, &rec.value_size),
        GNUNET_SQ_result_spec_absolute_time (&rec.expiry),
        GNUNET_SQ_result_spec_end
      };
      LOG (GNUNET_ERROR_TYPE_DEBUG,
           "Returning a matched record.\n");
 
      if (GNUNET_OK !=
          GNUNET_SQ_extract_result (stmt,
                                    rs))
      {
        GNUNET_break (0);
        break;
      }
      if (NULL != iter)
        iter (iter_cls,
              seq,
              &rec,
              NULL);
      GNUNET_SQ_cleanup_result (rs);
    }
  }
  GNUNET_SQ_reset (plugin->dbh,
                   stmt);
  return ret;
}

References GNUNET_PEERSTORE_Record::expiry, GNUNET_break, GNUNET_ERROR_TYPE_BULK, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_log, GNUNET_NO, GNUNET_OK, GNUNET_SQ_bind(), GNUNET_SQ_cleanup_result(), GNUNET_SQ_extract_result(), GNUNET_SQ_query_param_auto_from_type, GNUNET_SQ_query_param_end, GNUNET_SQ_query_param_string(), GNUNET_SQ_query_param_uint64(), 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_string(), GNUNET_SQ_result_spec_uint64(), GNUNET_SQ_result_spec_variable_size(), GNUNET_SYSERR, key, GNUNET_PEERSTORE_Record::key, LOG, LOG_SQLITE, GNUNET_PEERSTORE_Record::peer, plugin, ret, GNUNET_PEERSTORE_Record::sub_system, GNUNET_PEERSTORE_Record::value, and GNUNET_PEERSTORE_Record::value_size.

Referenced by libgnunet_plugin_peerstore_sqlite_init().

Here is the call graph for this function:

Here is the caller graph for this function:

peerstore_sqlite_store_record()

static int peerstore_sqlite_store_record ( void *  cls, const char *  sub_system, const struct GNUNET_PeerIdentity *  peer, const char *  key, const void *  value, size_t  size, struct GNUNET_TIME_Absolute  expiry, enum GNUNET_PEERSTORE_StoreOption  options, GNUNET_PEERSTORE_Continuation  cont, void *  cont_cls  )

static

Store a record in the peerstore.

Key is the combination of sub system and peer identity. One key can store multiple values.

Parameters

cls	closure (internal context for the plugin)
sub_system	name of the GNUnet sub system responsible
peer	peer identity
key	record key string
value	value to be stored
size	size of value to be stored
expiry	absolute time after which the record is (possibly) deleted
options	options related to the store operation
cont	continuation called when record is stored
cont_cls	continuation closure

Returns

GNUNET_OK on success, else GNUNET_SYSERR and cont is not called

Definition at line 406 of file plugin_peerstore_sqlite.c.

{
  struct Plugin *plugin = cls;
  sqlite3_stmt *stmt;
  struct GNUNET_SQ_QueryParam params[] = {
    GNUNET_SQ_query_param_string (sub_system),
    GNUNET_SQ_query_param_auto_from_type (peer),
    GNUNET_SQ_query_param_string (key),
    GNUNET_SQ_query_param_fixed_size (value, size),
    GNUNET_SQ_query_param_absolute_time (&expiry),
    GNUNET_SQ_query_param_end
  };
 
  if (GNUNET_PEERSTORE_STOREOPTION_REPLACE == options)
  {
    peerstore_sqlite_delete_records (cls,
                                     sub_system,
                                     peer,
                                     key);
  }
 
  stmt = plugin->insert_peerstoredata;
  if (GNUNET_OK !=
      GNUNET_SQ_bind (stmt,
                      params))
  {
    LOG_SQLITE (plugin,
                GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
                "sqlite3_bind");
    GNUNET_assert (0);
  }
  if (SQLITE_DONE != sqlite3_step (stmt))
  {
    LOG_SQLITE (plugin,
                GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
                "sqlite3_step");
  }
  GNUNET_SQ_reset (plugin->dbh,
                   stmt);
  if (NULL != cont)
    cont (cont_cls,
          GNUNET_OK);
  return GNUNET_OK;
}

References GNUNET_assert, GNUNET_ERROR_TYPE_BULK, GNUNET_ERROR_TYPE_ERROR, GNUNET_OK, GNUNET_PEERSTORE_STOREOPTION_REPLACE, 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_string(), GNUNET_SQ_reset(), key, LOG_SQLITE, options, peerstore_sqlite_delete_records(), plugin, size, and value.

Referenced by libgnunet_plugin_peerstore_sqlite_init().

Here is the call graph for this function:

Here is the caller graph for this function:

sql_exec()

static int sql_exec ( sqlite3 *  dbh, const char *  sql  )

static

Prepare a SQL statement.

Parameters

dbh	handle to the database
sql	SQL statement, UTF-8 encoded

Returns

0 on success

Definition at line 469 of file plugin_peerstore_sqlite.c.

{
  int result;
 
  result = sqlite3_exec (dbh,
                         sql,
                         NULL,
                         NULL,
                         NULL);
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Executed `%s' / %d\n",
       sql,
       result);
  if (SQLITE_OK != result)
    LOG (GNUNET_ERROR_TYPE_ERROR,
         _ ("Error executing SQL query: %s\n  %s\n"),
         sqlite3_errmsg (dbh),
         sql);
  return result;
}

References _, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, LOG, and result.

Referenced by database_setup().

Here is the caller graph for this function:

sql_prepare()

static int sql_prepare ( sqlite3 *  dbh, const char *  sql, sqlite3_stmt **  stmt  )

static

Prepare a SQL statement.

Parameters

dbh	handle to the database
sql	SQL statement, UTF-8 encoded
stmt	set to the prepared statement

Returns

0 on success

Definition at line 501 of file plugin_peerstore_sqlite.c.

{
  char *tail;
  int result;
 
  result = sqlite3_prepare_v2 (dbh,
                               sql,
                               strlen (sql),
                               stmt,
                               (const char **) &tail);
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Prepared `%s' / %p: %d\n",
       sql,
       *stmt,
       result);
  if (SQLITE_OK != result)
    LOG (GNUNET_ERROR_TYPE_ERROR,
         _ ("Error preparing SQL query: %s\n  %s\n"),
         sqlite3_errmsg (dbh),
         sql);
  return result;
}

References _, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, LOG, and result.

Referenced by database_setup().

Here is the caller graph for this function:

database_setup()

static int database_setup ( struct Plugin *  plugin )

static

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

Parameters

plugin

the plugin context (state for this module)

Returns

GNUNET_OK on success

Definition at line 536 of file plugin_peerstore_sqlite.c.

{
  char *filename;
 
  if (GNUNET_OK !=
      GNUNET_CONFIGURATION_get_value_filename (plugin->cfg,
                                               "peerstore-sqlite",
                                               "FILENAME",
                                               &filename))
  {
    GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR,
                               "peerstore-sqlite",
                               "FILENAME");
    return GNUNET_SYSERR;
  }
  if (GNUNET_OK != GNUNET_DISK_file_test (filename))
  {
    if (GNUNET_OK != GNUNET_DISK_directory_create_for_file (filename))
    {
      GNUNET_break (0);
      GNUNET_free (filename);
      return GNUNET_SYSERR;
    }
  }
  /* filename should be UTF-8-encoded. If it isn't, it's a bug */
  plugin->fn = filename;
  /* Open database and precompile statements */
  if (SQLITE_OK != sqlite3_open (plugin->fn,
                                 &plugin->dbh))
  {
    LOG (GNUNET_ERROR_TYPE_ERROR,
         _ ("Unable to initialize SQLite: %s.\n"),
         sqlite3_errmsg (plugin->dbh));
    return GNUNET_SYSERR;
  }
  sql_exec (plugin->dbh,
            "PRAGMA temp_store=MEMORY");
  sql_exec (plugin->dbh,
            "PRAGMA synchronous=OFF");
  sql_exec (plugin->dbh,
            "PRAGMA legacy_file_format=OFF");
  sql_exec (plugin->dbh,
            "PRAGMA auto_vacuum=INCREMENTAL");
  sql_exec (plugin->dbh,
            "PRAGMA encoding=\"UTF-8\"");
  sql_exec (plugin->dbh,
            "PRAGMA page_size=4096");
  sqlite3_busy_timeout (plugin->dbh,
                        BUSY_TIMEOUT_MS);
  /* Create tables */
  sql_exec (plugin->dbh,
            "CREATE TABLE IF NOT EXISTS peerstoredata (\n"
            "  uid INTEGER PRIMARY KEY,"
            "  sub_system TEXT NOT NULL,\n"
            "  peer_id BLOB NOT NULL,\n"
            "  key TEXT NOT NULL,\n"
            "  value BLOB NULL,\n"
            "  expiry INT8 NOT NULL" ");");
  /* Create Indices */
  if (SQLITE_OK !=
      sqlite3_exec (plugin->dbh,
                    "CREATE INDEX IF NOT EXISTS peerstoredata_key_index ON peerstoredata (sub_system, peer_id, key, uid)",
                    NULL,
                    NULL,
                    NULL))
  {
    LOG (GNUNET_ERROR_TYPE_ERROR,
         _ ("Unable to create indices: %s.\n"),
         sqlite3_errmsg (plugin->dbh));
    return GNUNET_SYSERR;
  }
  /* Prepare statements */
 
  sql_prepare (plugin->dbh,
               "INSERT INTO peerstoredata (sub_system, peer_id, key, value, expiry)"
               " VALUES (?,?,?,?,?);",
               &plugin->insert_peerstoredata);
  sql_prepare (plugin->dbh,
               "SELECT uid,sub_system,peer_id,key,value,expiry FROM peerstoredata"
               " WHERE sub_system = ?"
               " AND uid > ?"
               " ORDER BY uid ASC"
               " LIMIT ?",
               &plugin->select_peerstoredata);
  sql_prepare (plugin->dbh,
               "SELECT uid,sub_system,peer_id,key,value,expiry FROM peerstoredata"
               " WHERE sub_system = ?"
               " AND peer_id = ?"
               " AND uid > ?"
               " ORDER BY uid ASC"
               " LIMIT ?",
               &plugin->select_peerstoredata_by_pid);
  sql_prepare (plugin->dbh,
               "SELECT uid,sub_system,peer_id,key,value,expiry FROM peerstoredata"
               " WHERE sub_system = ?"
               " AND key = ?"
               " AND uid > ?"
               " ORDER BY uid ASC"
               " LIMIT ?",
               &plugin->select_peerstoredata_by_key);
  sql_prepare (plugin->dbh,
               "SELECT uid,sub_system,peer_id,key,value,expiry FROM peerstoredata"
               " WHERE sub_system = ?"
               " AND peer_id = ?"
               " AND key = ?"
               " AND uid > ?"
               " ORDER BY uid ASC"
               " LIMIT ?",
               &plugin->select_peerstoredata_by_all);
  sql_prepare (plugin->dbh,
               "DELETE FROM peerstoredata"
               " WHERE expiry < ?",
               &plugin->expire_peerstoredata);
  sql_prepare (plugin->dbh,
               "DELETE FROM peerstoredata"
               " WHERE sub_system = ?"
               " AND peer_id = ?" " AND key = ?",
               &plugin->delete_peerstoredata);
  return GNUNET_OK;
}

References _, BUSY_TIMEOUT_MS, filename, 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_OK, GNUNET_SYSERR, LOG, plugin, sql_exec(), and sql_prepare().

Referenced by libgnunet_plugin_peerstore_sqlite_init().

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 664 of file plugin_peerstore_sqlite.c.

{
  int result;
  sqlite3_stmt *stmt;
 
  while (NULL != (stmt = sqlite3_next_stmt (plugin->dbh,
                                            NULL)))
  {
    result = sqlite3_finalize (stmt);
    if (SQLITE_OK != result)
      LOG (GNUNET_ERROR_TYPE_WARNING,
           "Failed to close statement %p: %d\n",
           stmt,
           result);
  }
  if (SQLITE_OK != sqlite3_close (plugin->dbh))
    LOG_SQLITE (plugin,
                GNUNET_ERROR_TYPE_ERROR,
                "sqlite3_close");
  GNUNET_free (plugin->fn);
}

References GNUNET_ERROR_TYPE_ERROR, GNUNET_ERROR_TYPE_WARNING, GNUNET_free, LOG, LOG_SQLITE, plugin, and result.

Referenced by libgnunet_plugin_peerstore_sqlite_done(), and libgnunet_plugin_peerstore_sqlite_init().

Here is the caller graph for this function:

libgnunet_plugin_peerstore_sqlite_init()

void * libgnunet_plugin_peerstore_sqlite_init

(

void *

cls

)

Entry point for the plugin.

Parameters

cls	The struct GNUNET_CONFIGURATION_Handle.

Returns

NULL on error, otherwise the plugin context

Definition at line 696 of file plugin_peerstore_sqlite.c.

{
  static struct Plugin plugin;
  const struct GNUNET_CONFIGURATION_Handle *cfg = cls;
  struct GNUNET_PEERSTORE_PluginFunctions *api;
 
  if (NULL != plugin.cfg)
    return NULL;                /* can only initialize once! */
  memset (&plugin,
          0,
          sizeof(struct Plugin));
  plugin.cfg = cfg;
  if (GNUNET_OK != database_setup (&plugin))
  {
    database_shutdown (&plugin);
    return NULL;
  }
  api = GNUNET_new (struct GNUNET_PEERSTORE_PluginFunctions);
  api->cls = &plugin;
  api->store_record = &peerstore_sqlite_store_record;
  api->iterate_records = &peerstore_sqlite_iterate_records;
  api->expire_records = &peerstore_sqlite_expire_records;
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Sqlite plugin is running\n");
  return api;
}

References cfg, GNUNET_PEERSTORE_PluginFunctions::cls, database_setup(), database_shutdown(), GNUNET_PEERSTORE_PluginFunctions::expire_records, GNUNET_ERROR_TYPE_DEBUG, GNUNET_new, GNUNET_OK, GNUNET_PEERSTORE_PluginFunctions::iterate_records, LOG, peerstore_sqlite_expire_records(), peerstore_sqlite_iterate_records(), peerstore_sqlite_store_record(), plugin, and GNUNET_PEERSTORE_PluginFunctions::store_record.

Here is the call graph for this function:

libgnunet_plugin_peerstore_sqlite_done()

void * libgnunet_plugin_peerstore_sqlite_done

(

void *

cls

)

Exit point from the plugin.

Parameters

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

Returns

Always NULL

Definition at line 733 of file plugin_peerstore_sqlite.c.

{
  struct GNUNET_PEERSTORE_PluginFunctions *api = cls;
  struct Plugin *plugin = api->cls;
 
  database_shutdown (plugin);
  plugin->cfg = NULL;
  GNUNET_free (api);
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Sqlite plugin is finished\n");
  return NULL;
}

References Plugin::api, GNUNET_BLOCK_PluginFunctions::cls, GNUNET_PEERSTORE_PluginFunctions::cls, database_shutdown(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, LOG, and plugin.

Here is the call graph for this function: