/*
* This file is part of GNUnet
- * (C) 2009, 2011, 2012 Christian Grothoff (and other contributing authors)
+ * Copyright (C) 2009-2017 GNUnet e.V.
*
- * GNUnet is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published
- * by the Free Software Foundation; either version 3, or (at your
- * option) any later version.
+ * GNUnet is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Affero General Public License as published
+ * by the Free Software Foundation, either version 3 of the License,
+ * or (at your option) any later version.
*
* GNUnet is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with GNUnet; see the file COPYING. If not, write to the
- * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
- * Boston, MA 02111-1307, USA.
+ * Affero General Public License for more details.
*/
/**
#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>
/**
- * 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).
+ * 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.
+ * huge latencies while at the same time allowing operations to
+ * succeed with reasonable probability.
*/
#define BUSY_TIMEOUT_MS 1000
sqlite3 *dbh;
/**
- * Precompiled SQL for put record
- */
- sqlite3_stmt *put_record;
-
- /**
- * Precompiled SQL for put node
+ * Precompiled SQL to store records.
*/
- sqlite3_stmt *put_node;
+ sqlite3_stmt *store_records;
/**
- * Precompiled SQL for put signature
+ * Precompiled SQL to deltete existing records.
*/
- sqlite3_stmt *put_signature;
+ sqlite3_stmt *delete_records;
/**
- * Precompiled SQL for iterate records
+ * Precompiled SQL for iterate records within a zone.
*/
- sqlite3_stmt *iterate_records;
+ sqlite3_stmt *iterate_zone;
/**
- * Precompiled SQL for get node
+ * Precompiled SQL for iterate all records within all zones.
*/
- sqlite3_stmt *get_node;
+ sqlite3_stmt *iterate_all_zones;
/**
- * Precompiled SQL for get signature
+ * Precompiled SQL to for reverse lookup based on PKEY.
*/
- sqlite3_stmt *get_signature;
+ sqlite3_stmt *zone_to_name;
/**
- * Precompiled SQL for delete zone
+ * Precompiled SQL to lookup records based on label.
*/
- sqlite3_stmt *delete_zone_records;
-
- /**
- * Precompiled SQL for delete zone
- */
- sqlite3_stmt *delete_zone_nodes;
-
- /**
- * Precompiled SQL for delete zone
- */
- sqlite3_stmt *delete_zone_signatures;
-
+ sqlite3_stmt *lookup_label;
};
-/**
- * @brief Prepare a SQL statement
- *
- * @param dbh handle to the database
- * @param zSql SQL statement, UTF-8 encoded
- * @param ppStmt set to the prepared statement
- * @return 0 on success
- */
-static int
-sq_prepare (sqlite3 * dbh, const char *zSql, sqlite3_stmt ** ppStmt)
-{
- char *dummy;
- int result;
-
- result =
- sqlite3_prepare_v2 (dbh, zSql, strlen (zSql), ppStmt,
- (const char **) &dummy);
- LOG (GNUNET_ERROR_TYPE_DEBUG,
- "Prepared `%s' / %p: %d\n", zSql, *ppStmt, result);
- return result;
-}
-
-
-/**
- * Create our database indices.
- *
- * @param dbh handle to the database
- */
-static void
-create_indices (sqlite3 * dbh)
-{
- /* create indices */
- if (SQLITE_OK !=
- sqlite3_exec (dbh, "CREATE INDEX IF NOT EXISTS ir_zone_name_hash ON ns090records (zone_hash,record_name_hash)",
- NULL, NULL, NULL))
- LOG (GNUNET_ERROR_TYPE_ERROR,
- "Failed to create indices: %s\n", sqlite3_errmsg (dbh));
-
-
- if (SQLITE_OK !=
- sqlite3_exec (dbh, "CREATE INDEX IF NOT EXISTS in_zone_location ON ns090nodes (zone_hash,zone_revision,node_location_depth,node_location_offset DESC)",
- NULL, NULL, NULL))
- LOG (GNUNET_ERROR_TYPE_ERROR,
- "Failed to create indices: %s\n", sqlite3_errmsg (dbh));
-
-
- if (SQLITE_OK !=
- sqlite3_exec (dbh, "CREATE INDEX IF NOT EXISTS is_zone ON ns090signatures (zone_hash)",
- NULL, NULL, NULL))
- LOG (GNUNET_ERROR_TYPE_ERROR,
- "Failed to create indices: %s\n", sqlite3_errmsg (dbh));
-}
-
-
-#if 0
-#define CHECK(a) GNUNET_break(a)
-#define ENULL NULL
-#else
-#define ENULL &e
-#define ENULL_DEFINED 1
-#define CHECK(a) if (! a) { GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "%s\n", e); sqlite3_free(e); }
-#endif
-
-
/**
* Initialize the database connections and associated
* data structures (create tables and indices
* as needed as well).
*
* @param plugin the plugin context (state for this module)
- * @return GNUNET_OK on success
+ * @return #GNUNET_OK on success
*/
static int
database_setup (struct Plugin *plugin)
{
- sqlite3_stmt *stmt;
- char *afsdir;
-#if ENULL_DEFINED
- char *e;
-#endif
+ char *sqlite_filename;
+ 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=EXCLUSIVE"),
+ 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 IF NOT EXISTS ir_pkey_reverse "
+ "ON ns098records (zone_private_key,pkey)"),
+ GNUNET_SQ_make_try_execute ("CREATE INDEX IF NOT EXISTS ir_pkey_iter "
+ "ON ns098records (zone_private_key,uid)"),
+ 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 _rowid_ >= ?"
+ " ORDER BY _rowid_ ASC"
+ " LIMIT ?",
+ &plugin->iterate_zone),
+ GNUNET_SQ_make_prepare ("SELECT uid,record_count,record_data,label,zone_private_key"
+ " FROM ns098records"
+ " WHERE _rowid_ >= ?"
+ " ORDER BY _rowid_ ASC"
+ " LIMIT ?",
+ &plugin->iterate_all_zones),
+ GNUNET_SQ_make_prepare ("SELECT uid,record_count,record_data,label,zone_private_key"
+ " FROM ns098records"
+ " WHERE zone_private_key=? AND label=?",
+ &plugin->lookup_label),
+ GNUNET_SQ_PREPARE_END
+ };
if (GNUNET_OK !=
- GNUNET_CONFIGURATION_get_value_filename (plugin->cfg, "namestore-sqlite",
- "FILENAME", &afsdir))
- {
- LOG (GNUNET_ERROR_TYPE_ERROR,
- _ ("Option `%s' in section `%s' missing in configuration!\n"),
- "FILENAME", "namestore-sqlite");
+ 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 (afsdir))
+ if (GNUNET_OK !=
+ GNUNET_DISK_file_test (sqlite_filename))
{
- if (GNUNET_OK != GNUNET_DISK_directory_create_for_file (afsdir))
+ if (GNUNET_OK !=
+ GNUNET_DISK_directory_create_for_file (sqlite_filename))
{
GNUNET_break (0);
- GNUNET_free (afsdir);
+ GNUNET_free (sqlite_filename);
return GNUNET_SYSERR;
}
}
-#ifdef ENABLE_NLS
- plugin->fn =
- GNUNET_STRINGS_to_utf8 (afsdir, strlen (afsdir), nl_langinfo (CODESET));
-#else
- plugin->fn = GNUNET_STRINGS_to_utf8 (afsdir, strlen (afsdir), "UTF-8"); /* good luck */
-#endif
- GNUNET_free (afsdir);
+ /* sqlite_filename should be UTF-8-encoded. If it isn't, it's a bug */
+ plugin->fn = sqlite_filename;
/* Open database and precompile statements */
- if (sqlite3_open (plugin->fn, &plugin->dbh) != SQLITE_OK)
+ 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;
}
- CHECK (SQLITE_OK ==
- sqlite3_exec (plugin->dbh, "PRAGMA temp_store=MEMORY", NULL, NULL,
- ENULL));
- CHECK (SQLITE_OK ==
- sqlite3_exec (plugin->dbh, "PRAGMA synchronous=NORMAL", 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 encoding=\"UTF-8\"", 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 count_changes=OFF", NULL, NULL,
- ENULL));
- CHECK (SQLITE_OK ==
- sqlite3_exec (plugin->dbh, "PRAGMA page_size=4092", NULL, NULL,
- ENULL));
-
- CHECK (SQLITE_OK == sqlite3_busy_timeout (plugin->dbh, BUSY_TIMEOUT_MS));
-
-
- /* Create tables */
- CHECK (SQLITE_OK ==
- sq_prepare (plugin->dbh,
- "SELECT 1 FROM sqlite_master WHERE tbl_name = 'ns090records'",
- &stmt));
- if ((sqlite3_step (stmt) == SQLITE_DONE) &&
- (sqlite3_exec
- (plugin->dbh,
- "CREATE TABLE ns090records ("
- " zone_hash BLOB NOT NULL DEFAULT '',"
- " zone_revision INT4 NOT NULL DEFAULT 0,"
- " record_name_hash BLOB NOT NULL DEFAULT '',"
- " record_name TEXT NOT NULL DEFAULT '',"
- " record_type INT4 NOT NULL DEFAULT 0,"
- " node_location_depth INT4 NOT NULL DEFAULT 0,"
- " node_location_offset INT8 NOT NULL DEFAULT 0,"
- " record_expiration_time INT8 NOT NULL DEFAULT 0,"
- " record_flags INT4 NOT NULL DEFAULT 0,"
- " record_value BLOB NOT NULL DEFAULT ''"
- ")",
- NULL, NULL, NULL) != SQLITE_OK))
- {
- LOG_SQLITE (plugin, GNUNET_ERROR_TYPE_ERROR, "sqlite3_exec");
- sqlite3_finalize (stmt);
- return GNUNET_SYSERR;
- }
- sqlite3_finalize (stmt);
-
- CHECK (SQLITE_OK ==
- sq_prepare (plugin->dbh,
- "SELECT 1 FROM sqlite_master WHERE tbl_name = 'ns090nodes'",
- &stmt));
- if ((sqlite3_step (stmt) == SQLITE_DONE) &&
- (sqlite3_exec
- (plugin->dbh,
- "CREATE TABLE ns090nodes ("
- " zone_hash BLOB NOT NULL DEFAULT '',"
- " zone_revision INT4 NOT NULL DEFAULT 0,"
- " node_location_depth INT4 NOT NULL DEFAULT 0,"
- " node_location_offset INT8 NOT NULL DEFAULT 0,"
- " node_parent_offset INT8 NOT NULL DEFAULT 0,"
- " node_hashcodes BLOB NOT NULL DEFAULT ''"
- ")",
- NULL, NULL, NULL) != SQLITE_OK))
- {
- LOG_SQLITE (plugin, GNUNET_ERROR_TYPE_ERROR, "sqlite3_exec");
- sqlite3_finalize (stmt);
- return GNUNET_SYSERR;
- }
- sqlite3_finalize (stmt);
-
-
- CHECK (SQLITE_OK ==
- sq_prepare (plugin->dbh,
- "SELECT 1 FROM sqlite_master WHERE tbl_name = 'ns090signatures'",
- &stmt));
- if ((sqlite3_step (stmt) == SQLITE_DONE) &&
- (sqlite3_exec
- (plugin->dbh,
- "CREATE TABLE ns090signatures ("
- " zone_hash BLOB NOT NULL DEFAULT '',"
- " zone_revision INT4 NOT NULL DEFAULT 0,"
- " zone_time INT8 NOT NULL DEFAULT 0,"
- " zone_root_hash BLOB NOT NULL DEFAULT 0,"
- " zone_root_depth INT4 NOT NULL DEFAULT 0,"
- " zone_public_key BLOB NOT NULL DEFAULT 0,"
- " zone_signature BLOB NOT NULL DEFAULT 0"
- ")",
- NULL, NULL, NULL) != SQLITE_OK))
+ GNUNET_break (SQLITE_OK ==
+ sqlite3_busy_timeout (plugin->dbh,
+ BUSY_TIMEOUT_MS));
+ if (GNUNET_OK !=
+ GNUNET_SQ_exec_statements (plugin->dbh,
+ es))
{
- LOG_SQLITE (plugin, GNUNET_ERROR_TYPE_ERROR, "sqlite3_exec");
- sqlite3_finalize (stmt);
+ GNUNET_break (0);
+ LOG (GNUNET_ERROR_TYPE_ERROR,
+ _("Failed to setup database at `%s'\n"),
+ plugin->fn);
return GNUNET_SYSERR;
}
- sqlite3_finalize (stmt);
-
- create_indices (plugin->dbh);
-
- if ((sq_prepare
- (plugin->dbh,
- "INSERT INTO ns090records (zone_hash, zone_revision, record_name_hash, record_name, "
- "record_type, node_location_depth, node_location_offset, "
- "record_expiration_time, record_flags, record_value) VALUES "
- "(?, ?, ?, ?, ?, ?, ?, ?, ?, ?)",
- &plugin->put_record) != SQLITE_OK) ||
- (sq_prepare
- (plugin->dbh,
- "INSERT INTO ns090nodes (zone_hash, zone_revision, "
- "node_location_depth, node_location_offset, node_parent_offset, node_hashcodes) "
- "VALUES (?, ?, ?, ?, ?, ?)",
- &plugin->put_node) != SQLITE_OK) ||
- (sq_prepare
- (plugin->dbh,
- "INSERT INTO ns090signatures (zone_hash, zone_revision, zone_time, zone_root_hash, "
- "zone_root_depth, zone_public_key, zone_signature) "
- "VALUES (?, ?, ?, ?, ?, ?, ?)",
- &plugin->put_signature) != SQLITE_OK) ||
- (sq_prepare
- (plugin->dbh,
- "SELECT zone_revision,record_name,record_type,node_location_depth,node_location_offset,record_expiration_time,record_flags,record_value "
- "FROM ns090records WHERE zone_hash=? AND record_name_hash=?",
- &plugin->iterate_records) != SQLITE_OK) ||
- (sq_prepare
- (plugin->dbh,
- "SELECT node_parent_offset,node_location_offset,node_hashcodes FROM ns090nodes "
- "WHERE zone_hash=? AND zone_revision=? AND node_location_depth=? AND node_location_offset<=? ORDER BY node_location_offset DESC LIMIT 1",
- &plugin->get_node) != SQLITE_OK) ||
- (sq_prepare
- (plugin->dbh,
- "SELECT zone_revision,zone_time,zone_root_hash,zone_root_depth,zone_public_key,zone_signature "
- "FROM ns090signatures WHERE zone_hash=?",
- &plugin->get_signature) != SQLITE_OK) ||
- (sq_prepare
- (plugin->dbh,
- "DELETE FROM ns090records WHERE zone_hash=?",
- &plugin->delete_zone_records) != SQLITE_OK) ||
- (sq_prepare
- (plugin->dbh,
- "DELETE FROM ns090nodes WHERE zone_hash=?",
- &plugin->delete_zone_nodes) != SQLITE_OK) ||
- (sq_prepare
- (plugin->dbh,
- "DELETE FROM ns090signatures WHERE zone_hash=?",
- &plugin->delete_zone_signatures) != SQLITE_OK) )
+ if (GNUNET_OK !=
+ GNUNET_SQ_prepare (plugin->dbh,
+ ps))
{
- LOG_SQLITE (plugin,GNUNET_ERROR_TYPE_ERROR, "precompiling");
+ GNUNET_break (0);
+ LOG (GNUNET_ERROR_TYPE_ERROR,
+ _("Failed to setup database at `%s'\n"),
+ plugin->fn);
return GNUNET_SYSERR;
}
return GNUNET_OK;
int result;
sqlite3_stmt *stmt;
- if (NULL != plugin->put_record)
- sqlite3_finalize (plugin->put_record);
- if (NULL != plugin->put_node)
- sqlite3_finalize (plugin->put_node);
- if (NULL != plugin->put_signature)
- sqlite3_finalize (plugin->put_signature);
- if (NULL != plugin->iterate_records)
- sqlite3_finalize (plugin->iterate_records);
- if (NULL != plugin->get_node)
- sqlite3_finalize (plugin->get_node);
- if (NULL != plugin->get_signature)
- sqlite3_finalize (plugin->get_signature);
- if (NULL != plugin->delete_zone_records)
- sqlite3_finalize (plugin->delete_zone_records);
- if (NULL != plugin->delete_zone_nodes)
- sqlite3_finalize (plugin->delete_zone_nodes);
- if (NULL != plugin->delete_zone_signatures)
- sqlite3_finalize (plugin->delete_zone_signatures);
+ 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 (stmt != NULL)
+ stmt = sqlite3_next_stmt (plugin->dbh,
+ NULL);
+ while (NULL != stmt)
{
- GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, "sqlite",
- "Closing statement %p\n", 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);
+ 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");
+ LOG_SQLITE (plugin,
+ GNUNET_ERROR_TYPE_ERROR,
+ "sqlite3_close");
GNUNET_free_non_null (plugin->fn);
}
/**
- * Store a record in the datastore.
+ * Store a record in the datastore. Removes any existing record in the
+ * same zone with the same name.
*
* @param cls closure (internal context for the plugin)
- * @param zone hash of the public key of the zone
- * @param name name that is being mapped (at most 255 characters long)
- * @param record_type type of the record (A, AAAA, PKEY, etc.)
- * @param loc location of the signature for the record
- * @param expiration expiration time for the content
- * @param flags flags for the content
- * @param data_size number of bytes in data
- * @param data value, semantics depend on 'record_type' (see RFCs for DNS and
- * GNS specification for GNS extensions)
- * @return GNUNET_OK on success
+ * @param zone_key private key of the zone
+ * @param label name that is being mapped (at most 255 characters long)
+ * @param rd_count number of entries in @a rd array
+ * @param rd array of records with data to store
+ * @return #GNUNET_OK on success, else #GNUNET_SYSERR
*/
-static int
-namestore_sqlite_put_record (void *cls,
- const GNUNET_HashCode *zone,
- const char *name,
- uint32_t record_type,
- const struct GNUNET_NAMESTORE_SignatureLocation *loc,
- struct GNUNET_TIME_Absolute expiration,
- enum GNUNET_NAMESTORE_RecordFlags flags,
- size_t data_size,
- const void *data)
+static int
+namestore_sqlite_store_records (void *cls,
+ const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone_key,
+ const char *label,
+ unsigned int rd_count,
+ const struct GNUNET_GNSRECORD_Data *rd)
{
struct Plugin *plugin = cls;
int n;
- GNUNET_HashCode nh;
- size_t name_len;
-
- name_len = strlen (name);
- GNUNET_CRYPTO_hash (name, name_len, &nh);
- if ((SQLITE_OK != sqlite3_bind_blob (plugin->put_record, 1, zone, sizeof (GNUNET_HashCode), SQLITE_STATIC)) ||
- (SQLITE_OK != sqlite3_bind_int64 (plugin->put_record, 2, loc->revision)) ||
- (SQLITE_OK != sqlite3_bind_blob (plugin->put_record, 3, &nh, sizeof (GNUNET_HashCode), SQLITE_STATIC)) ||
- (SQLITE_OK != sqlite3_bind_text (plugin->put_record, 4, name, -1, SQLITE_STATIC)) ||
- (SQLITE_OK != sqlite3_bind_int (plugin->put_record, 5, record_type)) ||
- (SQLITE_OK != sqlite3_bind_int (plugin->put_record, 6, loc->depth)) ||
- (SQLITE_OK != sqlite3_bind_int64 (plugin->put_record, 7, loc->offset)) ||
- (SQLITE_OK != sqlite3_bind_int64 (plugin->put_record, 8, expiration.abs_value)) ||
- (SQLITE_OK != sqlite3_bind_int (plugin->put_record, 9, flags)) ||
- (SQLITE_OK != sqlite3_bind_blob (plugin->put_record, 10, data, data_size, SQLITE_STATIC)) )
+ struct GNUNET_CRYPTO_EcdsaPublicKey pkey;
+ uint64_t rvalue;
+ ssize_t data_size;
+
+ memset (&pkey,
+ 0,
+ sizeof (pkey));
+ for (unsigned int i=0;i<rd_count;i++)
+ if (GNUNET_GNSRECORD_TYPE_PKEY == rd[i].record_type)
+ {
+ GNUNET_break (sizeof (struct GNUNET_CRYPTO_EcdsaPublicKey) ==
+ rd[i].data_size);
+ GNUNET_memcpy (&pkey,
+ rd[i].data,
+ rd[i].data_size);
+ 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)
{
- LOG_SQLITE (plugin,
- GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
- "sqlite3_bind_XXXX");
- if (SQLITE_OK != sqlite3_reset (plugin->put_record))
- LOG_SQLITE (plugin,
- GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
- "sqlite3_reset");
+ GNUNET_break (0);
return GNUNET_SYSERR;
-
}
- n = sqlite3_step (plugin->put_record);
- if (SQLITE_OK != sqlite3_reset (plugin->put_record))
- LOG_SQLITE (plugin, GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
- "sqlite3_reset");
- switch (n)
- {
- case SQLITE_DONE:
- GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, "sqlite", "Record stored\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;
- }
-}
-
-
-/**
- * Store a Merkle tree node in the datastore.
- *
- * @param cls closure (internal context for the plugin)
- * @param zone hash of public key of the zone
- * @param loc location in the B-tree
- * @param ploc parent's location in the B-tree (must have depth = loc.depth + 1), NULL for root
- * @param num_entries number of entries at this node in the B-tree
- * @param entries the 'num_entries' entries to store (hashes over the
- * records)
- * @return GNUNET_OK on success
- */
-static int
-namestore_sqlite_put_node (void *cls,
- const GNUNET_HashCode *zone,
- const struct GNUNET_NAMESTORE_SignatureLocation *loc,
- const struct GNUNET_NAMESTORE_SignatureLocation *ploc,
- unsigned int num_entries,
- const GNUNET_HashCode *entries)
-{
- struct Plugin *plugin = cls;
- int n;
-
- if ( (loc->revision != ploc->revision) ||
- (loc->depth + 1 != ploc->depth) ||
- (0 == num_entries))
+ if (data_size > 64 * 65536)
{
GNUNET_break (0);
return GNUNET_SYSERR;
}
- if ((SQLITE_OK != sqlite3_bind_blob (plugin->put_node, 1, zone, sizeof (GNUNET_HashCode), SQLITE_STATIC)) ||
- (SQLITE_OK != sqlite3_bind_int (plugin->put_node, 2, loc->revision)) ||
- (SQLITE_OK != sqlite3_bind_int (plugin->put_node, 3, loc->depth)) ||
- (SQLITE_OK != sqlite3_bind_int64 (plugin->put_node, 4, loc->offset)) ||
- (SQLITE_OK != sqlite3_bind_int64 (plugin->put_node, 5, ploc->offset)) ||
- (SQLITE_OK != sqlite3_bind_blob (plugin->put_node, 6, entries, num_entries * sizeof (GNUNET_HashCode), SQLITE_STATIC)) )
{
- LOG_SQLITE (plugin, GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
- "sqlite3_bind_XXXX");
- if (SQLITE_OK != sqlite3_reset (plugin->put_node))
+ /* 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_reset");
- return GNUNET_SYSERR;
+ 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);
+ }
}
- n = sqlite3_step (plugin->put_node);
- if (SQLITE_OK != sqlite3_reset (plugin->put_node))
- LOG_SQLITE (plugin, GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
- "sqlite3_reset");
switch (n)
{
case SQLITE_DONE:
- GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, "sqlite", "Node stored\n");
+ 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");
+ 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");
+ LOG_SQLITE (plugin,
+ GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
+ "sqlite3_step");
return GNUNET_SYSERR;
}
}
-
-
-/**
- * Iterate over the results for a particular key and zone in the
- * datastore. Will only query the latest revision known for the
- * zone (as adding a new zone revision will cause the plugin to
- * delete all records from previous revisions).
- *
- * @param cls closure (internal context for the plugin)
- * @param zone hash of public key of the zone
- * @param name_hash hash of name, NULL to iterate over all records of the zone
- * @param iter maybe NULL (to just count)
- * @param iter_cls closure for iter
- * @return the number of results found
- */
-static unsigned int
-namestore_sqlite_iterate_records (void *cls,
- const GNUNET_HashCode *zone,
- const GNUNET_HashCode *name_hash,
- GNUNET_NAMESTORE_RecordIterator iter, void *iter_cls)
-{
- struct Plugin *plugin = cls;
- unsigned int ret;
- int sret;
- struct GNUNET_TIME_Absolute expiration;
- uint32_t record_type;
- enum GNUNET_NAMESTORE_RecordFlags flags;
- size_t data_size;
- const void *data;
- struct GNUNET_NAMESTORE_SignatureLocation loc;
- const char *name;
- if ((SQLITE_OK != sqlite3_bind_blob (plugin->iterate_records, 1,
- zone, sizeof (GNUNET_HashCode),
- SQLITE_STATIC)) ||
- (SQLITE_OK != sqlite3_bind_blob (plugin->iterate_records, 2,
- name_hash, sizeof (GNUNET_HashCode),
- SQLITE_STATIC)) )
- {
- LOG_SQLITE (plugin, GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
- "sqlite3_bind_XXXX");
- if (SQLITE_OK != sqlite3_reset (plugin->iterate_records))
- LOG_SQLITE (plugin,
- GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
- "sqlite3_reset");
- return GNUNET_SYSERR;
- }
- ret = 0;
- while (SQLITE_ROW == (sret = sqlite3_step (plugin->iterate_records)))
- {
- ret++;
- if (NULL == iter)
- continue; /* FIXME: just counting can be done more cheaply... */
- loc.revision = sqlite3_column_int (plugin->iterate_records, 0);
- name = (const char*) sqlite3_column_text (plugin->iterate_records, 1);
- record_type = sqlite3_column_int (plugin->iterate_records, 2);
- loc.depth = sqlite3_column_int (plugin->iterate_records, 3);
- loc.offset = sqlite3_column_int64 (plugin->iterate_records, 4);
- expiration.abs_value = (uint64_t) sqlite3_column_int64 (plugin->iterate_records, 5);
- flags = (enum GNUNET_NAMESTORE_RecordFlags) sqlite3_column_int (plugin->iterate_records, 6);
- data = sqlite3_column_blob (plugin->iterate_records, 7);
- data_size = sqlite3_column_bytes (plugin->iterate_records, 7);
- iter (iter_cls, zone,
- &loc, name, record_type,
- expiration, flags, data_size, data);
- }
- if (SQLITE_DONE != sret)
- LOG_SQLITE (plugin, GNUNET_ERROR_TYPE_ERROR, "sqlite_step");
- if (SQLITE_OK != sqlite3_reset (plugin->iterate_records))
- LOG_SQLITE (plugin,
- GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
- "sqlite3_reset");
- return ret;
-}
-
/**
- * Get a particular node from the signature tree.
+ * 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.
*
- * @param cls closure (internal context for the plugin)
- * @param zone hash of public key of the zone
- * @param loc location of the node in the signature tree
- * @param cb function to call with the result
- * @param cb_cls closure for cont
- * @return GNUNET_OK on success, GNUNET_NO if no node was found
+ * @param plugin plugin context
+ * @param stmt to run (and then clean up)
+ * @param zone_key private key of the zone
+ * @param limit maximum number of results to fetch
+ * @param iter iterator to call with the result
+ * @param iter_cls closure for @a iter
+ * @return #GNUNET_OK on success, #GNUNET_NO if there were no results, #GNUNET_SYSERR on error
*/
static int
-namestore_sqlite_get_node (void *cls,
- const GNUNET_HashCode *zone,
- const struct GNUNET_NAMESTORE_SignatureLocation *loc,
- GNUNET_NAMESTORE_NodeCallback cb, void *cb_cls)
+get_records_and_call_iterator (struct Plugin *plugin,
+ sqlite3_stmt *stmt,
+ const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone_key,
+ uint64_t limit,
+ GNUNET_NAMESTORE_RecordIterator iter,
+ void *iter_cls)
{
- struct Plugin *plugin = cls;
int ret;
- size_t hashcodes_size;
- const GNUNET_HashCode *hashcodes;
- struct GNUNET_NAMESTORE_SignatureLocation ploc;
- struct GNUNET_NAMESTORE_SignatureLocation rloc;
+ int sret;
- GNUNET_assert (NULL != cb);
- if ((SQLITE_OK != sqlite3_bind_blob (plugin->get_node, 1, zone, sizeof (GNUNET_HashCode), SQLITE_STATIC)) ||
- (SQLITE_OK != sqlite3_bind_int (plugin->get_node, 2, loc->revision)) ||
- (SQLITE_OK != sqlite3_bind_int (plugin->get_node, 3, loc->depth)) ||
- (SQLITE_OK != sqlite3_bind_int64 (plugin->get_node, 4, loc->offset)) )
+ ret = GNUNET_OK;
+ for (uint64_t i = 0;i<limit;i++)
{
- LOG_SQLITE (plugin, GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
- "sqlite3_bind_XXXX");
- if (SQLITE_OK != sqlite3_reset (plugin->get_node))
- LOG_SQLITE (plugin,
- GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
- "sqlite3_reset");
- return GNUNET_SYSERR;
+ sret = sqlite3_step (stmt);
- }
- rloc.revision = loc->revision;
- rloc.depth = loc->depth;
- ploc.revision = loc->revision;
- ploc.depth = loc->depth + 1;
- ret = GNUNET_NO;
- if (SQLITE_ROW == (ret = sqlite3_step (plugin->get_node)))
- {
- ploc.offset = sqlite3_column_int64 (plugin->get_node, 0);
- rloc.offset = sqlite3_column_int64 (plugin->get_node, 1);
- hashcodes = sqlite3_column_blob (plugin->get_node, 2);
- hashcodes_size = sqlite3_column_bytes (plugin->get_node, 2);
- if (0 != (hashcodes_size % sizeof (GNUNET_HashCode)))
+ if (SQLITE_DONE == sret)
{
- GNUNET_break (0);
- /* FIXME: delete bogus record? */
- }
- else
+ 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;
+ }
+
{
- ret = GNUNET_OK;
- cb (cb_cls,
- zone,
- &rloc,
- &ploc,
- hashcodes_size / sizeof (GNUNET_HashCode),
- hashcodes);
+ uint64_t seq;
+ uint32_t record_count;
+ size_t data_size;
+ void *data;
+ char *label;
+ struct GNUNET_CRYPTO_EcdsaPrivateKey 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
+ };
+
+ if (NULL == zone_key)
+ {
+ zone_key = &zk;
+ ret = GNUNET_SQ_extract_result (stmt,
+ rsx);
+ }
+ else
+ {
+ ret = GNUNET_SQ_extract_result (stmt,
+ 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];
+
+ if (GNUNET_OK !=
+ GNUNET_GNSRECORD_records_deserialize (data_size,
+ data,
+ record_count,
+ rd))
+ {
+ GNUNET_break (0);
+ ret = GNUNET_SYSERR;
+ break;
+ }
+ else
+ {
+ if (NULL != iter)
+ iter (iter_cls,
+ seq + 1,
+ zone_key,
+ label,
+ record_count,
+ rd);
+ }
+ }
+ GNUNET_SQ_cleanup_result (rs);
}
}
- else if (SQLITE_DONE != ret)
- LOG_SQLITE (plugin, GNUNET_ERROR_TYPE_ERROR, "sqlite_step");
- if (SQLITE_OK != sqlite3_reset (plugin->get_node))
- LOG_SQLITE (plugin,
- GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
- "sqlite3_reset");
+ GNUNET_SQ_reset (plugin->dbh,
+ stmt);
return ret;
}
/**
- * Get the current signature for a zone.
+ * Lookup records in the datastore for which we are the authority.
*
* @param cls closure (internal context for the plugin)
- * @param zone hash of public key of the zone
- * @param cb function to call with the result
- * @param cb_cls closure for cont
- * @return GNUNET_OK on success, GNUNET_NO if no node was found
+ * @param zone private key of the zone
+ * @param label name of the record in the zone
+ * @param iter function to call with the result
+ * @param iter_cls closure for @a iter
+ * @return #GNUNET_OK on success, #GNUNET_NO for no results, else #GNUNET_SYSERR
*/
static int
-namestore_sqlite_get_signature (void *cls,
- const GNUNET_HashCode *zone,
- GNUNET_NAMESTORE_SignatureCallback cb, void *cb_cls)
+namestore_sqlite_lookup_records (void *cls,
+ const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone,
+ const char *label,
+ GNUNET_NAMESTORE_RecordIterator iter,
+ void *iter_cls)
{
struct Plugin *plugin = cls;
- int ret;
- int sret;
- const struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *zone_key;
- struct GNUNET_NAMESTORE_SignatureLocation top_loc;
- const struct GNUNET_CRYPTO_RsaSignature *zone_sig;
- struct GNUNET_TIME_Absolute zone_time;
- const GNUNET_HashCode *top_hash;
+ struct GNUNET_SQ_QueryParam params[] = {
+ GNUNET_SQ_query_param_auto_from_type (zone),
+ GNUNET_SQ_query_param_string (label),
+ GNUNET_SQ_query_param_end
+ };
- GNUNET_assert (NULL != cb);
- if (SQLITE_OK != sqlite3_bind_blob (plugin->get_signature, 1, zone, sizeof (GNUNET_HashCode), SQLITE_STATIC))
+ if (NULL == zone)
{
- LOG_SQLITE (plugin, GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
- "sqlite3_bind_XXXX");
- if (SQLITE_OK != sqlite3_reset (plugin->get_signature))
- LOG_SQLITE (plugin,
- GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
- "sqlite3_reset");
+ GNUNET_break (0);
return GNUNET_SYSERR;
}
- ret = GNUNET_NO;
- if (SQLITE_ROW == (sret = sqlite3_step (plugin->get_signature)))
+ if (GNUNET_OK !=
+ GNUNET_SQ_bind (plugin->lookup_label,
+ params))
{
- top_loc.offset = 0;
- top_loc.revision = sqlite3_column_int (plugin->get_signature, 0);
- zone_time.abs_value = sqlite3_column_int64 (plugin->get_signature, 1);
- top_hash = sqlite3_column_blob (plugin->get_signature, 2);
- top_loc.depth = sqlite3_column_int (plugin->get_signature, 3);
- zone_key = sqlite3_column_blob (plugin->get_signature, 4);
- zone_sig = sqlite3_column_blob (plugin->get_signature, 5);
-
- if ((sizeof (GNUNET_HashCode) != sqlite3_column_bytes (plugin->get_signature, 2)) ||
- (sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded) != sqlite3_column_bytes (plugin->get_signature, 4)) ||
- (sizeof (struct GNUNET_CRYPTO_RsaSignature) != sqlite3_column_bytes (plugin->get_signature, 5)))
- {
- GNUNET_break (0);
- /* FIXME: delete bogus record & full zone (!?) */
- }
- else
- {
- ret = GNUNET_OK;
- cb (cb_cls,
- zone_key,
- &top_loc,
- zone_sig,
- zone_time,
- top_hash);
- }
+ 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;
}
- else if (SQLITE_DONE != sret)
- LOG_SQLITE (plugin, GNUNET_ERROR_TYPE_ERROR, "sqlite_step");
- if (SQLITE_OK != sqlite3_reset (plugin->get_signature))
- LOG_SQLITE (plugin,
- GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
- "sqlite3_reset");
- return ret;
+ return get_records_and_call_iterator (plugin,
+ plugin->lookup_label,
+ zone,
+ 1,
+ iter,
+ iter_cls);
}
/**
- * Run a SQL statement that takes only a 'zone' as the argument
- * and returns nothing (deletes records).
+ * Iterate over the results for a particular key and zone in the
+ * datastore. Will return at most one result to the iterator.
*
- * @param plugin our plugin
- * @param zone zone argument to pass
- * @param stmt prepared statement to run
+ * @param cls closure (internal context for the plugin)
+ * @param zone hash of public key of the zone, NULL to iterate over all zones
+ * @param serial serial number to exclude in the list of all matching records
+ * @param limit maximum number of results to return
+ * @param iter function to call with the result
+ * @param iter_cls closure for @a iter
+ * @return #GNUNET_OK on success, #GNUNET_NO if there were no more results, #GNUNET_SYSERR on error
*/
-static void
-run_delete_statement (struct Plugin *plugin,
- const GNUNET_HashCode *zone,
- sqlite3_stmt *stmt)
+static int
+namestore_sqlite_iterate_records (void *cls,
+ const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone,
+ uint64_t serial,
+ uint64_t limit,
+ GNUNET_NAMESTORE_RecordIterator iter,
+ void *iter_cls)
{
- int n;
+ struct Plugin *plugin = cls;
+ sqlite3_stmt *stmt;
+ int err;
- if (SQLITE_OK != sqlite3_bind_blob (stmt, 1, zone, sizeof (GNUNET_HashCode), SQLITE_STATIC))
+ if (NULL == zone)
{
- LOG_SQLITE (plugin, GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
- "sqlite3_bind_XXXX");
- if (SQLITE_OK != sqlite3_reset (stmt))
- LOG_SQLITE (plugin,
- GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
- "sqlite3_reset");
- return;
+ 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);
}
- n = sqlite3_step (stmt);
- if (SQLITE_OK != sqlite3_reset (stmt))
- LOG_SQLITE (plugin, GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
- "sqlite3_reset");
- switch (n)
+ else
{
- case SQLITE_DONE:
- GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, "sqlite", "Values deleted\n");
- break;
- case SQLITE_BUSY:
- LOG_SQLITE (plugin, GNUNET_ERROR_TYPE_WARNING | GNUNET_ERROR_TYPE_BULK,
- "sqlite3_step");
- break;
- default:
- LOG_SQLITE (plugin, GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
- "sqlite3_step");
- break;
+ 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);
}
/**
- * Delete an entire zone (all revisions, all records, all nodes,
- * all signatures). Not used in normal operation.
+ * Look for an existing PKEY delegation record for a given public key.
+ * Returns at most one result to the iterator.
*
* @param cls closure (internal context for the plugin)
- * @param zone zone to delete
- */
-static void
-namestore_sqlite_delete_zone (void *cls,
- const GNUNET_HashCode *zone)
-{
- struct Plugin *plugin = cls;
-
- run_delete_statement (plugin, zone, plugin->delete_zone_records);
- run_delete_statement (plugin, zone, plugin->delete_zone_nodes);
- run_delete_statement (plugin, zone, plugin->delete_zone_signatures);
-}
-
-
-/**
- * Context for 'delete_old_zone_information'.
- */
-struct DeleteContext
-{
- /**
- * Plugin handle.
- */
- struct Plugin *plugin;
-
- /**
- * Hash of the public key of the zone (to avoid having to
- * recalculate it).
- */
- const GNUNET_HashCode *zone;
-
- /**
- * Revision to compare against.
- */
- uint32_t revision;
-
-};
-
-
-/**
- * Function called on the current signature in the database for
- * a zone. If the revision given in the closure is more recent,
- * delete all information about the zone. Otherwise, only delete
- * the signature.
- *
- * @param cls a 'struct DeleteContext' with a revision to compare against
- * @param zone_key public key of the zone
- * @param loc location of the root in the B-tree (depth, revision)
- * @param top_sig signature signing the zone
- * @param zone_time time the signature was created
- * @param root_hash top level hash that is being signed
- */
-static void
-delete_old_zone_information (void *cls,
- const struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *zone_key,
- const struct GNUNET_NAMESTORE_SignatureLocation *loc,
- const struct GNUNET_CRYPTO_RsaSignature *top_sig,
- struct GNUNET_TIME_Absolute zone_time,
- const GNUNET_HashCode *root_hash)
-{
- struct DeleteContext *dc = cls;
-
- run_delete_statement (dc->plugin, dc->zone, dc->plugin->delete_zone_signatures);
- if (loc->revision == dc->revision)
- return;
- run_delete_statement (dc->plugin, dc->zone, dc->plugin->delete_zone_records);
- run_delete_statement (dc->plugin, dc->zone, dc->plugin->delete_zone_nodes);
-}
-
-
-/**
- * Store a zone signature in the datastore. If a signature for the zone with a
- * lower depth exists, the old signature is removed. If a signature for an
- * older revision of the zone exists, this will delete all records, nodes
- * and signatures for the older revision of the zone.
- *
- * @param cls closure (internal context for the plugin)
- * @param zone_key public key of the zone
- * @param loc location in the B-tree (top of the tree, offset 0, depth at 'maximum')
- * @param top_sig signature at the top, NULL if 'loc.depth > 0'
- * @param root_hash top level hash that is signed
- * @param zone_time time the zone was signed
- * @return GNUNET_OK on success
+ * @param zone private key of the zone to look up in, never NULL
+ * @param value_zone public key of the target zone (value), never NULL
+ * @param iter function to call with the result
+ * @param iter_cls closure for @a iter
+ * @return #GNUNET_OK on success, #GNUNET_NO if there were no results, #GNUNET_SYSERR on error
*/
static int
-namestore_sqlite_put_signature (void *cls,
- const struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *zone_key,
- const struct GNUNET_NAMESTORE_SignatureLocation *loc,
- const struct GNUNET_CRYPTO_RsaSignature *top_sig,
- const GNUNET_HashCode *root_hash,
- struct GNUNET_TIME_Absolute zone_time)
+namestore_sqlite_zone_to_name (void *cls,
+ const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone,
+ const struct GNUNET_CRYPTO_EcdsaPublicKey *value_zone,
+ GNUNET_NAMESTORE_RecordIterator iter,
+ void *iter_cls)
{
struct Plugin *plugin = cls;
- int n;
- GNUNET_HashCode zone;
- struct DeleteContext dc;
+ 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
+ };
- GNUNET_break (0 == loc->offset); /* little sanity check */
- GNUNET_CRYPTO_hash (zone_key,
- sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded),
- &zone);
- /* get "old" signature, if older revision, delete all existing
- records/nodes for the zone, if same revision, delete only the signature */
- dc.plugin = plugin;
- dc.zone = &zone;
- dc.revision = loc->revision;
- (void) namestore_sqlite_get_signature (plugin,
- &zone,
- &delete_old_zone_information,
- &dc);
- if ((SQLITE_OK != sqlite3_bind_blob (plugin->put_signature, 1, &zone, sizeof (GNUNET_HashCode), SQLITE_STATIC)) ||
- (SQLITE_OK != sqlite3_bind_int (plugin->put_signature, 2, loc->revision)) ||
- (SQLITE_OK != sqlite3_bind_int64 (plugin->put_signature, 3, zone_time.abs_value)) ||
- (SQLITE_OK != sqlite3_bind_blob (plugin->put_signature, 4, root_hash, sizeof (GNUNET_HashCode), SQLITE_STATIC)) ||
- (SQLITE_OK != sqlite3_bind_int (plugin->put_signature, 5, loc->depth)) ||
- (SQLITE_OK != sqlite3_bind_blob (plugin->put_signature, 6, zone_key, sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded), SQLITE_STATIC))||
- (SQLITE_OK != sqlite3_bind_blob (plugin->put_signature, 7, top_sig, sizeof (struct GNUNET_CRYPTO_RsaSignature), SQLITE_STATIC)) )
- {
- LOG_SQLITE (plugin, GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
- "sqlite3_bind_XXXX");
- if (SQLITE_OK != sqlite3_reset (plugin->put_signature))
- LOG_SQLITE (plugin,
- GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
- "sqlite3_reset");
- return GNUNET_SYSERR;
- }
- n = sqlite3_step (plugin->put_signature);
- if (SQLITE_OK != sqlite3_reset (plugin->put_signature))
- LOG_SQLITE (plugin, GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
- "sqlite3_reset");
- switch (n)
+ if (GNUNET_OK !=
+ GNUNET_SQ_bind (plugin->zone_to_name,
+ params))
{
- case SQLITE_DONE:
- GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, "sqlite", "Signature stored\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");
+ 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);
}
* Entry point for the plugin.
*
* @param cls the "struct GNUNET_NAMESTORE_PluginEnvironment*"
- * @return NULL on error, othrewise the plugin context
+ * @return NULL on error, otherwise the plugin context
*/
void *
libgnunet_plugin_namestore_sqlite_init (void *cls)
if (NULL != plugin.cfg)
return NULL; /* can only initialize once! */
- memset (&plugin, 0, sizeof (struct Plugin));
- plugin.cfg = cfg;
+ memset (&plugin,
+ 0,
+ sizeof (struct Plugin));
+ plugin.cfg = cfg;
if (GNUNET_OK != database_setup (&plugin))
{
database_shutdown (&plugin);
return NULL;
}
- api = GNUNET_malloc (sizeof (struct GNUNET_NAMESTORE_PluginFunctions));
+ api = GNUNET_new (struct GNUNET_NAMESTORE_PluginFunctions);
api->cls = &plugin;
- api->put_record = &namestore_sqlite_put_record;
- api->put_node = &namestore_sqlite_put_node;
- api->put_signature = &namestore_sqlite_put_signature;
+ api->store_records = &namestore_sqlite_store_records;
api->iterate_records = &namestore_sqlite_iterate_records;
- api->get_node = &namestore_sqlite_get_node;
- api->get_signature = &namestore_sqlite_get_signature;
- api->delete_zone = &namestore_sqlite_delete_zone;
- LOG (GNUNET_ERROR_TYPE_INFO,
+ api->zone_to_name = &namestore_sqlite_zone_to_name;
+ api->lookup_records = &namestore_sqlite_lookup_records;
+ LOG (GNUNET_ERROR_TYPE_INFO,
_("Sqlite database running\n"));
return api;
}
struct GNUNET_NAMESTORE_PluginFunctions *api = cls;
struct Plugin *plugin = api->cls;
- LOG (GNUNET_ERROR_TYPE_DEBUG,
- "sqlite plugin is done\n");
database_shutdown (plugin);
plugin->cfg = NULL;
GNUNET_free (api);
- LOG (GNUNET_ERROR_TYPE_DEBUG,
+ LOG (GNUNET_ERROR_TYPE_DEBUG,
"sqlite plugin is finished\n");
return NULL;
}
projects / oweals / gnunet.git / blobdiff