/**
* Exit point from the plugin.
*
* @param cls the plugin context (as returned by "init")
* @return always NULL
*/
void *
libgnunet_plugin_datastore_sqlite_done (void *cls)
{
char *fn;
struct GNUNET_DATASTORE_PluginFunctions *api = cls;
struct Plugin *plugin = api->cls;
GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, "sqlite",
"sqlite plugin is done\n");
fn = NULL;
if (plugin->drop_on_shutdown)
fn = GNUNET_strdup (plugin->fn);
GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, "sqlite",
"Shutting down database\n");
database_shutdown (plugin);
plugin->env = NULL;
GNUNET_free (api);
if (fn != NULL)
{
if (0 != UNLINK (fn))
GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING, "unlink", fn);
GNUNET_free (fn);
}
GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, "sqlite",
"sqlite plugin is finished\n");
return NULL;
}
/**
* Entry point for the plugin.
*
* @param cls the "struct GNUNET_DATASTORE_PluginEnvironment*"
* @return NULL on error, othrewise the plugin context
*/
void *
libgnunet_plugin_datastore_sqlite_init (void *cls)
{
static struct Plugin plugin;
struct GNUNET_DATASTORE_PluginEnvironment *env = cls;
struct GNUNET_DATASTORE_PluginFunctions *api;
if (plugin.env != NULL)
return NULL; /* can only initialize once! */
memset (&plugin, 0, sizeof (struct Plugin));
plugin.env = env;
if (GNUNET_OK != database_setup (env->cfg, &plugin))
{
database_shutdown (&plugin);
return NULL;
}
api = GNUNET_malloc (sizeof (struct GNUNET_DATASTORE_PluginFunctions));
api->cls = &plugin;
api->estimate_size = &sqlite_plugin_estimate_size;
api->put = &sqlite_plugin_put;
api->update = &sqlite_plugin_update;
api->get_key = &sqlite_plugin_get_key;
api->get_replication = &sqlite_plugin_get_replication;
api->get_expiration = &sqlite_plugin_get_expiration;
api->get_zero_anonymity = &sqlite_plugin_get_zero_anonymity;
api->get_keys = &sqlite_plugin_get_keys;
api->drop = &sqlite_plugin_drop;
GNUNET_log_from (GNUNET_ERROR_TYPE_INFO, "sqlite",
_("Sqlite database running\n"));
return api;
}
EAPI int eolian_shutdown(void)
{
if (_eolian_init_counter <= 0)
{
EINA_LOG_ERR("Init count not greater than 0 in shutdown.");
return 0;
}
_eolian_init_counter--;
if (_eolian_init_counter == 0)
{
INF("Shutdown");
eina_log_timing(_eolian_log_dom,
EINA_LOG_STATE_START,
EINA_LOG_STATE_SHUTDOWN);
eo_lexer_shutdown();
database_shutdown();
eina_prefix_free(_eolian_prefix);
_eolian_prefix = NULL;
eina_log_domain_unregister(_eolian_log_dom);
_eolian_log_dom = -1;
eina_shutdown();
}
return _eolian_init_counter;
}
/**
* Exit point from the plugin.
*
* @param cls The plugin context (as returned by "init")
* @return Always NULL
*/
void *
libgnunet_plugin_peerstore_sqlite_done (void *cls)
{
struct GNUNET_PEERSTORE_PluginFunctions *api = cls;
struct Plugin *plugin = api->cls;
database_shutdown (plugin);
plugin->cfg = NULL;
GNUNET_free (api);
LOG (GNUNET_ERROR_TYPE_DEBUG, "Sqlite plugin is finished\n");
return NULL;
}
/**
* Exit point from the plugin.
*
* @param cls the plugin context (as returned by "init")
* @return always NULL
*/
void *
libgnunet_plugin_namecache_sqlite_done (void *cls)
{
struct GNUNET_NAMECACHE_PluginFunctions *api = cls;
struct Plugin *plugin = api->cls;
database_shutdown (plugin);
plugin->cfg = NULL;
GNUNET_free (api);
LOG (GNUNET_ERROR_TYPE_DEBUG,
"sqlite plugin is finished\n");
return NULL;
}
/**
* Entry point for the plugin.
*
* @param cls The struct GNUNET_CONFIGURATION_Handle.
* @return NULL on error, otherwise the plugin context
*/
void *
libgnunet_plugin_peerstore_sqlite_init (void *cls)
{
static struct Plugin plugin;
const struct GNUNET_CONFIGURATION_Handle *cfg = cls;
struct GNUNET_PEERSTORE_PluginFunctions *api;
if (NULL != plugin.cfg)
return NULL; /* can only initialize once! */
memset (&plugin, 0, sizeof (struct Plugin));
plugin.cfg = cfg;
if (GNUNET_OK != database_setup (&plugin))
{
database_shutdown (&plugin);
return NULL;
}
api = GNUNET_new (struct GNUNET_PEERSTORE_PluginFunctions);
api->cls = &plugin;
api->store_record = &peerstore_sqlite_store_record;
api->iterate_records = &peerstore_sqlite_iterate_records;
api->expire_records = &peerstore_sqlite_expire_records;
LOG (GNUNET_ERROR_TYPE_DEBUG, "Sqlite plugin is running\n");
return api;
}
/**
* Entry point for the plugin.
*
* @param cls the "struct GNUNET_NAMECACHE_PluginEnvironment*"
* @return NULL on error, otherwise the plugin context
*/
void *
libgnunet_plugin_namecache_sqlite_init (void *cls)
{
static struct Plugin plugin;
const struct GNUNET_CONFIGURATION_Handle *cfg = cls;
struct GNUNET_NAMECACHE_PluginFunctions *api;
if (NULL != plugin.cfg)
return NULL; /* can only initialize once! */
memset (&plugin, 0, sizeof (struct Plugin));
plugin.cfg = cfg;
if (GNUNET_OK != database_setup (&plugin))
{
database_shutdown (&plugin);
return NULL;
}
api = GNUNET_new (struct GNUNET_NAMECACHE_PluginFunctions);
api->cls = &plugin;
api->cache_block = &namecache_sqlite_cache_block;
api->lookup_block = &namecache_sqlite_lookup_block;
LOG (GNUNET_ERROR_TYPE_INFO,
_("Sqlite database running\n"));
return api;
}
/**
* Execute statement that gets a row and call the callback
* with the result. Resets the statement afterwards.
*
* @param plugin the plugin
* @param stmt the statement
* @param proc processor to call
* @param proc_cls closure for 'proc'
*/
static void
execute_get (struct Plugin *plugin, sqlite3_stmt * stmt,
PluginDatumProcessor proc, void *proc_cls)
{
int n;
struct GNUNET_TIME_Absolute expiration;
unsigned long long rowid;
unsigned int size;
int ret;
n = sqlite3_step (stmt);
switch (n)
{
case SQLITE_ROW:
size = sqlite3_column_bytes (stmt, 5);
rowid = sqlite3_column_int64 (stmt, 6);
if (sqlite3_column_bytes (stmt, 4) != sizeof (GNUNET_HashCode))
{
GNUNET_log_from (GNUNET_ERROR_TYPE_WARNING, "sqlite",
_
("Invalid data in database. Trying to fix (by deletion).\n"));
if (SQLITE_OK != sqlite3_reset (stmt))
LOG_SQLITE (plugin, NULL,
GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
"sqlite3_reset");
if (GNUNET_OK == delete_by_rowid (plugin, rowid))
plugin->env->duc (plugin->env->cls,
-(size + GNUNET_DATASTORE_ENTRY_OVERHEAD));
break;
}
expiration.abs_value = sqlite3_column_int64 (stmt, 3);
GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, "sqlite",
"Found reply in database with expiration %llu\n",
(unsigned long long) expiration.abs_value);
ret = proc (proc_cls, sqlite3_column_blob (stmt, 4) /* key */ ,
size, sqlite3_column_blob (stmt, 5) /* data */ ,
sqlite3_column_int (stmt, 0) /* type */ ,
sqlite3_column_int (stmt, 1) /* priority */ ,
sqlite3_column_int (stmt, 2) /* anonymity */ ,
expiration, rowid);
if (SQLITE_OK != sqlite3_reset (stmt))
LOG_SQLITE (plugin, NULL,
GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
"sqlite3_reset");
if ((GNUNET_NO == ret) && (GNUNET_OK == delete_by_rowid (plugin, rowid)))
plugin->env->duc (plugin->env->cls,
-(size + GNUNET_DATASTORE_ENTRY_OVERHEAD));
return;
case SQLITE_DONE:
/* database must be empty */
if (SQLITE_OK != sqlite3_reset (stmt))
LOG_SQLITE (plugin, NULL,
GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
"sqlite3_reset");
break;
case SQLITE_BUSY:
case SQLITE_ERROR:
case SQLITE_MISUSE:
default:
LOG_SQLITE (plugin, NULL, GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
"sqlite3_step");
if (SQLITE_OK != sqlite3_reset (stmt))
LOG_SQLITE (plugin, NULL,
GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
"sqlite3_reset");
GNUNET_break (0);
database_shutdown (plugin);
database_setup (plugin->env->cfg, plugin);
break;
}
if (SQLITE_OK != sqlite3_reset (stmt))
LOG_SQLITE (plugin, NULL, GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
"sqlite3_reset");
proc (proc_cls, NULL, 0, NULL, 0, 0, 0, GNUNET_TIME_UNIT_ZERO_ABS, 0);
}
/**
* Store an item in the datastore.
*
* @param cls closure
* @param key key for the item
* @param size number of bytes in data
* @param data content stored
* @param type type of the content
* @param priority priority of the content
* @param anonymity anonymity-level for the content
* @param replication replication-level for the content
* @param expiration expiration time for the content
* @param msg set to an error message
* @return GNUNET_OK on success
*/
static int
sqlite_plugin_put (void *cls, const GNUNET_HashCode * key, uint32_t size,
const void *data, enum GNUNET_BLOCK_Type type,
uint32_t priority, uint32_t anonymity, uint32_t replication,
struct GNUNET_TIME_Absolute expiration, char **msg)
{
struct Plugin *plugin = cls;
int n;
int ret;
sqlite3_stmt *stmt;
GNUNET_HashCode vhash;
uint64_t rvalue;
if (size > MAX_ITEM_SIZE)
return GNUNET_SYSERR;
GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, "sqlite",
"Storing in database block with type %u/key `%s'/priority %u/expiration in %llu ms (%lld).\n",
type, GNUNET_h2s (key), priority,
(unsigned long long)
GNUNET_TIME_absolute_get_remaining (expiration).rel_value,
(long long) expiration.abs_value);
GNUNET_CRYPTO_hash (data, size, &vhash);
stmt = plugin->insertContent;
rvalue = GNUNET_CRYPTO_random_u64 (GNUNET_CRYPTO_QUALITY_WEAK, UINT64_MAX);
if ((SQLITE_OK != sqlite3_bind_int (stmt, 1, replication)) ||
(SQLITE_OK != sqlite3_bind_int (stmt, 2, type)) ||
(SQLITE_OK != sqlite3_bind_int (stmt, 3, priority)) ||
(SQLITE_OK != sqlite3_bind_int (stmt, 4, anonymity)) ||
(SQLITE_OK != sqlite3_bind_int64 (stmt, 5, expiration.abs_value)) ||
(SQLITE_OK != sqlite3_bind_int64 (stmt, 6, rvalue)) ||
(SQLITE_OK !=
sqlite3_bind_blob (stmt, 7, key, sizeof (GNUNET_HashCode),
SQLITE_TRANSIENT)) ||
(SQLITE_OK !=
sqlite3_bind_blob (stmt, 8, &vhash, sizeof (GNUNET_HashCode),
SQLITE_TRANSIENT)) ||
(SQLITE_OK != sqlite3_bind_blob (stmt, 9, data, size, SQLITE_TRANSIENT)))
{
LOG_SQLITE (plugin, msg, GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
"sqlite3_bind_XXXX");
if (SQLITE_OK != sqlite3_reset (stmt))
LOG_SQLITE (plugin, NULL,
GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
"sqlite3_reset");
return GNUNET_SYSERR;
}
n = sqlite3_step (stmt);
switch (n)
{
case SQLITE_DONE:
plugin->env->duc (plugin->env->cls, size + GNUNET_DATASTORE_ENTRY_OVERHEAD);
GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, "sqlite",
"Stored new entry (%u bytes)\n",
size + GNUNET_DATASTORE_ENTRY_OVERHEAD);
ret = GNUNET_OK;
break;
case SQLITE_BUSY:
GNUNET_break (0);
LOG_SQLITE (plugin, msg, GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
"sqlite3_step");
ret = GNUNET_SYSERR;
break;
default:
LOG_SQLITE (plugin, msg, GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
"sqlite3_step");
if (SQLITE_OK != sqlite3_reset (stmt))
LOG_SQLITE (plugin, NULL,
GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
"sqlite3_reset");
database_shutdown (plugin);
database_setup (plugin->env->cfg, plugin);
return GNUNET_SYSERR;
}
if (SQLITE_OK != sqlite3_reset (stmt))
LOG_SQLITE (plugin, NULL, GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
"sqlite3_reset");
return ret;
}
