/*
* 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
*
* 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.
+ * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
*/
/**
#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
+ * Precompiled SQL to store records.
*/
- sqlite3_stmt *put_records;
+ sqlite3_stmt *store_records;
/**
- * Precompiled SQL for remove record
+ * Precompiled SQL to deltete existing records.
*/
- sqlite3_stmt *remove_records;
+ sqlite3_stmt *delete_records;
/**
- * Precompiled SQL for iterate over all records.
+ * Precompiled SQL for iterate records within a zone.
*/
- sqlite3_stmt *iterate_all;
+ sqlite3_stmt *iterate_zone;
/**
- * Precompiled SQL for iterate records with same name.
+ * Precompiled SQL for iterate all records within all zones.
*/
- sqlite3_stmt *iterate_by_name;
+ sqlite3_stmt *iterate_all_zones;
/**
- * Precompiled SQL for iterate records with same zone.
- */
- sqlite3_stmt *iterate_by_zone;
-
- /**
- * Precompiled SQL for iterate records with same name and zone.
- */
- sqlite3_stmt *iterate_records;
-
- /**
- * Precompiled SQL to get the name for a given zone-value.
+ * Precompiled SQL to for reverse lookup based on PKEY.
*/
sqlite3_stmt *zone_to_name;
/**
- * Precompiled SQL for delete zone
+ * Precompiled SQL to lookup records based on label.
*/
- sqlite3_stmt *delete_zone;
-
+ sqlite3_stmt *lookup_label;
};
* @return 0 on success
*/
static int
-sq_prepare (sqlite3 * dbh, const char *zSql, sqlite3_stmt ** ppStmt)
+sq_prepare (sqlite3 *dbh,
+ const char *zSql,
+ sqlite3_stmt **ppStmt)
{
char *dummy;
int result;
result =
- sqlite3_prepare_v2 (dbh, zSql, strlen (zSql), ppStmt,
+ sqlite3_prepare_v2 (dbh,
+ zSql,
+ strlen (zSql),
+ ppStmt,
(const char **) &dummy);
- LOG (GNUNET_ERROR_TYPE_DEBUG,
- "Prepared `%s' / %p: %d\n", zSql, *ppStmt, result);
+ LOG (GNUNET_ERROR_TYPE_DEBUG,
+ "Prepared `%s' / %p: %d\n",
+ zSql,
+ *ppStmt,
+ result);
return result;
}
{
/* create indices */
if ( (SQLITE_OK !=
- 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 ns091records (zone_hash,rvalue)",
+ sqlite3_exec (dbh,
+ "CREATE INDEX IF NOT EXISTS ir_pkey_reverse ON ns097records (zone_private_key,pkey)",
NULL, NULL, NULL)) ||
(SQLITE_OK !=
- sqlite3_exec (dbh, "CREATE INDEX IF NOT EXISTS ir_zone ON ns091records (zone_hash)",
+ sqlite3_exec (dbh,
+ "CREATE INDEX IF NOT EXISTS ir_pkey_iter ON ns097records (zone_private_key,rvalue)",
NULL, NULL, NULL)) ||
(SQLITE_OK !=
- 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 ns091records (rvalue)",
- NULL, NULL, NULL)) )
- LOG (GNUNET_ERROR_TYPE_ERROR,
- "Failed to create indices: %s\n", sqlite3_errmsg (dbh));
+ sqlite3_exec (dbh,
+ "CREATE INDEX IF NOT EXISTS it_iter ON ns097records (rvalue)",
+ NULL, NULL, NULL)) )
+ LOG (GNUNET_ERROR_TYPE_ERROR,
+ "Failed to create indices: %s\n",
+ sqlite3_errmsg (dbh));
}
#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); }
+#define CHECK(a) if (! (a)) { GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "%s\n", e); sqlite3_free(e); }
#endif
* 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)
#endif
if (GNUNET_OK !=
- GNUNET_CONFIGURATION_get_value_filename (plugin->cfg, "namestore-sqlite",
- "FILENAME", &afsdir))
+ GNUNET_CONFIGURATION_get_value_filename (plugin->cfg,
+ "namestore-sqlite",
+ "FILENAME",
+ &afsdir))
{
GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR,
- "namestore-sqlite", "FILENAME");
+ "namestore-sqlite",
+ "FILENAME");
return GNUNET_SYSERR;
}
- if (GNUNET_OK != GNUNET_DISK_file_test (afsdir))
+ if (GNUNET_OK !=
+ GNUNET_DISK_file_test (afsdir))
{
- if (GNUNET_OK != GNUNET_DISK_directory_create_for_file (afsdir))
+ if (GNUNET_OK !=
+ GNUNET_DISK_directory_create_for_file (afsdir))
{
GNUNET_break (0);
GNUNET_free (afsdir);
return GNUNET_SYSERR;
}
CHECK (SQLITE_OK ==
- sqlite3_exec (plugin->dbh, "PRAGMA temp_store=MEMORY", NULL, NULL,
+ sqlite3_exec (plugin->dbh,
+ "PRAGMA temp_store=MEMORY", NULL, NULL,
ENULL));
CHECK (SQLITE_OK ==
- sqlite3_exec (plugin->dbh, "PRAGMA synchronous=NORMAL", NULL, NULL,
+ sqlite3_exec (plugin->dbh,
+ "PRAGMA synchronous=NORMAL", NULL, NULL,
ENULL));
CHECK (SQLITE_OK ==
- sqlite3_exec (plugin->dbh, "PRAGMA legacy_file_format=OFF", NULL, NULL,
+ sqlite3_exec (plugin->dbh,
+ "PRAGMA legacy_file_format=OFF", NULL, NULL,
ENULL));
CHECK (SQLITE_OK ==
- sqlite3_exec (plugin->dbh, "PRAGMA auto_vacuum=INCREMENTAL", NULL,
+ sqlite3_exec (plugin->dbh,
+ "PRAGMA auto_vacuum=INCREMENTAL", NULL,
NULL, ENULL));
CHECK (SQLITE_OK ==
- sqlite3_exec (plugin->dbh, "PRAGMA encoding=\"UTF-8\"", NULL,
+ 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,
+ sqlite3_exec (plugin->dbh,
+ "PRAGMA locking_mode=EXCLUSIVE", NULL, NULL,
ENULL));
CHECK (SQLITE_OK ==
- sqlite3_exec (plugin->dbh, "PRAGMA page_size=4092", NULL, NULL,
+ sqlite3_exec (plugin->dbh,
+ "PRAGMA page_size=4092", NULL, NULL,
ENULL));
- CHECK (SQLITE_OK == sqlite3_busy_timeout (plugin->dbh, BUSY_TIMEOUT_MS));
+ CHECK (SQLITE_OK ==
+ sqlite3_busy_timeout (plugin->dbh,
+ BUSY_TIMEOUT_MS));
- /* Create tables */
+ /* Create table */
CHECK (SQLITE_OK ==
sq_prepare (plugin->dbh,
- "SELECT 1 FROM sqlite_master WHERE tbl_name = 'ns091records'",
+ "SELECT 1 FROM sqlite_master WHERE tbl_name = 'ns097records'",
&stmt));
if ((sqlite3_step (stmt) == SQLITE_DONE) &&
(sqlite3_exec
(plugin->dbh,
- "CREATE TABLE ns091records ("
- " zone_key BLOB NOT NULL DEFAULT '',"
- " zone_delegation BLOB NOT NULL DEFAULT '',"
- " zone_hash BLOB NOT NULL DEFAULT '',"
+ "CREATE TABLE ns097records ("
+ " zone_private_key BLOB NOT NULL DEFAULT '',"
+ " pkey BLOB,"
+ " rvalue INT8 NOT NULL DEFAULT '',"
" record_count INT NOT NULL DEFAULT 0,"
" record_data BLOB NOT NULL DEFAULT '',"
- " block_expiration_time INT8 NOT NULL DEFAULT 0,"
- " signature BLOB NOT NULL DEFAULT '',"
- " record_name TEXT NOT NULL DEFAULT '',"
- " record_name_hash BLOB NOT NULL DEFAULT '',"
- " rvalue INT8 NOT NULL DEFAULT ''"
- ")",
+ " label TEXT NOT NULL DEFAULT ''"
+ ")",
NULL, NULL, NULL) != SQLITE_OK))
{
- LOG_SQLITE (plugin, GNUNET_ERROR_TYPE_ERROR, "sqlite3_exec");
+ LOG_SQLITE (plugin, GNUNET_ERROR_TYPE_ERROR,
+ "sqlite3_exec");
sqlite3_finalize (stmt);
return GNUNET_SYSERR;
}
create_indices (plugin->dbh);
- if ((sq_prepare
- (plugin->dbh,
- "INSERT INTO ns091records (zone_key, record_name, record_count, record_data, block_expiration_time, signature, zone_delegation, zone_hash, record_name_hash, rvalue) VALUES "
- "(?, ?, ?, ?, ?, ?, ?, ?, ?, ?)",
- &plugin->put_records) != SQLITE_OK) ||
- (sq_prepare
- (plugin->dbh,
- "DELETE FROM ns091records WHERE zone_hash=? AND record_name_hash=?",
- &plugin->remove_records) != SQLITE_OK) ||
- (sq_prepare
- (plugin->dbh,
- "SELECT zone_key, record_name, record_count, record_data, block_expiration_time, signature"
- " 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 zone_key, record_name, record_count, record_data, block_expiration_time, signature"
- " FROM ns091records WHERE zone_hash=? ORDER BY rvalue LIMIT 1 OFFSET ?",
- &plugin->iterate_by_zone) != SQLITE_OK) ||
- (sq_prepare
- (plugin->dbh,
- "SELECT zone_key, record_name, record_count, record_data, block_expiration_time, signature"
- " FROM ns091records WHERE record_name_hash=? ORDER BY rvalue LIMIT 1 OFFSET ?",
- &plugin->iterate_by_name) != SQLITE_OK) ||
- (sq_prepare
- (plugin->dbh,
- "SELECT zone_key, record_name, record_count, record_data, block_expiration_time, signature"
- " FROM ns091records ORDER BY rvalue LIMIT 1 OFFSET ?",
- &plugin->iterate_all) != SQLITE_OK) ||
- (sq_prepare
- (plugin->dbh,
- "SELECT zone_key, record_name, record_count, record_data, block_expiration_time, signature"
- " FROM ns091records WHERE zone_hash=? AND zone_delegation=?",
- &plugin->zone_to_name) != SQLITE_OK) ||
- (sq_prepare
- (plugin->dbh,
- "DELETE FROM ns091records WHERE zone_hash=?",
- &plugin->delete_zone) != SQLITE_OK) )
+ if ( (SQLITE_OK !=
+ sq_prepare (plugin->dbh,
+ "INSERT INTO ns097records (zone_private_key, pkey, rvalue, record_count, record_data, label)"
+ " VALUES (?, ?, ?, ?, ?, ?)",
+ &plugin->store_records)) ||
+ (SQLITE_OK !=
+ sq_prepare (plugin->dbh,
+ "DELETE FROM ns097records WHERE zone_private_key=? AND label=?",
+ &plugin->delete_records)) ||
+ (SQLITE_OK !=
+ sq_prepare (plugin->dbh,
+ "SELECT record_count,record_data,label"
+ " FROM ns097records WHERE zone_private_key=? AND pkey=?",
+ &plugin->zone_to_name)) ||
+ (SQLITE_OK !=
+ sq_prepare (plugin->dbh,
+ "SELECT record_count,record_data,label"
+ " FROM ns097records WHERE zone_private_key=?"
+ " ORDER BY rvalue LIMIT 1 OFFSET ?",
+ &plugin->iterate_zone)) ||
+ (SQLITE_OK !=
+ sq_prepare (plugin->dbh,
+ "SELECT record_count,record_data,label,zone_private_key"
+ " FROM ns097records ORDER BY rvalue LIMIT 1 OFFSET ?",
+ &plugin->iterate_all_zones)) ||
+ (SQLITE_OK !=
+ sq_prepare (plugin->dbh,
+ "SELECT record_count,record_data,label,zone_private_key"
+ " FROM ns097records WHERE zone_private_key=? AND label=?",
+ &plugin->lookup_label))
+ )
{
- LOG_SQLITE (plugin,GNUNET_ERROR_TYPE_ERROR, "precompiling");
+ LOG_SQLITE (plugin,
+ GNUNET_ERROR_TYPE_ERROR,
+ "precompiling");
return GNUNET_SYSERR;
}
return GNUNET_OK;
int result;
sqlite3_stmt *stmt;
- if (NULL != plugin->put_records)
- sqlite3_finalize (plugin->put_records);
- if (NULL != plugin->remove_records)
- sqlite3_finalize (plugin->remove_records);
- if (NULL != plugin->iterate_records)
- sqlite3_finalize (plugin->iterate_records);
- if (NULL != plugin->iterate_by_zone)
- sqlite3_finalize (plugin->iterate_by_zone);
- if (NULL != plugin->iterate_by_name)
- sqlite3_finalize (plugin->iterate_by_name);
- if (NULL != plugin->iterate_all)
- sqlite3_finalize (plugin->iterate_all);
+ 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->delete_zone)
- sqlite3_finalize (plugin->delete_zone);
+ 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);
}
-/**
- * Removes any existing record in the given 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 to remove (at most 255 characters long)
- * @return GNUNET_OK on success
- */
-static int
-namestore_sqlite_remove_records (void *cls,
- const struct GNUNET_CRYPTO_ShortHashCode *zone,
- const char *name)
-{
- struct Plugin *plugin = cls;
- struct GNUNET_CRYPTO_ShortHashCode nh;
- size_t name_len;
- int n;
-
- name_len = strlen (name);
- GNUNET_CRYPTO_short_hash (name, name_len, &nh);
-
- 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");
- if (SQLITE_OK != sqlite3_reset (plugin->remove_records))
- LOG_SQLITE (plugin,
- GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
- "sqlite3_reset");
- return GNUNET_SYSERR;
- }
- n = sqlite3_step (plugin->remove_records);
- if (SQLITE_OK != sqlite3_reset (plugin->remove_records))
- 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 removed\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 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_key public key of the zone
- * @param expire when does the corresponding block in the DHT expire (until
- * when should we never do a DHT lookup for the same name again)?
- * @param name name that is being mapped (at most 255 characters long)
- * @param rd_count number of entries in 'rd' array
+ * @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
- * @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, else GNUNET_SYSERR
+ * @return #GNUNET_OK on success, else #GNUNET_SYSERR
*/
-static int
-namestore_sqlite_put_records (void *cls,
- const struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded *zone_key,
- struct GNUNET_TIME_Absolute expire,
- const char *name,
- unsigned int rd_count,
- const struct GNUNET_NAMESTORE_RecordData *rd,
- const struct GNUNET_CRYPTO_EccSignature *signature)
+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;
- struct GNUNET_CRYPTO_ShortHashCode zone;
- struct GNUNET_CRYPTO_ShortHashCode zone_delegation;
- struct GNUNET_CRYPTO_ShortHashCode nh;
- size_t name_len;
+ struct GNUNET_CRYPTO_EcdsaPublicKey pkey;
uint64_t rvalue;
size_t data_size;
unsigned int i;
- GNUNET_CRYPTO_short_hash (zone_key, sizeof (struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded), &zone);
- (void) namestore_sqlite_remove_records (plugin, &zone, name);
- name_len = strlen (name);
- GNUNET_CRYPTO_short_hash (name, name_len, &nh);
- memset (&zone_delegation, 0, sizeof (zone_delegation));
+ memset (&pkey, 0, sizeof (pkey));
for (i=0;i<rd_count;i++)
- if (rd[i].record_type == GNUNET_NAMESTORE_TYPE_PKEY)
+ if (GNUNET_GNSRECORD_TYPE_PKEY == rd[i].record_type)
{
- GNUNET_assert (sizeof (struct GNUNET_CRYPTO_ShortHashCode) == rd[i].data_size);
- memcpy (&zone_delegation,
- rd[i].data,
- sizeof (struct GNUNET_CRYPTO_ShortHashCode));
+ 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_NAMESTORE_records_get_size (rd_count, rd);
+ rvalue = GNUNET_CRYPTO_random_u64 (GNUNET_CRYPTO_QUALITY_WEAK,
+ UINT64_MAX);
+ data_size = GNUNET_GNSRECORD_records_get_size (rd_count,
+ rd);
if (data_size > 64 * 65536)
{
GNUNET_break (0);
return GNUNET_SYSERR;
}
{
+ /* First delete 'old' records */
char data[data_size];
-
- if (data_size != GNUNET_NAMESTORE_records_serialize (rd_count, rd,
- data_size, data))
+ 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
+ };
+
+ if (data_size !=
+ GNUNET_GNSRECORD_records_serialize (rd_count,
+ rd,
+ data_size,
+ data))
{
GNUNET_break (0);
return GNUNET_SYSERR;
}
- if ((SQLITE_OK != sqlite3_bind_blob (plugin->put_records, 1, zone_key, sizeof (struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded), SQLITE_STATIC)) ||
- (SQLITE_OK != sqlite3_bind_text (plugin->put_records, 2, name, -1, SQLITE_STATIC)) ||
- (SQLITE_OK != sqlite3_bind_int (plugin->put_records, 3, rd_count)) ||
- (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_EccSignature), SQLITE_STATIC)) ||
- (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)) )
+ if (GNUNET_OK !=
+ GNUNET_SQ_bind (plugin->delete_records,
+ dparams))
{
- LOG_SQLITE (plugin,
+ LOG_SQLITE (plugin,
GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
"sqlite3_bind_XXXX");
- if (SQLITE_OK != sqlite3_reset (plugin->put_records))
- LOG_SQLITE (plugin,
- GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
- "sqlite3_reset");
+ 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 (&rvalue),
+ 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_records);
- if (SQLITE_OK != sqlite3_reset (plugin->put_records))
- 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");
+ 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,
+ 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,
+ LOG_SQLITE (plugin,
+ GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
"sqlite3_step");
- return GNUNET_SYSERR;
+ return GNUNET_SYSERR;
}
}
*
* @param plugin plugin context
* @param stmt to run (and then clean up)
+ * @param zone_key private key of the zone
* @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
+ * @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
get_record_and_call_iterator (struct Plugin *plugin,
- sqlite3_stmt *stmt,
- GNUNET_NAMESTORE_RecordIterator iter, void *iter_cls)
+ sqlite3_stmt *stmt,
+ const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone_key,
+ GNUNET_NAMESTORE_RecordIterator iter,
+ void *iter_cls)
{
+ uint32_t record_count;
+ size_t data_size;
+ void *data;
+ char *label;
+ struct GNUNET_CRYPTO_EcdsaPrivateKey zk;
int ret;
int sret;
- unsigned int record_count;
- size_t data_size;
- const struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded *zone_key;
- const struct GNUNET_CRYPTO_EccSignature *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_EccPublicKeyBinaryEncoded) != sqlite3_column_bytes (stmt, 0)) ||
- (sizeof (struct GNUNET_CRYPTO_EccSignature) != sqlite3_column_bytes (stmt, 5)) )
+ {
+ struct GNUNET_SQ_ResultSpec rs[] = {
+ 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_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)
{
- GNUNET_break (0);
- ret = GNUNET_SYSERR;
+ zone_key = &zk;
+ ret = GNUNET_SQ_extract_result (stmt,
+ rsx);
+ }
+ else
+ {
+ ret = GNUNET_SQ_extract_result (stmt,
+ rs);
}
- else if (record_count > 64 * 1024)
+ 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;
- }
+ }
else
{
- struct GNUNET_NAMESTORE_RecordData rd[record_count];
+ struct GNUNET_GNSRECORD_Data rd[record_count];
if (GNUNET_OK !=
- GNUNET_NAMESTORE_records_deserialize (data_size, data,
- record_count, rd))
+ GNUNET_GNSRECORD_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);
+ if (NULL != iter)
+ iter (iter_cls,
+ zone_key,
+ label,
+ record_count,
+ rd);
+ ret = GNUNET_YES;
}
}
+ GNUNET_SQ_cleanup_result (rs);
}
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);
+ LOG_SQLITE (plugin,
+ GNUNET_ERROR_TYPE_ERROR,
+ "sqlite_step");
}
- if (SQLITE_OK != sqlite3_reset (stmt))
- LOG_SQLITE (plugin,
- GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
- "sqlite3_reset");
+ GNUNET_SQ_reset (plugin->dbh,
+ stmt);
return ret;
}
-
-
+
+
/**
- * Iterate over the results for a particular key and zone in the
- * datastore. Will return at most one result to the iterator.
+ * 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, NULL to iterate over all zones
- * @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 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 iter
- * @return GNUNET_OK on success, GNUNET_NO if there were no results, GNUNET_SYSERR on error
+ * @param iter_cls closure for @a iter
+ * @return #GNUNET_OK on success, else #GNUNET_SYSERR
*/
-static int
-namestore_sqlite_iterate_records (void *cls,
- const struct GNUNET_CRYPTO_ShortHashCode *zone,
- const char *name,
- uint64_t offset,
- GNUNET_NAMESTORE_RecordIterator iter, void *iter_cls)
+static int
+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;
- sqlite3_stmt *stmt;
- struct GNUNET_CRYPTO_ShortHashCode name_hase;
- unsigned int boff;
+ 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)
- 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)
- 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 (struct GNUNET_CRYPTO_ShortHashCode),
- SQLITE_STATIC)) )
- {
- 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;
- }
- if ( (NULL != name) &&
- (SQLITE_OK != sqlite3_bind_blob (stmt, ++boff,
- &name_hase, sizeof (struct GNUNET_CRYPTO_ShortHashCode),
- SQLITE_STATIC)) )
- {
- GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
- "ITERATE NAME HASH: `%8s'",
- GNUNET_NAMESTORE_short_h2s(&name_hase));
- 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;
- }
-
- if (SQLITE_OK != sqlite3_bind_int64 (stmt, ++boff,
- offset))
+ if (GNUNET_OK !=
+ GNUNET_SQ_bind (plugin->lookup_label,
+ params))
{
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");
+ GNUNET_SQ_reset (plugin->dbh,
+ plugin->lookup_label);
return GNUNET_SYSERR;
}
-
- return get_record_and_call_iterator (plugin, stmt, iter, iter_cls);
+ return get_record_and_call_iterator (plugin,
+ plugin->lookup_label,
+ zone,
+ iter,
+ iter_cls);
}
/**
- * Look for an existing PKEY delegation record for a given public key.
- * Returns at most one result to the iterator.
+ * Iterate over the results for a particular key and zone in the
+ * datastore. Will return 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 zone hash of public key of the zone, NULL to iterate over all zones
+ * @param offset offset in the list of all matching records
* @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
+ * @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_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)
+namestore_sqlite_iterate_records (void *cls,
+ const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone,
+ uint64_t offset,
+ GNUNET_NAMESTORE_RecordIterator iter,
+ void *iter_cls)
{
struct Plugin *plugin = cls;
sqlite3_stmt *stmt;
+ int err;
- 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 (NULL == zone)
{
- LOG_SQLITE (plugin, GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
+ struct GNUNET_SQ_QueryParam params[] = {
+ GNUNET_SQ_query_param_uint64 (&offset),
+ 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 (&offset),
+ 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");
- if (SQLITE_OK != sqlite3_reset (stmt))
- LOG_SQLITE (plugin,
- GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
- "sqlite3_reset");
+ GNUNET_SQ_reset (plugin->dbh,
+ stmt);
return GNUNET_SYSERR;
- }
- return get_record_and_call_iterator (plugin, stmt, iter, iter_cls);
+ }
+ return get_record_and_call_iterator (plugin,
+ stmt,
+ zone,
+ iter,
+ iter_cls);
}
/**
- * Delete an entire zone (all records). 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
+ * @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 void
-namestore_sqlite_delete_zone (void *cls,
- const struct GNUNET_CRYPTO_ShortHashCode *zone)
+static int
+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;
- sqlite3_stmt *stmt = plugin->delete_zone;
- int n;
+ 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 (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");
- if (SQLITE_OK != sqlite3_reset (stmt))
- LOG_SQLITE (plugin,
- GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
- "sqlite3_reset");
- return;
- }
- 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)
+ if (GNUNET_OK !=
+ GNUNET_SQ_bind (plugin->zone_to_name,
+ params))
{
- 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;
+ 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_record_and_call_iterator (plugin,
+ plugin->zone_to_name,
+ zone,
+ 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;
+ 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_records = &namestore_sqlite_put_records;
- api->remove_records = &namestore_sqlite_remove_records;
+ api->store_records = &namestore_sqlite_store_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,
+ 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