#include "platform.h"
#include "gnunet_namestore_plugin.h"
+#include "gnunet_namestore_service.h"
+#include "namestore.h"
#include <sqlite3.h>
/**
sqlite3_stmt *iterate_records;
/**
- * Precompiled SQL for delete zone
+ * Precompiled SQL to get the name for a given zone-value.
*/
- sqlite3_stmt *delete_zone;
-
-};
-
-
-/**
- * Internal format of a record in the BLOB in the database.
- */
-struct DbRecord
-{
+ sqlite3_stmt *zone_to_name;
/**
- * Expiration time for the DNS record.
- */
- struct GNUNET_TIME_AbsoluteNBO expiration;
-
- /**
- * Number of bytes in 'data', network byte order.
- */
- uint32_t data_size;
-
- /**
- * Type of the GNS/DNS record, network byte order.
+ * Precompiled SQL for delete zone
*/
- uint32_t record_type;
+ sqlite3_stmt *delete_zone;
- /**
- * Flags for the record, network byte order.
- */
- uint32_t flags;
-
};
{
/* create indices */
if ( (SQLITE_OK !=
- sqlite3_exec (dbh, "CREATE INDEX IF NOT EXISTS ir_zone_name_rv ON ns090records (zone_hash,record_name_hash,rvalue)",
+ sqlite3_exec (dbh, "CREATE INDEX IF NOT EXISTS ir_zone_name_rv ON ns091records (zone_hash,record_name_hash,rvalue)",
+ NULL, NULL, NULL)) ||
+ (SQLITE_OK !=
+ sqlite3_exec (dbh, "CREATE INDEX IF NOT EXISTS ir_zone_delegation ON ns091records (zone_hash,zone_delegation)",
NULL, NULL, NULL)) ||
(SQLITE_OK !=
- sqlite3_exec (dbh, "CREATE INDEX IF NOT EXISTS ir_zone_rv ON ns090records (zone_hash,rvalue)",
+ sqlite3_exec (dbh, "CREATE INDEX IF NOT EXISTS ir_zone_rv ON ns091records (zone_hash,rvalue)",
NULL, NULL, NULL)) ||
(SQLITE_OK !=
- sqlite3_exec (dbh, "CREATE INDEX IF NOT EXISTS ir_zone ON ns090records (zone_hash)",
+ sqlite3_exec (dbh, "CREATE INDEX IF NOT EXISTS ir_zone ON ns091records (zone_hash)",
NULL, NULL, NULL)) ||
(SQLITE_OK !=
- sqlite3_exec (dbh, "CREATE INDEX IF NOT EXISTS ir_name_rv ON ns090records (record_name_hash,rvalue)",
+ sqlite3_exec (dbh, "CREATE INDEX IF NOT EXISTS ir_name_rv ON ns091records (record_name_hash,rvalue)",
NULL, NULL, NULL)) ||
(SQLITE_OK !=
- sqlite3_exec (dbh, "CREATE INDEX IF NOT EXISTS ir_rv ON ns090records (rvalue)",
+ sqlite3_exec (dbh, "CREATE INDEX IF NOT EXISTS ir_rv ON ns091records (rvalue)",
NULL, NULL, NULL)) )
LOG (GNUNET_ERROR_TYPE_ERROR,
"Failed to create indices: %s\n", sqlite3_errmsg (dbh));
/* Create tables */
CHECK (SQLITE_OK ==
sq_prepare (plugin->dbh,
- "SELECT 1 FROM sqlite_master WHERE tbl_name = 'ns090records'",
+ "SELECT 1 FROM sqlite_master WHERE tbl_name = 'ns091records'",
&stmt));
if ((sqlite3_step (stmt) == SQLITE_DONE) &&
(sqlite3_exec
(plugin->dbh,
- "CREATE TABLE ns090records ("
+ "CREATE TABLE ns091records ("
" zone_key BLOB NOT NULL DEFAULT '',"
+ " zone_delegation BLOB NOT NULL DEFAULT '',"
" zone_hash BLOB NOT NULL DEFAULT '',"
" record_count INT NOT NULL DEFAULT 0,"
" record_data BLOB NOT NULL DEFAULT '',"
#define ALL "zone_key, record_name, record_count, record_data, block_expiration_time, signature"
if ((sq_prepare
(plugin->dbh,
- "INSERT INTO ns090records (" ALL ", zone_hash, record_name_hash, rvalue) VALUES "
- "(?, ?, ?, ?, ?, ?, ?, ?, ?)",
+ "INSERT INTO ns091records (" ALL ", zone_delegation, zone_hash, record_name_hash, rvalue) VALUES "
+ "(?, ?, ?, ?, ?, ?, ?, ?, ?, ?)",
&plugin->put_records) != SQLITE_OK) ||
(sq_prepare
(plugin->dbh,
- "DELETE FROM ns090records WHERE zone_hash=? AND record_name_hash=?",
+ "DELETE FROM ns091records WHERE zone_hash=? AND record_name_hash=?",
&plugin->remove_records) != SQLITE_OK) ||
(sq_prepare
(plugin->dbh,
"SELECT " ALL
- " FROM ns090records WHERE zone_hash=? AND record_name_hash=? ORDER BY rvalue LIMIT 1 OFFSET ?",
+ " FROM ns091records WHERE zone_hash=? AND record_name_hash=? ORDER BY rvalue LIMIT 1 OFFSET ?",
&plugin->iterate_records) != SQLITE_OK) ||
(sq_prepare
(plugin->dbh,
"SELECT " ALL
- " FROM ns090records WHERE zone_hash=? ORDER BY rvalue LIMIT 1 OFFSET ?",
+ " FROM ns091records WHERE zone_hash=? ORDER BY rvalue LIMIT 1 OFFSET ?",
&plugin->iterate_by_zone) != SQLITE_OK) ||
(sq_prepare
(plugin->dbh,
"SELECT " ALL
- " FROM ns090records WHERE record_name_hash=? ORDER BY rvalue LIMIT 1 OFFSET ?",
+ " FROM ns091records WHERE record_name_hash=? ORDER BY rvalue LIMIT 1 OFFSET ?",
&plugin->iterate_by_name) != SQLITE_OK) ||
(sq_prepare
(plugin->dbh,
"SELECT " ALL
- " FROM ns090records ORDER BY rvalue LIMIT 1 OFFSET ?",
+ " FROM ns091records ORDER BY rvalue LIMIT 1 OFFSET ?",
&plugin->iterate_all) != SQLITE_OK) ||
+ (sq_prepare
+ (plugin->dbh,
+ "SELECT " ALL
+ " FROM ns091records WHERE zone_hash=? AND zone_delegation=?",
+ &plugin->zone_to_name) != SQLITE_OK) ||
(sq_prepare
(plugin->dbh,
- "DELETE FROM ns090records WHERE zone_hash=?",
+ "DELETE FROM ns091records WHERE zone_hash=?",
&plugin->delete_zone) != SQLITE_OK) )
{
LOG_SQLITE (plugin,GNUNET_ERROR_TYPE_ERROR, "precompiling");
sqlite3_finalize (plugin->remove_records);
if (NULL != plugin->iterate_records)
sqlite3_finalize (plugin->iterate_records);
- if (NULL != plugin->iterate_records)
+ if (NULL != plugin->iterate_by_zone)
sqlite3_finalize (plugin->iterate_by_zone);
- if (NULL != plugin->iterate_records)
+ if (NULL != plugin->iterate_by_name)
sqlite3_finalize (plugin->iterate_by_name);
- if (NULL != plugin->iterate_records)
+ if (NULL != plugin->iterate_all)
sqlite3_finalize (plugin->iterate_all);
+ if (NULL != plugin->zone_to_name)
+ sqlite3_finalize (plugin->zone_to_name);
if (NULL != plugin->delete_zone)
sqlite3_finalize (plugin->delete_zone);
result = sqlite3_close (plugin->dbh);
*/
static int
namestore_sqlite_remove_records (void *cls,
- const GNUNET_HashCode *zone,
+ const struct GNUNET_CRYPTO_ShortHashCode *zone,
const char *name)
{
struct Plugin *plugin = cls;
- GNUNET_HashCode nh;
+ struct GNUNET_CRYPTO_ShortHashCode nh;
size_t name_len;
int n;
-
name_len = strlen (name);
- GNUNET_CRYPTO_hash (name, name_len, &nh);
+ GNUNET_CRYPTO_short_hash (name, name_len, &nh);
- if ((SQLITE_OK != sqlite3_bind_blob (plugin->remove_records, 1, zone, sizeof (GNUNET_HashCode), SQLITE_STATIC)) ||
- (SQLITE_OK != sqlite3_bind_blob (plugin->remove_records, 2, &nh, sizeof (GNUNET_HashCode), SQLITE_STATIC)))
+ if ((SQLITE_OK != sqlite3_bind_blob (plugin->remove_records, 1, zone, sizeof (struct GNUNET_CRYPTO_ShortHashCode), SQLITE_STATIC)) ||
+ (SQLITE_OK != sqlite3_bind_blob (plugin->remove_records, 2, &nh, sizeof (struct GNUNET_CRYPTO_ShortHashCode), SQLITE_STATIC)))
{
LOG_SQLITE (plugin, GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
"sqlite3_bind_XXXX");
* @param rd array of records with data to store
* @param signature signature of the record block, NULL if signature is unavailable (i.e.
* because the user queried for a particular record type only)
- * @return GNUNET_OK on success
+ * @return GNUNET_OK on success, else GNUNET_SYSERR
*/
static int
namestore_sqlite_put_records (void *cls,
{
struct Plugin *plugin = cls;
int n;
- GNUNET_HashCode zone;
- GNUNET_HashCode nh;
+ struct GNUNET_CRYPTO_ShortHashCode zone;
+ struct GNUNET_CRYPTO_ShortHashCode zone_delegation;
+ struct GNUNET_CRYPTO_ShortHashCode nh;
size_t name_len;
uint64_t rvalue;
size_t data_size;
- size_t off;
unsigned int i;
- GNUNET_CRYPTO_hash (zone_key, sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded), &zone);
+ GNUNET_CRYPTO_short_hash (zone_key, sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded), &zone);
(void) namestore_sqlite_remove_records (plugin, &zone, name);
name_len = strlen (name);
- GNUNET_CRYPTO_hash (name, name_len, &nh);
+ GNUNET_CRYPTO_short_hash (name, name_len, &nh);
+ memset (&zone_delegation, 0, sizeof (zone_delegation));
+ for (i=0;i<rd_count;i++)
+ if (rd[i].record_type == GNUNET_NAMESTORE_TYPE_PKEY)
+ {
+ GNUNET_assert (sizeof (struct GNUNET_CRYPTO_ShortHashCode) == rd[i].data_size);
+ memcpy (&zone_delegation,
+ rd[i].data,
+ sizeof (struct GNUNET_CRYPTO_ShortHashCode));
+ break;
+ }
rvalue = GNUNET_CRYPTO_random_u64 (GNUNET_CRYPTO_QUALITY_WEAK, UINT64_MAX);
- data_size = rd_count * sizeof (struct DbRecord);
- for (i=0;i<rd_count;i++)
- data_size += rd[i].data_size;
+ data_size = GNUNET_NAMESTORE_records_get_size (rd_count, rd);
if (data_size > 64 * 65536)
{
GNUNET_break (0);
}
{
char data[data_size];
- struct DbRecord *rec;
-
- rec = (struct DbRecord *) data;
- off = rd_count * sizeof (struct DbRecord);
- for (i=0;i<rd_count;i++)
+
+ if (data_size != GNUNET_NAMESTORE_records_serialize (rd_count, rd,
+ data_size, data))
{
- rec[i].expiration = GNUNET_TIME_absolute_hton (rd[i].expiration);
- rec[i].data_size = htonl ((uint32_t) rd[i].data_size);
- rec[i].record_type = htonl (rd[i].record_type);
- rec[i].flags = htonl (rd[i].flags);
- memcpy (&data[off],
- rd[i].data,
- rd[i].data_size);
- off += rd[i].data_size;
+ GNUNET_break (0);
+ return GNUNET_SYSERR;
}
if ((SQLITE_OK != sqlite3_bind_blob (plugin->put_records, 1, zone_key, sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded), SQLITE_STATIC)) ||
(SQLITE_OK != sqlite3_bind_text (plugin->put_records, 2, name, -1, SQLITE_STATIC)) ||
(SQLITE_OK != sqlite3_bind_blob (plugin->put_records, 4, data, data_size, SQLITE_STATIC)) ||
(SQLITE_OK != sqlite3_bind_int64 (plugin->put_records, 5, expire.abs_value)) ||
(SQLITE_OK != sqlite3_bind_blob (plugin->put_records, 6, signature, sizeof (struct GNUNET_CRYPTO_RsaSignature), SQLITE_STATIC)) ||
- (SQLITE_OK != sqlite3_bind_blob (plugin->put_records, 7, &zone, sizeof (GNUNET_HashCode), SQLITE_STATIC)) ||
- (SQLITE_OK != sqlite3_bind_blob (plugin->put_records, 8, &nh, sizeof (GNUNET_HashCode), SQLITE_STATIC)) ||
- (SQLITE_OK != sqlite3_bind_int64 (plugin->put_records, 9, rvalue)) )
+ (SQLITE_OK != sqlite3_bind_blob (plugin->put_records, 7, &zone_delegation, sizeof (struct GNUNET_CRYPTO_ShortHashCode), SQLITE_STATIC)) ||
+ (SQLITE_OK != sqlite3_bind_blob (plugin->put_records, 8, &zone, sizeof (struct GNUNET_CRYPTO_ShortHashCode), SQLITE_STATIC)) ||
+ (SQLITE_OK != sqlite3_bind_blob (plugin->put_records, 9, &nh, sizeof (struct GNUNET_CRYPTO_ShortHashCode), SQLITE_STATIC)) ||
+ (SQLITE_OK != sqlite3_bind_int64 (plugin->put_records, 10, rvalue)) )
{
LOG_SQLITE (plugin,
GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
return GNUNET_SYSERR;
}
}
+
+
+/**
+ * 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 plugin plugin context
+ * @param stmt to run (and then clean up)
+ * @param iter iterator to call with the result
+ * @param iter_cls closure for 'iter'
+ * @return GNUNET_OK on success, GNUNET_NO if there were no results, GNUNET_SYSERR on error
+ */
+static int
+get_record_and_call_iterator (struct Plugin *plugin,
+ sqlite3_stmt *stmt,
+ GNUNET_NAMESTORE_RecordIterator iter, void *iter_cls)
+{
+ int ret;
+ int sret;
+ unsigned int record_count;
+ size_t data_size;
+ const struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *zone_key;
+ const struct GNUNET_CRYPTO_RsaSignature *sig;
+ struct GNUNET_TIME_Absolute expiration;
+ const char *data;
+ const char *name;
+
+ ret = GNUNET_NO;
+ if (SQLITE_ROW == (sret = sqlite3_step (stmt)))
+ {
+ ret = GNUNET_YES;
+ zone_key = sqlite3_column_blob (stmt, 0);
+ name = (const char*) sqlite3_column_text (stmt, 1);
+ record_count = sqlite3_column_int (stmt, 2);
+ data_size = sqlite3_column_bytes (stmt, 3);
+ data = sqlite3_column_blob (stmt, 3);
+ expiration.abs_value = (uint64_t) sqlite3_column_int64 (stmt, 4);
+ sig = sqlite3_column_blob (stmt, 5);
+
+ if ( (sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded) != sqlite3_column_bytes (stmt, 0)) ||
+ (sizeof (struct GNUNET_CRYPTO_RsaSignature) != sqlite3_column_bytes (stmt, 5)) )
+ {
+ GNUNET_break (0);
+ ret = GNUNET_SYSERR;
+ }
+ else if (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;
+ }
+ else
+ {
+ struct GNUNET_NAMESTORE_RecordData rd[record_count];
+
+ if (GNUNET_OK !=
+ GNUNET_NAMESTORE_records_deserialize (data_size, data,
+ record_count, rd))
+ {
+ GNUNET_break (0);
+ ret = GNUNET_SYSERR;
+ }
+ else
+ {
+ iter (iter_cls, zone_key, expiration, name,
+ record_count, rd, sig);
+ }
+ }
+ }
+ else
+ {
+ if (SQLITE_DONE != sret)
+ LOG_SQLITE (plugin, GNUNET_ERROR_TYPE_ERROR, "sqlite_step");
+ iter (iter_cls, NULL, GNUNET_TIME_UNIT_ZERO_ABS, NULL, 0, NULL, NULL);
+ }
+ if (SQLITE_OK != sqlite3_reset (stmt))
+ LOG_SQLITE (plugin,
+ GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
+ "sqlite3_reset");
+ return ret;
+}
/**
*
* @param cls closure (internal context for the plugin)
* @param zone hash of public key of the zone, NULL to iterate over all zones
- * @param name_hash hash of name, NULL to iterate over all records of the zone
+ * @param name name as string, NULL to iterate over all records of the zone
* @param offset offset in the list of all matching records
* @param iter function to call with the result
* @param iter_cls closure for iter
*/
static int
namestore_sqlite_iterate_records (void *cls,
- const GNUNET_HashCode *zone,
- const GNUNET_HashCode *name_hash,
+ const struct GNUNET_CRYPTO_ShortHashCode *zone,
+ const char *name,
uint64_t offset,
GNUNET_NAMESTORE_RecordIterator iter, void *iter_cls)
{
struct Plugin *plugin = cls;
sqlite3_stmt *stmt;
+ struct GNUNET_CRYPTO_ShortHashCode name_hase;
unsigned int boff;
- int ret;
- int sret;
if (NULL == zone)
- if (NULL == name_hash)
+ if (NULL == name)
stmt = plugin->iterate_all;
else
+ {
+ GNUNET_CRYPTO_short_hash (name, strlen(name), &name_hase);
stmt = plugin->iterate_by_name;
+ }
else
- if (NULL == name_hash)
+ if (NULL == name)
stmt = plugin->iterate_by_zone;
else
+ {
+ GNUNET_CRYPTO_short_hash (name, strlen(name), &name_hase);
stmt = plugin->iterate_records;
+ }
boff = 0;
if ( (NULL != zone) &&
(SQLITE_OK != sqlite3_bind_blob (stmt, ++boff,
- zone, sizeof (GNUNET_HashCode),
+ zone, sizeof (struct GNUNET_CRYPTO_ShortHashCode),
SQLITE_STATIC)) )
{
LOG_SQLITE (plugin, GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
"sqlite3_reset");
return GNUNET_SYSERR;
}
- if ( (NULL != name_hash) &&
+ if ( (NULL != name) &&
(SQLITE_OK != sqlite3_bind_blob (stmt, ++boff,
- name_hash, sizeof (GNUNET_HashCode),
+ &name_hase, sizeof (struct GNUNET_CRYPTO_ShortHashCode),
SQLITE_STATIC)) )
{
+ GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "ITERATE NAME HASH: `%8s'", GNUNET_short_h2s(&name_hase));
LOG_SQLITE (plugin, GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
"sqlite3_bind_XXXX");
if (SQLITE_OK != sqlite3_reset (stmt))
"sqlite3_reset");
return GNUNET_SYSERR;
}
- ret = GNUNET_NO;
- if (SQLITE_ROW == (sret = sqlite3_step (stmt)))
- {
- unsigned int record_count;
- size_t data_size;
- const struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *zone_key;
- const struct GNUNET_CRYPTO_RsaSignature *sig;
- struct GNUNET_TIME_Absolute expiration;
- const char *data;
- const char *name;
-
- ret = GNUNET_YES;
- zone_key = sqlite3_column_blob (stmt, 0);
- name = (const char*) sqlite3_column_text (stmt, 1);
- record_count = sqlite3_column_int (stmt, 2);
- data_size = sqlite3_column_bytes (stmt, 3);
- data = sqlite3_column_blob (stmt, 3);
- expiration.abs_value = (uint64_t) sqlite3_column_int64 (stmt, 4);
- sig = sqlite3_column_blob (stmt, 5);
- if ( (sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded) != sqlite3_column_bytes (stmt, 0)) ||
- (sizeof (struct GNUNET_CRYPTO_RsaSignature) != sqlite3_column_bytes (stmt, 5)) ||
- (sizeof (struct DbRecord) * record_count > data_size) )
- {
- GNUNET_break (0);
- ret = GNUNET_SYSERR;
- }
- else
- {
- const struct DbRecord *db = (const struct DbRecord*) data;
- struct GNUNET_NAMESTORE_RecordData rd[record_count];
- unsigned int i;
- size_t off;
+ return get_record_and_call_iterator (plugin, stmt, iter, iter_cls);
+}
- off = record_count * sizeof (struct DbRecord);
- for (i=0;i<record_count;i++)
- {
- if (off + ntohl (db[i].data_size) > data_size)
- {
- GNUNET_break (0);
- ret = GNUNET_SYSERR;
- record_count = i;
- break;
- }
- rd[i].expiration = GNUNET_TIME_absolute_ntoh (db[i].expiration);
- rd[i].data_size = ntohl (db[i].data_size);
- rd[i].data = &data[off];
- rd[i].record_type = ntohl (db[i].record_type);
- rd[i].flags = ntohl (db[i].flags);
- off += rd[i].data_size;
- }
- iter (iter_cls, zone_key, expiration, name,
- record_count, rd, sig);
- }
- }
- else
+
+/**
+ * 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 hash of public key of the zone to look up in, never NULL
+ * @param value_zone hash of the public key of the target zone (value), never NULL
+ * @param iter function to call with the result
+ * @param iter_cls closure for iter
+ * @return GNUNET_OK on success, GNUNET_NO if there were no results, GNUNET_SYSERR on error
+ */
+static int
+namestore_sqlite_zone_to_name (void *cls,
+ const struct GNUNET_CRYPTO_ShortHashCode *zone,
+ const struct GNUNET_CRYPTO_ShortHashCode *value_zone,
+ GNUNET_NAMESTORE_RecordIterator iter, void *iter_cls)
+{
+ struct Plugin *plugin = cls;
+ sqlite3_stmt *stmt;
+
+ stmt = plugin->zone_to_name;
+ if ( (SQLITE_OK != sqlite3_bind_blob (stmt, 1,
+ zone, sizeof (struct GNUNET_CRYPTO_ShortHashCode),
+ SQLITE_STATIC)) ||
+ (SQLITE_OK != sqlite3_bind_blob (stmt, 2,
+ value_zone, sizeof (struct GNUNET_CRYPTO_ShortHashCode),
+ SQLITE_STATIC)) )
{
- if (SQLITE_DONE != sret)
- LOG_SQLITE (plugin, GNUNET_ERROR_TYPE_ERROR, "sqlite_step");
- iter (iter_cls, NULL, GNUNET_TIME_UNIT_ZERO_ABS, NULL, 0, NULL, NULL);
- }
- if (SQLITE_OK != sqlite3_reset (stmt))
- LOG_SQLITE (plugin,
- GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
- "sqlite3_reset");
- return ret;
+ 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 GNUNET_SYSERR;
+ }
+
+ return get_record_and_call_iterator (plugin, stmt, iter, iter_cls);
}
*/
static void
namestore_sqlite_delete_zone (void *cls,
- const GNUNET_HashCode *zone)
+ const struct GNUNET_CRYPTO_ShortHashCode *zone)
{
struct Plugin *plugin = cls;
sqlite3_stmt *stmt = plugin->delete_zone;
int n;
- if (SQLITE_OK != sqlite3_bind_blob (stmt, 1, zone, sizeof (GNUNET_HashCode), SQLITE_STATIC))
+ if (SQLITE_OK != sqlite3_bind_blob (stmt, 1, zone, sizeof (struct GNUNET_CRYPTO_ShortHashCode), SQLITE_STATIC))
{
LOG_SQLITE (plugin, GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
"sqlite3_bind_XXXX");
api->put_records = &namestore_sqlite_put_records;
api->remove_records = &namestore_sqlite_remove_records;
api->iterate_records = &namestore_sqlite_iterate_records;
+ api->zone_to_name = &namestore_sqlite_zone_to_name;
api->delete_zone = &namestore_sqlite_delete_zone;
LOG (GNUNET_ERROR_TYPE_INFO,
_("Sqlite database running\n"));
projects / oweals / gnunet.git / blobdiff