GNUnet 0.22.0
plugin_namecache_sqlite.c File Reference

sqlite-based namecache backend More...

#include "platform.h"
#include "gnunet_sq_lib.h"
#include "gnunet_namecache_plugin.h"
#include "gnunet_gnsrecord_lib.h"
#include <sqlite3.h>
Include dependency graph for plugin_namecache_sqlite.c:

Go to the source code of this file.

Data Structures

struct  Plugin
 Handle for a plugin. More...
 

Macros

#define BUSY_TIMEOUT_MS   1000
 After how many ms "busy" should a DB operation fail for good? A low value makes sure that we are more responsive to requests (especially PUTs). More...
 
#define LOG_SQLITE(db, level, cmd)
 Log an error message at log-level 'level' that indicates a failure of the command 'cmd' on file 'filename' with the message given by strerror(errno). More...
 
#define LOG(kind, ...)   GNUNET_log_from (kind, "namecache-sqlite", __VA_ARGS__)
 

Functions

static int database_setup (struct Plugin *plugin)
 Initialize the database connections and associated data structures (create tables and indices as needed as well). More...
 
static void database_shutdown (struct Plugin *plugin)
 Shutdown database connection and associate data structures. More...
 
static void namecache_sqlite_expire_blocks (struct Plugin *plugin)
 Removes any expired block. More...
 
static int namecache_sqlite_cache_block (void *cls, const struct GNUNET_GNSRECORD_Block *block)
 Cache a block in the datastore. More...
 
static int namecache_sqlite_lookup_block (void *cls, const struct GNUNET_HashCode *query, GNUNET_NAMECACHE_BlockCallback iter, void *iter_cls)
 Get the block for a particular zone and label in the datastore. More...
 
void * libgnunet_plugin_namecache_sqlite_init (void *cls)
 Entry point for the plugin. More...
 
void * libgnunet_plugin_namecache_sqlite_done (void *cls)
 Exit point from the plugin. More...
 

Detailed Description

sqlite-based namecache backend

Author
Christian Grothoff

Definition in file plugin_namecache_sqlite.c.

Macro Definition Documentation

◆ BUSY_TIMEOUT_MS

#define BUSY_TIMEOUT_MS   1000

After how many ms "busy" should a DB operation fail for good? A low value makes sure that we are more responsive to requests (especially PUTs).

A high value guarantees a higher success rate (SELECTs in iterate can take several seconds despite LIMIT=1).

The default value of 1s should ensure that users do not experience huge latencies while at the same time allowing operations to succeed with reasonable probability.

Definition at line 42 of file plugin_namecache_sqlite.c.

◆ LOG_SQLITE

#define LOG_SQLITE (   db,
  level,
  cmd 
)
Value:
do { GNUNET_log_from (level, \
"namecache-sqlite", _ ( \
"`%s' failed at %s:%d with error: %s\n"), \
cmd, \
__FILE__, __LINE__, \
sqlite3_errmsg ( \
db->dbh)); \
} while (0)
static struct GNUNET_FS_DirectoryBuilder * db
#define GNUNET_log_from(kind, comp,...)
#define _(String)
GNU gettext support macro.
Definition: platform.h:178

Log an error message at log-level 'level' that indicates a failure of the command 'cmd' on file 'filename' with the message given by strerror(errno).

Definition at line 50 of file plugin_namecache_sqlite.c.

◆ LOG

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

Definition at line 59 of file plugin_namecache_sqlite.c.

Function Documentation

◆ database_setup()

static int database_setup ( struct Plugin plugin)
static

Initialize the database connections and associated data structures (create tables and indices as needed as well).

Parameters
pluginthe plugin context (state for this module)
Returns
GNUNET_OK on success

Definition at line 110 of file plugin_namecache_sqlite.c.

111{
112 struct GNUNET_SQ_ExecuteStatement es[] = {
113 GNUNET_SQ_make_try_execute ("PRAGMA temp_store=MEMORY"),
114 GNUNET_SQ_make_try_execute ("PRAGMA synchronous=NORMAL"),
115 GNUNET_SQ_make_try_execute ("PRAGMA legacy_file_format=OFF"),
116 GNUNET_SQ_make_try_execute ("PRAGMA auto_vacuum=INCREMENTAL"),
117 GNUNET_SQ_make_try_execute ("PRAGMA encoding=\"UTF-8\""),
118 GNUNET_SQ_make_try_execute ("PRAGMA locking_mode=EXCLUSIVE"),
119 GNUNET_SQ_make_try_execute ("PRAGMA page_size=4092"),
120 GNUNET_SQ_make_try_execute ("PRAGMA journal_mode=WAL"),
121 GNUNET_SQ_make_execute ("CREATE TABLE IF NOT EXISTS ns096blocks ("
122 " query BLOB NOT NULL,"
123 " block BLOB NOT NULL,"
124 " expiration_time INT8 NOT NULL"
125 ")"),
126 GNUNET_SQ_make_execute ("CREATE INDEX IF NOT EXISTS ir_query_hash "
127 "ON ns096blocks (query,expiration_time)"),
128 GNUNET_SQ_make_execute ("CREATE INDEX IF NOT EXISTS ir_block_expiration "
129 "ON ns096blocks (expiration_time)"),
131 };
132 struct GNUNET_SQ_PrepareStatement ps[] = {
134 "INSERT INTO ns096blocks (query,block,expiration_time) VALUES (?, ?, ?)",
135 &plugin->cache_block),
136 GNUNET_SQ_make_prepare ("DELETE FROM ns096blocks WHERE expiration_time<?",
137 &plugin->expire_blocks),
139 "DELETE FROM ns096blocks WHERE query=? AND expiration_time<=?",
140 &plugin->delete_block),
141 GNUNET_SQ_make_prepare ("SELECT block FROM ns096blocks WHERE query=? "
142 "ORDER BY expiration_time DESC LIMIT 1",
143 &plugin->lookup_block),
145 };
146 char *afsdir;
147
148 if (GNUNET_OK !=
150 "namecache-sqlite",
151 "FILENAME",
152 &afsdir))
153 {
155 "namecache-sqlite",
156 "FILENAME");
157 return GNUNET_SYSERR;
158 }
159 if (GNUNET_OK !=
160 GNUNET_DISK_file_test (afsdir))
161 {
162 if (GNUNET_OK !=
164 {
165 GNUNET_break (0);
166 GNUNET_free (afsdir);
167 return GNUNET_SYSERR;
168 }
169 }
170 /* afsdir should be UTF-8-encoded. If it isn't, it's a bug */
171 plugin->fn = afsdir;
172
173 /* Open database and precompile statements */
174 if (SQLITE_OK !=
175 sqlite3_open (plugin->fn, &plugin->dbh))
176 {
178 _ ("Unable to initialize SQLite: %s.\n"),
179 sqlite3_errmsg (plugin->dbh));
180 return GNUNET_SYSERR;
181 }
182 if (GNUNET_OK !=
184 es))
185 {
186 GNUNET_break (0);
188 _ ("Failed to setup database at `%s'\n"),
189 plugin->fn);
190 return GNUNET_SYSERR;
191 }
192 GNUNET_break (SQLITE_OK ==
193 sqlite3_busy_timeout (plugin->dbh,
195
196 if (GNUNET_OK !=
198 ps))
199 {
200 GNUNET_break (0);
202 _ ("Failed to setup database at `%s'\n"),
203 plugin->fn);
204 return GNUNET_SYSERR;
205 }
206
207 return GNUNET_OK;
208}
static struct GNUNET_TESTING_PluginFunctions * plugin
Plugin to dynamically load a test case.
static struct GNUNET_PEERSTORE_Handle * ps
Handle to the PEERSTORE service.
struct GNUNET_SQ_PrepareStatement GNUNET_SQ_make_prepare(const char *sql, sqlite3_stmt **pstmt)
Create a struct GNUNET_SQ_PrepareStatement
Definition: sq_prepare.c:37
struct GNUNET_SQ_ExecuteStatement GNUNET_SQ_make_execute(const char *sql)
Create a struct GNUNET_SQ_ExecuteStatement where errors are fatal.
Definition: sq_exec.c:36
struct GNUNET_SQ_ExecuteStatement GNUNET_SQ_make_try_execute(const char *sql)
Create a struct GNUNET_SQ_ExecuteStatement where errors should be tolerated.
Definition: sq_exec.c:55
#define GNUNET_SQ_PREPARE_END
Terminator for executable statement list.
enum GNUNET_GenericReturnValue GNUNET_SQ_exec_statements(sqlite3 *dbh, const struct GNUNET_SQ_ExecuteStatement *es)
Request execution of an array of statements es from Postgres.
Definition: sq_exec.c:76
enum GNUNET_GenericReturnValue GNUNET_SQ_prepare(sqlite3 *dbh, const struct GNUNET_SQ_PrepareStatement *ps)
Prepare all statements given in the (NULL,NULL)-terminated array at ps.
Definition: sq_prepare.c:50
#define GNUNET_SQ_EXECUTE_STATEMENT_END
Terminator for executable statement list.
enum GNUNET_GenericReturnValue GNUNET_CONFIGURATION_get_value_filename(const struct GNUNET_CONFIGURATION_Handle *cfg, const char *section, const char *option, char **value)
Get a configuration value that should be the name of a file or directory.
enum GNUNET_GenericReturnValue GNUNET_DISK_file_test(const char *fil)
Check that fil corresponds to a filename (of a file that exists and that is not a directory).
Definition: disk.c:483
enum GNUNET_GenericReturnValue GNUNET_DISK_directory_create_for_file(const char *filename)
Create the directory structure for storing a file.
Definition: disk.c:583
@ GNUNET_OK
@ GNUNET_SYSERR
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur.
void GNUNET_log_config_missing(enum GNUNET_ErrorType kind, const char *section, const char *option)
Log error message about missing configuration option.
@ GNUNET_ERROR_TYPE_ERROR
#define GNUNET_free(ptr)
Wrapper around free.
#define BUSY_TIMEOUT_MS
After how many ms "busy" should a DB operation fail for good? A low value makes sure that we are more...
#define LOG(kind,...)
Information needed to run a list of SQL statements using GNUNET_SQ_exec_statements().
Information needed to run a list of SQL statements using GNUNET_SQ_exec_statements().

References _, BUSY_TIMEOUT_MS, GNUNET_break, GNUNET_CONFIGURATION_get_value_filename(), GNUNET_DISK_directory_create_for_file(), GNUNET_DISK_file_test(), GNUNET_ERROR_TYPE_ERROR, GNUNET_free, GNUNET_log_config_missing(), GNUNET_OK, GNUNET_SQ_exec_statements(), GNUNET_SQ_EXECUTE_STATEMENT_END, GNUNET_SQ_make_execute(), GNUNET_SQ_make_prepare(), GNUNET_SQ_make_try_execute(), GNUNET_SQ_prepare(), GNUNET_SQ_PREPARE_END, GNUNET_SYSERR, LOG, plugin, and ps.

Referenced by libgnunet_plugin_namecache_sqlite_init().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ database_shutdown()

static void database_shutdown ( struct Plugin plugin)
static

Shutdown database connection and associate data structures.

Parameters
pluginthe plugin context (state for this module)

Definition at line 217 of file plugin_namecache_sqlite.c.

218{
219 int result;
220 sqlite3_stmt *stmt;
221
222 if (NULL != plugin->cache_block)
223 sqlite3_finalize (plugin->cache_block);
224 if (NULL != plugin->lookup_block)
225 sqlite3_finalize (plugin->lookup_block);
226 if (NULL != plugin->expire_blocks)
227 sqlite3_finalize (plugin->expire_blocks);
228 if (NULL != plugin->delete_block)
229 sqlite3_finalize (plugin->delete_block);
230 result = sqlite3_close (plugin->dbh);
231 if (result == SQLITE_BUSY)
232 {
234 _ (
235 "Tried to close sqlite without finalizing all prepared statements.\n"));
236 stmt = sqlite3_next_stmt (plugin->dbh,
237 NULL);
238 while (stmt != NULL)
239 {
241 "sqlite",
242 "Closing statement %p\n",
243 stmt);
244 result = sqlite3_finalize (stmt);
245 if (result != SQLITE_OK)
247 "sqlite",
248 "Failed to close statement %p: %d\n",
249 stmt,
250 result);
251 stmt = sqlite3_next_stmt (plugin->dbh,
252 NULL);
253 }
254 result = sqlite3_close (plugin->dbh);
255 }
256 if (SQLITE_OK != result)
259 "sqlite3_close");
260
261 GNUNET_free (plugin->fn);
262}
static int result
Global testing status.
@ GNUNET_ERROR_TYPE_WARNING
@ GNUNET_ERROR_TYPE_DEBUG
#define LOG_SQLITE(db, level, cmd)
Log an error message at log-level 'level' that indicates a failure of the command 'cmd' on file 'file...

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

Referenced by libgnunet_plugin_namecache_sqlite_done(), and libgnunet_plugin_namecache_sqlite_init().

Here is the caller graph for this function:

◆ namecache_sqlite_expire_blocks()

static void namecache_sqlite_expire_blocks ( struct Plugin plugin)
static

Removes any expired block.

Parameters
pluginthe plugin

Definition at line 271 of file plugin_namecache_sqlite.c.

272{
274 struct GNUNET_SQ_QueryParam params[] = {
277 };
278 int n;
279
280 if (GNUNET_OK !=
281 GNUNET_SQ_bind (plugin->expire_blocks,
282 params))
283 {
286 "sqlite3_bind_XXXX");
288 plugin->expire_blocks);
289 return;
290 }
291 n = sqlite3_step (plugin->expire_blocks);
293 plugin->expire_blocks);
294 switch (n)
295 {
296 case SQLITE_DONE:
298 "sqlite",
299 "Records expired\n");
300 return;
301
302 case SQLITE_BUSY:
305 "sqlite3_step");
306 return;
307
308 default:
311 "sqlite3_step");
312 return;
313 }
314}
struct GNUNET_SQ_QueryParam GNUNET_SQ_query_param_absolute_time(const struct GNUNET_TIME_Absolute *x)
Generate query parameter for an absolute time value.
enum GNUNET_GenericReturnValue GNUNET_SQ_bind(sqlite3_stmt *stmt, const struct GNUNET_SQ_QueryParam *params)
Execute binding operations for a prepared statement.
Definition: sq.c:30
void GNUNET_SQ_reset(sqlite3 *dbh, sqlite3_stmt *stmt)
Reset stmt and log error.
Definition: sq.c:119
#define GNUNET_SQ_query_param_end
End of query parameter specification.
Definition: gnunet_sq_lib.h:87
@ GNUNET_ERROR_TYPE_BULK
struct GNUNET_TIME_Absolute GNUNET_TIME_absolute_get(void)
Get the current time.
Definition: time.c:111
Description of a DB query parameter.
Definition: gnunet_sq_lib.h:56
Time for absolute times used by GNUnet, in microseconds.

References GNUNET_ERROR_TYPE_BULK, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_ERROR_TYPE_WARNING, GNUNET_log_from, GNUNET_OK, GNUNET_SQ_bind(), GNUNET_SQ_query_param_absolute_time(), GNUNET_SQ_query_param_end, GNUNET_SQ_reset(), GNUNET_TIME_absolute_get(), LOG_SQLITE, and plugin.

Referenced by namecache_sqlite_cache_block().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ namecache_sqlite_cache_block()

static int namecache_sqlite_cache_block ( void *  cls,
const struct GNUNET_GNSRECORD_Block block 
)
static

Cache a block in the datastore.

Parameters
clsclosure (internal context for the plugin)
blockblock to cache
Returns
GNUNET_OK on success, else GNUNET_SYSERR

Definition at line 325 of file plugin_namecache_sqlite.c.

327{
328 static struct GNUNET_TIME_Absolute last_expire;
329 struct Plugin *plugin = cls;
330 struct GNUNET_HashCode query;
332 size_t block_size = GNUNET_GNSRECORD_block_get_size (block);
333 struct GNUNET_SQ_QueryParam del_params[] = {
337 };
338 struct GNUNET_SQ_QueryParam ins_params[] = {
341 block_size),
344 };
345 int n;
346
347 /* run expiration of old cache entries once per hour */
348 if (GNUNET_TIME_absolute_get_duration (last_expire).rel_value_us >
349 GNUNET_TIME_UNIT_HOURS.rel_value_us)
350 {
351 last_expire = GNUNET_TIME_absolute_get ();
353 }
355 GNUNET_GNSRECORD_query_from_block (block, &query));
358 "Caching new version of block %s (expires %s)\n",
359 GNUNET_h2s (&query),
361 if (block_size > 64 * 65536)
362 {
363 GNUNET_break (0);
364 return GNUNET_SYSERR;
365 }
366
367 /* delete old version of the block */
368 if (GNUNET_OK !=
369 GNUNET_SQ_bind (plugin->delete_block,
370 del_params))
371 {
373 "sqlite3_bind_XXXX");
375 plugin->delete_block);
376 return GNUNET_SYSERR;
377 }
378 n = sqlite3_step (plugin->delete_block);
379 switch (n)
380 {
381 case SQLITE_DONE:
383 "sqlite",
384 "Old block deleted\n");
385 break;
386
387 case SQLITE_BUSY:
390 "sqlite3_step");
391 break;
392
393 default:
396 "sqlite3_step");
397 break;
398 }
400 plugin->delete_block);
401
402 /* insert new version of the block */
403 if (GNUNET_OK !=
404 GNUNET_SQ_bind (plugin->cache_block,
405 ins_params))
406 {
409 "sqlite3_bind_XXXX");
411 plugin->cache_block);
412 return GNUNET_SYSERR;
413 }
415 "Caching block under derived key `%s'\n",
416 GNUNET_h2s_full (&query));
417 n = sqlite3_step (plugin->cache_block);
419 plugin->cache_block);
420 switch (n)
421 {
422 case SQLITE_DONE:
424 "Record stored\n");
425 return GNUNET_OK;
426
427 case SQLITE_BUSY:
430 "sqlite3_step");
431 return GNUNET_NO;
432
433 default:
436 "sqlite3_step");
437 return GNUNET_SYSERR;
438 }
439}
static struct GNUNET_TIME_Relative expiration
User supplied expiration value.
struct GNUNET_SQ_QueryParam GNUNET_SQ_query_param_fixed_size(const void *ptr, size_t ptr_size)
Generate query parameter for a buffer ptr of ptr_size bytes.
#define GNUNET_SQ_query_param_auto_from_type(x)
Generate fixed-size query parameter with size determined by variable type.
size_t GNUNET_GNSRECORD_block_get_size(const struct GNUNET_GNSRECORD_Block *block)
Returns the length of this block in bytes.
enum GNUNET_GenericReturnValue GNUNET_GNSRECORD_query_from_block(const struct GNUNET_GNSRECORD_Block *block, struct GNUNET_HashCode *query)
Builds the query hash from a block.
struct GNUNET_TIME_Absolute GNUNET_GNSRECORD_block_get_expiration(const struct GNUNET_GNSRECORD_Block *block)
Returns the expiration of a block.
#define GNUNET_log(kind,...)
@ GNUNET_NO
const char * GNUNET_h2s_full(const struct GNUNET_HashCode *hc)
Convert a hash value to a string (for printing debug messages).
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
const char * GNUNET_h2s(const struct GNUNET_HashCode *hc)
Convert a hash value to a string (for printing debug messages).
@ GNUNET_ERROR_TYPE_INFO
struct GNUNET_TIME_Relative GNUNET_TIME_absolute_get_duration(struct GNUNET_TIME_Absolute whence)
Get the duration of an operation as the difference of the current time and the given start time "henc...
Definition: time.c:438
#define GNUNET_TIME_UNIT_HOURS
One hour.
const char * GNUNET_STRINGS_absolute_time_to_string(struct GNUNET_TIME_Absolute t)
Like asctime, except for GNUnet time.
Definition: strings.c:640
static void namecache_sqlite_expire_blocks(struct Plugin *plugin)
Removes any expired block.
A 512-bit hashcode.
Handle for a plugin.
Definition: block.c:38

References expiration, GNUNET_assert, GNUNET_break, GNUNET_ERROR_TYPE_BULK, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_ERROR_TYPE_INFO, GNUNET_ERROR_TYPE_WARNING, GNUNET_GNSRECORD_block_get_expiration(), GNUNET_GNSRECORD_block_get_size(), GNUNET_GNSRECORD_query_from_block(), GNUNET_h2s(), GNUNET_h2s_full(), GNUNET_log, GNUNET_log_from, GNUNET_NO, GNUNET_OK, GNUNET_SQ_bind(), GNUNET_SQ_query_param_absolute_time(), GNUNET_SQ_query_param_auto_from_type, GNUNET_SQ_query_param_end, GNUNET_SQ_query_param_fixed_size(), GNUNET_SQ_reset(), GNUNET_STRINGS_absolute_time_to_string(), GNUNET_SYSERR, GNUNET_TIME_absolute_get(), GNUNET_TIME_absolute_get_duration(), GNUNET_TIME_UNIT_HOURS, LOG, LOG_SQLITE, namecache_sqlite_expire_blocks(), and plugin.

Referenced by libgnunet_plugin_namecache_sqlite_init().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ namecache_sqlite_lookup_block()

static int namecache_sqlite_lookup_block ( void *  cls,
const struct GNUNET_HashCode query,
GNUNET_NAMECACHE_BlockCallback  iter,
void *  iter_cls 
)
static

Get the block for a particular zone and label in the datastore.

Will return at most one result to the iterator.

Parameters
clsclosure (internal context for the plugin)
queryhash of public key derived from the zone and the label
iterfunction to call with the result
iter_clsclosure for iter
Returns
GNUNET_OK on success, GNUNET_NO if there were no results, GNUNET_SYSERR on error

Definition at line 453 of file plugin_namecache_sqlite.c.

457{
458 struct Plugin *plugin = cls;
459 int ret;
460 int sret;
461 size_t block_size;
462 const struct GNUNET_GNSRECORD_Block *block;
463 struct GNUNET_SQ_QueryParam params[] = {
466 };
467 struct GNUNET_SQ_ResultSpec rs[] = {
468 GNUNET_SQ_result_spec_variable_size ((void **) &block,
469 &block_size),
471 };
472
473 if (GNUNET_OK !=
474 GNUNET_SQ_bind (plugin->lookup_block,
475 params))
476 {
479 "sqlite3_bind_XXXX");
481 plugin->lookup_block);
482 return GNUNET_SYSERR;
483 }
484 ret = GNUNET_NO;
485 if (SQLITE_ROW ==
486 (sret = sqlite3_step (plugin->lookup_block)))
487 {
488 if (GNUNET_OK !=
489 GNUNET_SQ_extract_result (plugin->lookup_block,
490 rs))
491 {
492 GNUNET_break (0);
494 }
495 else if ((block_size < sizeof(struct GNUNET_GNSRECORD_Block)))
496 {
497 GNUNET_break (0);
500 }
501 else
502 {
504 "Found block under derived key `%s'\n",
505 GNUNET_h2s_full (query));
506 iter (iter_cls,
507 block);
509 ret = GNUNET_YES;
510 }
511 }
512 else
513 {
514 if (SQLITE_DONE != sret)
515 {
518 "sqlite_step");
520 }
521 else
522 {
524 "No block found under derived key `%s'\n",
525 GNUNET_h2s_full (query));
526 }
527 }
529 plugin->lookup_block);
530 return ret;
531}
static int ret
Final status code.
Definition: gnunet-arm.c:93
enum GNUNET_GenericReturnValue GNUNET_SQ_extract_result(sqlite3_stmt *result, struct GNUNET_SQ_ResultSpec *rs)
Extract results from a query result according to the given specification.
Definition: sq.c:75
void GNUNET_SQ_cleanup_result(struct GNUNET_SQ_ResultSpec *rs)
Free all memory that was allocated in rs during GNUNET_SQ_extract_result().
Definition: sq.c:104
#define GNUNET_SQ_result_spec_end
End of result parameter specification.
struct GNUNET_SQ_ResultSpec GNUNET_SQ_result_spec_variable_size(void **dst, size_t *sptr)
Variable-size result expected.
@ GNUNET_YES
Description of a DB result cell.

References GNUNET_break, GNUNET_ERROR_TYPE_BULK, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_h2s_full(), GNUNET_log, GNUNET_NO, GNUNET_OK, GNUNET_SQ_bind(), GNUNET_SQ_cleanup_result(), GNUNET_SQ_extract_result(), GNUNET_SQ_query_param_auto_from_type, GNUNET_SQ_query_param_end, GNUNET_SQ_reset(), GNUNET_SQ_result_spec_end, GNUNET_SQ_result_spec_variable_size(), GNUNET_SYSERR, GNUNET_YES, LOG_SQLITE, plugin, and ret.

Referenced by libgnunet_plugin_namecache_sqlite_init().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ libgnunet_plugin_namecache_sqlite_init()

void * libgnunet_plugin_namecache_sqlite_init ( void *  cls)

Entry point for the plugin.

Parameters
clsthe "struct GNUNET_NAMECACHE_PluginEnvironment*"
Returns
NULL on error, otherwise the plugin context

Definition at line 543 of file plugin_namecache_sqlite.c.

544{
545 static struct Plugin plugin;
546 const struct GNUNET_CONFIGURATION_Handle *cfg = cls;
548
549 if (NULL != plugin.cfg)
550 return NULL; /* can only initialize once! */
551 memset (&plugin, 0, sizeof(struct Plugin));
552 plugin.cfg = cfg;
554 {
556 return NULL;
557 }
559 api->cls = &plugin;
563 _ ("Sqlite database running\n"));
564 return api;
565}
static struct GNUNET_CONFIGURATION_Handle * cfg
Our configuration.
Definition: gnunet-arm.c:108
#define GNUNET_new(type)
Allocate a struct or union of the given type.
static void database_shutdown(struct Plugin *plugin)
Shutdown database connection and associate data structures.
static int namecache_sqlite_cache_block(void *cls, const struct GNUNET_GNSRECORD_Block *block)
Cache a block in the datastore.
static int database_setup(struct Plugin *plugin)
Initialize the database connections and associated data structures (create tables and indices as need...
static int namecache_sqlite_lookup_block(void *cls, const struct GNUNET_HashCode *query, GNUNET_NAMECACHE_BlockCallback iter, void *iter_cls)
Get the block for a particular zone and label in the datastore.
struct returned by the initialization function of the plugin
int(* lookup_block)(void *cls, const struct GNUNET_HashCode *query, GNUNET_NAMECACHE_BlockCallback iter, void *iter_cls)
Get the block for a particular zone and label in the datastore.
int(* cache_block)(void *cls, const struct GNUNET_GNSRECORD_Block *block)
Cache a block in the datastore.
void * cls
Closure to pass to all plugin functions.

References _, GNUNET_NAMECACHE_PluginFunctions::cache_block, cfg, GNUNET_NAMECACHE_PluginFunctions::cls, database_setup(), database_shutdown(), GNUNET_ERROR_TYPE_INFO, GNUNET_new, GNUNET_OK, LOG, GNUNET_NAMECACHE_PluginFunctions::lookup_block, namecache_sqlite_cache_block(), namecache_sqlite_lookup_block(), and plugin.

Here is the call graph for this function:

◆ libgnunet_plugin_namecache_sqlite_done()

void * libgnunet_plugin_namecache_sqlite_done ( void *  cls)

Exit point from the plugin.

Parameters
clsthe plugin context (as returned by "init")
Returns
always NULL

Definition at line 577 of file plugin_namecache_sqlite.c.

578{
580 struct Plugin *plugin = api->cls;
581
583 plugin->cfg = NULL;
586 "sqlite plugin is finished\n");
587 return NULL;
588}
void * cls
Closure for all of the callbacks.
struct GNUNET_BLOCK_PluginFunctions * api
Plugin API.
Definition: block.c:47

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

Here is the call graph for this function: