plugin_namestore_sqlite.c File Reference

sqlite-based namestore backend More...

#include "platform.h"
#include "gnunet_namestore_plugin.h"
#include "gnunet_namestore_service.h"
#include "gnunet_gnsrecord_lib.h"
#include "gnunet_sq_lib.h"
#include "namestore.h"
#include <sqlite3.h>

Include dependency graph for plugin_namestore_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, "namestore-sqlite", __VA_ARGS__)

Functions
static enum GNUNET_GenericReturnValue	database_prepare (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 enum GNUNET_GenericReturnValue	namestore_sqlite_store_records (void *cls, const struct GNUNET_IDENTITY_PrivateKey *zone_key, const char *label, unsigned int rd_count, const struct GNUNET_GNSRECORD_Data *rd)
	Store a record in the datastore. More...
static enum GNUNET_GenericReturnValue	get_records_and_call_iterator (struct Plugin *plugin, sqlite3_stmt *stmt, const struct GNUNET_IDENTITY_PrivateKey *zone_key, uint64_t limit, GNUNET_NAMESTORE_RecordIterator iter, void *iter_cls)
	The given 'sqlite' statement has been prepared to be run. More...
static enum GNUNET_GenericReturnValue	namestore_sqlite_lookup_records (void *cls, const struct GNUNET_IDENTITY_PrivateKey *zone, const char *label, GNUNET_NAMESTORE_RecordIterator iter, void *iter_cls)
	Lookup records in the datastore for which we are the authority. More...
static enum GNUNET_GenericReturnValue	namestore_sqlite_iterate_records (void *cls, const struct GNUNET_IDENTITY_PrivateKey *zone, uint64_t serial, uint64_t limit, GNUNET_NAMESTORE_RecordIterator iter, void *iter_cls)
	Iterate over the results for a particular key and zone in the datastore. More...
static enum GNUNET_GenericReturnValue	namestore_sqlite_zone_to_name (void *cls, const struct GNUNET_IDENTITY_PrivateKey *zone, const struct GNUNET_IDENTITY_PublicKey *value_zone, GNUNET_NAMESTORE_RecordIterator iter, void *iter_cls)
	Look for an existing PKEY delegation record for a given public key. More...
static enum GNUNET_GenericReturnValue	namestore_sqlite_transaction_begin (void *cls, char **emsg)
	Begin a transaction for a client. More...
static enum GNUNET_GenericReturnValue	namestore_sqlite_transaction_rollback (void *cls, char **emsg)
	Commit a transaction for a client. More...
static enum GNUNET_GenericReturnValue	namestore_sqlite_transaction_commit (void *cls, char **emsg)
	Roll back a transaction for a client. More...
static enum GNUNET_GenericReturnValue	namestore_sqlite_create_tables (void *cls)
static enum GNUNET_GenericReturnValue	namestore_sqlite_drop_tables (void *cls)
static enum GNUNET_GenericReturnValue	database_connect (struct Plugin *plugin)
	Initialize the database connections and associated data structures (create tables and indices as needed as well). More...
void *	libgnunet_plugin_namestore_sqlite_init (void *cls)
	Entry point for the plugin. More...
void *	libgnunet_plugin_namestore_sqlite_done (void *cls)
	Exit point from the plugin. More...

Detailed Description

sqlite-based namestore backend

Author

Christian Grothoff

Definition in file plugin_namestore_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_namestore_sqlite.c.

LOG_SQLITE

#define LOG_SQLITE	(		db,
			level,
			cmd
	)

Value:

    do { \
    GNUNET_log_from (level,                                             \
                     "namestore-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 53 of file plugin_namestore_sqlite.c.

LOG

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

Definition at line 63 of file plugin_namestore_sqlite.c.

Function Documentation

database_prepare()

static enum GNUNET_GenericReturnValue database_prepare ( 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 1 of file plugin_namestore_sqlite.c.

{
  if (plugin->ready)
    return GNUNET_OK;
  struct GNUNET_SQ_ExecuteStatement es[] = {
    GNUNET_SQ_make_try_execute ("PRAGMA temp_store=MEMORY"),
    GNUNET_SQ_make_try_execute ("PRAGMA synchronous=NORMAL"),
    GNUNET_SQ_make_try_execute ("PRAGMA legacy_file_format=OFF"),
    GNUNET_SQ_make_try_execute ("PRAGMA auto_vacuum=INCREMENTAL"),
    GNUNET_SQ_make_try_execute ("PRAGMA encoding=\"UTF-8\""),
    GNUNET_SQ_make_try_execute ("PRAGMA locking_mode=NORMAL"),
    GNUNET_SQ_make_try_execute ("PRAGMA journal_mode=WAL"),
    GNUNET_SQ_make_try_execute ("PRAGMA page_size=4092"),
    GNUNET_SQ_EXECUTE_STATEMENT_END
  };
  struct GNUNET_SQ_PrepareStatement ps[] = {
    GNUNET_SQ_make_prepare ("INSERT INTO ns098records "
                            "(zone_private_key,pkey,rvalue,record_count,record_data,label)"
                            " VALUES (?, ?, ?, ?, ?, ?)",
                            &plugin->store_records),
    GNUNET_SQ_make_prepare ("DELETE FROM ns098records "
                            "WHERE zone_private_key=? AND label=?",
                            &plugin->delete_records),
    GNUNET_SQ_make_prepare ("SELECT uid,record_count,record_data,label"
                            " FROM ns098records"
                            " WHERE zone_private_key=? AND pkey=?",
                            &plugin->zone_to_name),
    GNUNET_SQ_make_prepare ("SELECT uid,record_count,record_data,label"
                            " FROM ns098records"
                            " WHERE zone_private_key=? AND uid > ?"
                            " ORDER BY uid ASC"
                            " LIMIT ?",
                            &plugin->iterate_zone),
    GNUNET_SQ_make_prepare (
      "SELECT uid,record_count,record_data,label,zone_private_key"
      " FROM ns098records"
      " WHERE uid > ?"
      " ORDER BY uid ASC"
      " LIMIT ?",
      &plugin->iterate_all_zones),
    GNUNET_SQ_make_prepare ("SELECT uid,record_count,record_data,label"
                            " FROM ns098records"
                            " WHERE zone_private_key=? AND label=?",
                            &plugin->lookup_label),
    GNUNET_SQ_PREPARE_END
  };
 
  if (GNUNET_OK !=
      GNUNET_SQ_exec_statements (plugin->dbh,
                                 es))
  {
    LOG (GNUNET_ERROR_TYPE_ERROR,
         _ ("Failed to setup database with: `%s'\n"),
         sqlite3_errmsg (plugin->dbh));
    return GNUNET_SYSERR;
  }
  if (GNUNET_OK !=
      GNUNET_SQ_prepare (plugin->dbh,
                         ps))
  {
    GNUNET_break (0);
    LOG (GNUNET_ERROR_TYPE_ERROR,
         _ ("Failed to setup database with: `%s'\n"),
         sqlite3_errmsg (plugin->dbh));
    return GNUNET_SYSERR;
  }
  plugin->ready = GNUNET_YES;
  return GNUNET_OK;
}

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 206 of file plugin_namestore_sqlite.c.

{
  int result;
  sqlite3_stmt *stmt;
 
  if (NULL != plugin->store_records)
    sqlite3_finalize (plugin->store_records);
  if (NULL != plugin->delete_records)
    sqlite3_finalize (plugin->delete_records);
  if (NULL != plugin->iterate_zone)
    sqlite3_finalize (plugin->iterate_zone);
  if (NULL != plugin->iterate_all_zones)
    sqlite3_finalize (plugin->iterate_all_zones);
  if (NULL != plugin->zone_to_name)
    sqlite3_finalize (plugin->zone_to_name);
  if (NULL != plugin->lookup_label)
    sqlite3_finalize (plugin->lookup_label);
  result = sqlite3_close (plugin->dbh);
  if (result == SQLITE_BUSY)
  {
    LOG (GNUNET_ERROR_TYPE_WARNING,
         _ (
           "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);
  }
  if (SQLITE_OK != result)
    LOG_SQLITE (plugin,
                GNUNET_ERROR_TYPE_ERROR,
                "sqlite3_close");
 
}

Referenced by libgnunet_plugin_namestore_sqlite_done().

Here is the caller graph for this function:

namestore_sqlite_store_records()

static enum GNUNET_GenericReturnValue namestore_sqlite_store_records ( void *  cls, const struct GNUNET_IDENTITY_PrivateKey *  zone_key, const char *  label, unsigned int  rd_count, const struct GNUNET_GNSRECORD_Data *  rd  )

static

Store a record in the datastore.

Removes any existing record in the same zone with the same name.

Parameters

cls	closure (internal context for the plugin)
zone_key	private key of the zone
label	name that is being mapped (at most 255 characters long)
rd_count	number of entries in rd array
rd	array of records with data to store

Returns

GNUNET_OK on success, else GNUNET_SYSERR

Definition at line 206 of file plugin_namestore_sqlite.c.

{
  struct Plugin *plugin = cls;
  int n;
  struct GNUNET_IDENTITY_PublicKey pkey;
  uint64_t rvalue;
  ssize_t data_size;
 
  GNUNET_assert (GNUNET_OK == database_prepare (plugin));
  memset (&pkey,
          0,
          sizeof(pkey));
  for (unsigned int i = 0; i < rd_count; i++)
  {
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "Checking if `%d' is zonekey type\n",
         rd[i].record_type);
 
    if (GNUNET_YES == GNUNET_GNSRECORD_is_zonekey_type (rd[i].record_type))
    {
      GNUNET_break (GNUNET_YES ==
                    GNUNET_GNSRECORD_identity_from_data (rd[i].data,
                                                         rd[i].data_size,
                                                         rd[i].record_type,
                                                         &pkey));
      LOG (GNUNET_ERROR_TYPE_DEBUG,
           "Storing delegation zone record value `%s'\n",
           GNUNET_GNSRECORD_z2s (&pkey));
 
      break;
    }
  }
  rvalue = GNUNET_CRYPTO_random_u64 (GNUNET_CRYPTO_QUALITY_WEAK,
                                     UINT64_MAX);
  data_size = GNUNET_GNSRECORD_records_get_size (rd_count,
                                                 rd);
  if (data_size < 0)
  {
    GNUNET_break (0);
    return GNUNET_SYSERR;
  }
  if (data_size > 64 * 65536)
  {
    GNUNET_break (0);
    return GNUNET_SYSERR;
  }
  {
    /* First delete 'old' records */
    char data[data_size];
    struct GNUNET_SQ_QueryParam dparams[] = {
      GNUNET_SQ_query_param_auto_from_type (zone_key),
      GNUNET_SQ_query_param_string (label),
      GNUNET_SQ_query_param_end
    };
    ssize_t ret;
 
    ret = GNUNET_GNSRECORD_records_serialize (rd_count,
                                              rd,
                                              data_size,
                                              data);
    if ((ret < 0) ||
        (data_size != ret))
    {
      GNUNET_break (0);
      return GNUNET_SYSERR;
    }
    if (GNUNET_OK !=
        GNUNET_SQ_bind (plugin->delete_records,
                        dparams))
    {
      LOG_SQLITE (plugin,
                  GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
                  "sqlite3_bind_XXXX");
      GNUNET_SQ_reset (plugin->dbh,
                       plugin->delete_records);
      return GNUNET_SYSERR;
    }
    n = sqlite3_step (plugin->delete_records);
    GNUNET_SQ_reset (plugin->dbh,
                     plugin->delete_records);
 
    if (0 != rd_count)
    {
      uint32_t rd_count32 = (uint32_t) rd_count;
      struct GNUNET_SQ_QueryParam sparams[] = {
        GNUNET_SQ_query_param_auto_from_type (zone_key),
        GNUNET_SQ_query_param_auto_from_type (&pkey),
        GNUNET_SQ_query_param_uint64 (&rvalue),
        GNUNET_SQ_query_param_uint32 (&rd_count32),
        GNUNET_SQ_query_param_fixed_size (data, data_size),
        GNUNET_SQ_query_param_string (label),
        GNUNET_SQ_query_param_end
      };
 
      if (GNUNET_OK !=
          GNUNET_SQ_bind (plugin->store_records,
                          sparams))
      {
        LOG_SQLITE (plugin,
                    GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
                    "sqlite3_bind_XXXX");
        GNUNET_SQ_reset (plugin->dbh,
                         plugin->store_records);
        return GNUNET_SYSERR;
      }
      n = sqlite3_step (plugin->store_records);
      GNUNET_SQ_reset (plugin->dbh,
                       plugin->store_records);
    }
  }
  switch (n)
  {
  case SQLITE_DONE:
    if (0 != rd_count)
      GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG,
                       "sqlite",
                       "Record stored\n");
    else
      GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG,
                       "sqlite",
                       "Record deleted\n");
    return GNUNET_OK;
 
  case SQLITE_BUSY:
    LOG_SQLITE (plugin,
                GNUNET_ERROR_TYPE_WARNING | GNUNET_ERROR_TYPE_BULK,
                "sqlite3_step");
    return GNUNET_NO;
 
  default:
    LOG_SQLITE (plugin,
                GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
                "sqlite3_step");
    return GNUNET_SYSERR;
  }
}

Referenced by libgnunet_plugin_namestore_sqlite_init().

Here is the caller graph for this function:

get_records_and_call_iterator()

static enum GNUNET_GenericReturnValue get_records_and_call_iterator ( struct Plugin *  plugin, sqlite3_stmt *  stmt, const struct GNUNET_IDENTITY_PrivateKey *  zone_key, uint64_t  limit, GNUNET_NAMESTORE_RecordIterator  iter, void *  iter_cls  )

static

The given 'sqlite' statement has been prepared to be run.

It will return a record which should be given to the iterator. Runs the statement and parses the returned record.

Parameters

plugin	plugin context
stmt	to run (and then clean up)
zone_key	private key of the zone
limit	maximum number of results to fetch
iter	iterator to call with the result
iter_cls	closure for iter

Returns

GNUNET_OK on success, GNUNET_NO if there were no results, GNUNET_SYSERR on error

Definition at line 206 of file plugin_namestore_sqlite.c.

{
  int ret;
  int sret;
 
  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;
    }
 
    {
      uint64_t seq;
      uint32_t record_count;
      size_t data_size;
      void *data;
      char *label;
      struct GNUNET_IDENTITY_PrivateKey zk;
      struct GNUNET_SQ_ResultSpec rs[] = {
        GNUNET_SQ_result_spec_uint64 (&seq),
        GNUNET_SQ_result_spec_uint32 (&record_count),
        GNUNET_SQ_result_spec_variable_size (&data,
                                             &data_size),
        GNUNET_SQ_result_spec_string (&label),
        GNUNET_SQ_result_spec_end
      };
      struct GNUNET_SQ_ResultSpec rsx[] = {
        GNUNET_SQ_result_spec_uint64 (&seq),
        GNUNET_SQ_result_spec_uint32 (&record_count),
        GNUNET_SQ_result_spec_variable_size (&data,
                                             &data_size),
        GNUNET_SQ_result_spec_string (&label),
        GNUNET_SQ_result_spec_auto_from_type (&zk),
        GNUNET_SQ_result_spec_end
      };
 
      ret = GNUNET_SQ_extract_result (stmt,
                                      (NULL == zone_key)
                                      ? rsx
                                      : rs);
      if ((GNUNET_OK != ret) ||
          (record_count > 64 * 1024))
      {
        /* sanity check, don't stack allocate far too much just
           because database might contain a large value here */
        GNUNET_break (0);
        ret = GNUNET_SYSERR;
        break;
      }
      else
      {
        struct GNUNET_GNSRECORD_Data rd[record_count];
 
        GNUNET_assert (0 != seq);
        if (GNUNET_OK !=
            GNUNET_GNSRECORD_records_deserialize (data_size,
                                                  data,
                                                  record_count,
                                                  rd))
        {
          GNUNET_break (0);
          ret = GNUNET_SYSERR;
          break;
        }
        else
        {
          if (NULL != zone_key)
            zk = *zone_key;
          if (NULL != iter)
            iter (iter_cls,
                  seq,
                  &zk,
                  label,
                  record_count,
                  rd);
        }
      }
      GNUNET_SQ_cleanup_result (rs);
    }
  }
  GNUNET_SQ_reset (plugin->dbh,
                   stmt);
  return ret;
}

namestore_sqlite_lookup_records()

static enum GNUNET_GenericReturnValue namestore_sqlite_lookup_records ( void *  cls, const struct GNUNET_IDENTITY_PrivateKey *  zone, const char *  label, GNUNET_NAMESTORE_RecordIterator  iter, void *  iter_cls  )

static

Lookup records in the datastore for which we are the authority.

Parameters

cls	closure (internal context for the plugin)
zone	private key of the zone
label	name of the record in the zone
iter	function to call with the result
iter_cls	closure for iter

Returns

GNUNET_OK on success, GNUNET_NO for no results, else GNUNET_SYSERR

Definition at line 206 of file plugin_namestore_sqlite.c.

{
  struct Plugin *plugin = cls;
  GNUNET_assert (GNUNET_OK == database_prepare (plugin));
  struct GNUNET_SQ_QueryParam params[] = {
    GNUNET_SQ_query_param_auto_from_type (zone),
    GNUNET_SQ_query_param_string (label),
    GNUNET_SQ_query_param_end
  };
 
  if (NULL == zone)
  {
    GNUNET_break (0);
    return GNUNET_SYSERR;
  }
  if (GNUNET_OK !=
      GNUNET_SQ_bind (plugin->lookup_label,
                      params))
  {
    LOG_SQLITE (plugin, GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
                "sqlite3_bind_XXXX");
    GNUNET_SQ_reset (plugin->dbh,
                     plugin->lookup_label);
    return GNUNET_SYSERR;
  }
  return get_records_and_call_iterator (plugin,
                                        plugin->lookup_label,
                                        zone,
                                        1,
                                        iter,
                                        iter_cls);
}

Referenced by libgnunet_plugin_namestore_sqlite_init().

Here is the caller graph for this function:

namestore_sqlite_iterate_records()

static enum GNUNET_GenericReturnValue namestore_sqlite_iterate_records ( void *  cls, const struct GNUNET_IDENTITY_PrivateKey *  zone, uint64_t  serial, uint64_t  limit, GNUNET_NAMESTORE_RecordIterator  iter, void *  iter_cls  )

static

Iterate over the results for a particular key and zone in the datastore.

Will return at most one result to the iterator.

Parameters

cls	closure (internal context for the plugin)
zone	hash of public key of the zone, NULL to iterate over all zones
serial	serial number to exclude in the list of all matching records
limit	maximum number of results to return
iter	function to call with the result
iter_cls	closure for iter

Returns

GNUNET_OK on success, GNUNET_NO if there were no more results, GNUNET_SYSERR on error

Definition at line 206 of file plugin_namestore_sqlite.c.

{
  struct Plugin *plugin = cls;
  sqlite3_stmt *stmt;
  int err;
 
  GNUNET_assert (GNUNET_OK == database_prepare (plugin));
  if (NULL == zone)
  {
    struct GNUNET_SQ_QueryParam params[] = {
      GNUNET_SQ_query_param_uint64 (&serial),
      GNUNET_SQ_query_param_uint64 (&limit),
      GNUNET_SQ_query_param_end
    };
 
    stmt = plugin->iterate_all_zones;
    err = GNUNET_SQ_bind (stmt,
                          params);
  }
  else
  {
    struct GNUNET_SQ_QueryParam params[] = {
      GNUNET_SQ_query_param_auto_from_type (zone),
      GNUNET_SQ_query_param_uint64 (&serial),
      GNUNET_SQ_query_param_uint64 (&limit),
      GNUNET_SQ_query_param_end
    };
 
    stmt = plugin->iterate_zone;
    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;
  }
  return get_records_and_call_iterator (plugin,
                                        stmt,
                                        zone,
                                        limit,
                                        iter,
                                        iter_cls);
}

Referenced by libgnunet_plugin_namestore_sqlite_init().

Here is the caller graph for this function:

namestore_sqlite_zone_to_name()

static enum GNUNET_GenericReturnValue namestore_sqlite_zone_to_name ( void *  cls, const struct GNUNET_IDENTITY_PrivateKey *  zone, const struct GNUNET_IDENTITY_PublicKey *  value_zone, GNUNET_NAMESTORE_RecordIterator  iter, void *  iter_cls  )

static

Look for an existing PKEY delegation record for a given public key.

Returns at most one result to the iterator.

Parameters

cls	closure (internal context for the plugin)
zone	private key of the zone to look up in, never NULL
value_zone	public key of the target zone (value), never NULL
iter	function to call with the result
iter_cls	closure for iter

Returns

GNUNET_OK on success, GNUNET_NO if there were no results, GNUNET_SYSERR on error

Definition at line 206 of file plugin_namestore_sqlite.c.

{
  struct Plugin *plugin = cls;
  GNUNET_assert (GNUNET_OK == database_prepare (plugin));
  struct GNUNET_SQ_QueryParam params[] = {
    GNUNET_SQ_query_param_auto_from_type (zone),
    GNUNET_SQ_query_param_auto_from_type (value_zone),
    GNUNET_SQ_query_param_end
  };
 
  if (GNUNET_OK !=
      GNUNET_SQ_bind (plugin->zone_to_name,
                      params))
  {
    LOG_SQLITE (plugin,
                GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
                "sqlite3_bind_XXXX");
    GNUNET_SQ_reset (plugin->dbh,
                     plugin->zone_to_name);
    return GNUNET_SYSERR;
  }
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Performing reverse lookup for `%s'\n",
       GNUNET_GNSRECORD_z2s (value_zone));
  return get_records_and_call_iterator (plugin,
                                        plugin->zone_to_name,
                                        zone,
                                        1,
                                        iter,
                                        iter_cls);
}

Referenced by libgnunet_plugin_namestore_sqlite_init().

Here is the caller graph for this function:

namestore_sqlite_transaction_begin()

static enum GNUNET_GenericReturnValue namestore_sqlite_transaction_begin ( void *  cls, char **  emsg  )

static

Begin a transaction for a client.

This locks the database. SQLite is unable to discern between different rows with a specific zone key but the API looks like this anyway. https://www.sqlite.org/lang_transaction.html

Parameters

cls	closure (internal context for the plugin)
emsg	error message set of return code is GNUNET_SYSERR

Returns

GNUNET_YES on success, GNUNET_SYSERR if transaction cannot be started.

Definition at line 206 of file plugin_namestore_sqlite.c.

{
  struct Plugin *plugin = cls;
  int rc;
  char *sqlEmsg;
 
  GNUNET_assert (GNUNET_OK == database_prepare (plugin));
  rc = sqlite3_exec (plugin->dbh, "BEGIN IMMEDIATE TRANSACTION;",
                     NULL, NULL, &sqlEmsg);
  if (SQLITE_OK != rc)
  {
    *emsg = GNUNET_strdup (sqlEmsg);
    sqlite3_free (sqlEmsg);
  }
  return (SQLITE_OK != rc) ? GNUNET_SYSERR : GNUNET_YES;
}

Referenced by libgnunet_plugin_namestore_sqlite_init().

Here is the caller graph for this function:

namestore_sqlite_transaction_rollback()

static enum GNUNET_GenericReturnValue namestore_sqlite_transaction_rollback ( void *  cls, char **  emsg  )

static

Commit a transaction for a client.

This releases the lock on the database.

Parameters

cls	closure (internal context for the plugin)
emsg	error message set of return code is GNUNET_SYSERR

Returns

GNUNET_YES on success, GNUNET_SYSERR if transaction cannot be started.

Definition at line 206 of file plugin_namestore_sqlite.c.

{
  struct Plugin *plugin = cls;
  int rc;
  char *sqlEmsg;
 
  GNUNET_assert (GNUNET_OK == database_prepare (plugin));
  rc = sqlite3_exec (plugin->dbh, "ROLLBACK;",
                     NULL, NULL, &sqlEmsg);
  if (SQLITE_OK != rc)
  {
    *emsg = GNUNET_strdup (sqlEmsg);
    sqlite3_free (sqlEmsg);
  }
  return (SQLITE_OK != rc) ? GNUNET_SYSERR : GNUNET_YES;
}

Referenced by libgnunet_plugin_namestore_sqlite_init().

Here is the caller graph for this function:

namestore_sqlite_transaction_commit()

static enum GNUNET_GenericReturnValue namestore_sqlite_transaction_commit ( void *  cls, char **  emsg  )

static

Roll back a transaction for a client.

This releases the lock on the database.

Parameters

cls	closure (internal context for the plugin)
emsg	error message set of return code is GNUNET_SYSERR

Returns

GNUNET_YES on success, GNUNET_SYSERR if transaction cannot be started.

Definition at line 206 of file plugin_namestore_sqlite.c.

{
  struct Plugin *plugin = cls;
  int rc;
  char *sqlEmsg;
 
  GNUNET_assert (GNUNET_OK == database_prepare (plugin));
  rc = sqlite3_exec (plugin->dbh, "END TRANSACTION;",
                     NULL, NULL, &sqlEmsg);
  if (SQLITE_OK != rc)
  {
    *emsg = GNUNET_strdup (sqlEmsg);
    sqlite3_free (sqlEmsg);
  }
  return (SQLITE_OK != rc) ? GNUNET_SYSERR : GNUNET_YES;
}

Referenced by libgnunet_plugin_namestore_sqlite_init().

Here is the caller graph for this function:

namestore_sqlite_create_tables()

static enum GNUNET_GenericReturnValue namestore_sqlite_create_tables ( void *  cls )

static

Definition at line 206 of file plugin_namestore_sqlite.c.

{
  struct Plugin *plugin = cls;
  struct GNUNET_SQ_ExecuteStatement es[] = {
    GNUNET_SQ_make_try_execute ("PRAGMA temp_store=MEMORY"),
    GNUNET_SQ_make_try_execute ("PRAGMA synchronous=NORMAL"),
    GNUNET_SQ_make_try_execute ("PRAGMA legacy_file_format=OFF"),
    GNUNET_SQ_make_try_execute ("PRAGMA auto_vacuum=INCREMENTAL"),
    GNUNET_SQ_make_try_execute ("PRAGMA encoding=\"UTF-8\""),
    GNUNET_SQ_make_try_execute ("PRAGMA locking_mode=NORMAL"),
    GNUNET_SQ_make_try_execute ("PRAGMA journal_mode=WAL"),
    GNUNET_SQ_make_try_execute ("PRAGMA page_size=4092"),
    GNUNET_SQ_make_execute ("CREATE TABLE IF NOT EXISTS ns098records ("
                            " uid INTEGER PRIMARY KEY,"
                            " zone_private_key BLOB NOT NULL,"
                            " pkey BLOB,"
                            " rvalue INT8 NOT NULL,"
                            " record_count INT NOT NULL,"
                            " record_data BLOB NOT NULL,"
                            " label TEXT NOT NULL"
                            ")"),
    GNUNET_SQ_make_try_execute ("CREATE INDEX ir_pkey_reverse "
                                "ON ns098records (zone_private_key,pkey)"),
    GNUNET_SQ_make_try_execute ("CREATE INDEX ir_pkey_iter "
                                "ON ns098records (zone_private_key,uid)"),
    GNUNET_SQ_EXECUTE_STATEMENT_END
  };
 
  if (GNUNET_OK !=
      GNUNET_SQ_exec_statements (plugin->dbh,
                                 es))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                "Failed to setup database with: `%s'\n",
                sqlite3_errmsg (plugin->dbh));
    return GNUNET_SYSERR;
  }
  return GNUNET_OK;
}

Referenced by libgnunet_plugin_namestore_sqlite_init().

Here is the caller graph for this function:

namestore_sqlite_drop_tables()

static enum GNUNET_GenericReturnValue namestore_sqlite_drop_tables ( void *  cls )

static

Definition at line 206 of file plugin_namestore_sqlite.c.

{
  struct Plugin *plugin = cls;
  struct GNUNET_SQ_ExecuteStatement es_drop[] = {
    GNUNET_SQ_make_execute ("DROP TABLE IF EXISTS ns098records"),
    GNUNET_SQ_EXECUTE_STATEMENT_END
  };
 
  if (GNUNET_OK !=
      GNUNET_SQ_exec_statements (plugin->dbh,
                                 es_drop))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                "Failed to drop database with: `%s'\n",
                sqlite3_errmsg (plugin->dbh));
    return GNUNET_SYSERR;
  }
  return GNUNET_OK;
}

Referenced by libgnunet_plugin_namestore_sqlite_init().

Here is the caller graph for this function:

database_connect()

static enum GNUNET_GenericReturnValue database_connect ( 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 206 of file plugin_namestore_sqlite.c.

{
  char *sqlite_filename;
 
  if (GNUNET_OK !=
      GNUNET_CONFIGURATION_get_value_filename (plugin->cfg,
                                               "namestore-sqlite",
                                               "FILENAME",
                                               &sqlite_filename))
  {
    GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR,
                               "namestore-sqlite",
                               "FILENAME");
    return GNUNET_SYSERR;
  }
  if (GNUNET_OK !=
      GNUNET_DISK_file_test (sqlite_filename))
  {
    if (GNUNET_OK !=
        GNUNET_DISK_directory_create_for_file (sqlite_filename))
    {
      GNUNET_break (0);
      GNUNET_free (sqlite_filename);
      return GNUNET_SYSERR;
    }
  }
 
  /* Open database and precompile statements */
  if ((NULL == plugin->dbh) &&
      (SQLITE_OK != sqlite3_open (sqlite_filename,
                                  &plugin->dbh)))
  {
    LOG (GNUNET_ERROR_TYPE_ERROR,
         _ ("Unable to initialize SQLite: %s.\n"),
         sqlite3_errmsg (plugin->dbh));
    GNUNET_free (sqlite_filename);
    return GNUNET_SYSERR;
  }
  GNUNET_free (sqlite_filename);
  GNUNET_break (SQLITE_OK ==
                sqlite3_busy_timeout (plugin->dbh,
                                      BUSY_TIMEOUT_MS));
  if (GNUNET_YES ==
      GNUNET_CONFIGURATION_get_value_yesno (plugin->cfg,
                                            "namestore-sqlite",
                                            "INIT_ON_CONNECT"))
  {
    if (GNUNET_OK !=
        namestore_sqlite_create_tables (plugin))
      return GNUNET_SYSERR;
  }
  return GNUNET_OK;
}

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

Referenced by libgnunet_plugin_namestore_sqlite_init().

Here is the caller graph for this function:

libgnunet_plugin_namestore_sqlite_init()

void* libgnunet_plugin_namestore_sqlite_init

(

void *

cls

)

Entry point for the plugin.

Parameters

cls	the "struct GNUNET_NAMESTORE_PluginEnvironment*"

Returns

NULL on error, otherwise the plugin context

NOTE: Since SQlite does not support SELECT ... FOR UPDATE this is just an alias to lookup_records. The BEGIN IMMEDIATE mechanic currently implicitly ensures this API behaves as it should

Definition at line 923 of file plugin_namestore_sqlite.c.

{
  struct Plugin *plugin;
  const struct GNUNET_CONFIGURATION_Handle *cfg = cls;
  struct GNUNET_NAMESTORE_PluginFunctions *api;
 
  plugin = GNUNET_new (struct Plugin);
  plugin->cfg = cfg;
  if (GNUNET_OK != database_connect (plugin))
  {
    LOG (GNUNET_ERROR_TYPE_ERROR,
         "Database could not be connected to.\n");
    GNUNET_free (plugin);
    return NULL;
  }
  api = GNUNET_new (struct GNUNET_NAMESTORE_PluginFunctions);
  api->cls = plugin;
  api->store_records = &namestore_sqlite_store_records;
  api->iterate_records = &namestore_sqlite_iterate_records;
  api->zone_to_name = &namestore_sqlite_zone_to_name;
  api->lookup_records = &namestore_sqlite_lookup_records;
  api->transaction_begin = &namestore_sqlite_transaction_begin;
  api->transaction_commit = &namestore_sqlite_transaction_commit;
  api->transaction_rollback = &namestore_sqlite_transaction_rollback;
  api->create_tables = &namestore_sqlite_create_tables;
  api->drop_tables = &namestore_sqlite_drop_tables;
  api->edit_records = &namestore_sqlite_lookup_records;
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       _ ("SQlite database running\n"));
  return api;
}

References _, cfg, GNUNET_NAMESTORE_PluginFunctions::cls, GNUNET_NAMESTORE_PluginFunctions::create_tables, database_connect(), GNUNET_NAMESTORE_PluginFunctions::drop_tables, GNUNET_NAMESTORE_PluginFunctions::edit_records, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_free, GNUNET_new, GNUNET_OK, GNUNET_NAMESTORE_PluginFunctions::iterate_records, LOG, GNUNET_NAMESTORE_PluginFunctions::lookup_records, namestore_sqlite_create_tables(), namestore_sqlite_drop_tables(), namestore_sqlite_iterate_records(), namestore_sqlite_lookup_records(), namestore_sqlite_store_records(), namestore_sqlite_transaction_begin(), namestore_sqlite_transaction_commit(), namestore_sqlite_transaction_rollback(), namestore_sqlite_zone_to_name(), plugin, GNUNET_NAMESTORE_PluginFunctions::store_records, GNUNET_NAMESTORE_PluginFunctions::transaction_begin, GNUNET_NAMESTORE_PluginFunctions::transaction_commit, GNUNET_NAMESTORE_PluginFunctions::transaction_rollback, and GNUNET_NAMESTORE_PluginFunctions::zone_to_name.

Here is the call graph for this function:

libgnunet_plugin_namestore_sqlite_done()

void* libgnunet_plugin_namestore_sqlite_done

(

void *

cls

)

Exit point from the plugin.

Parameters

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

Returns

always NULL

Definition at line 968 of file plugin_namestore_sqlite.c.

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

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

Here is the call graph for this function: