2 This file is part of GNUnet
3 (C) 2006, 2009 Christian Grothoff (and other contributing authors)
5 GNUnet is free software; you can redistribute it and/or modify
6 it under the terms of the GNU General Public License as published
7 by the Free Software Foundation; either version 2, or (at your
8 option) any later version.
10 GNUnet is distributed in the hope that it will be useful, but
11 WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 General Public License for more details.
15 You should have received a copy of the GNU General Public License
16 along with GNUnet; see the file COPYING. If not, write to the
17 Free Software Foundation, Inc., 59 Temple Place - Suite 330,
18 Boston, MA 02111-1307, USA.
22 * @file datacache/plugin_datacache_sqlite.c
23 * @brief sqlite for an implementation of a database backend for the datacache
24 * @author Christian Grothoff
27 #include "gnunet_util_lib.h"
28 #include "plugin_datacache.h"
31 #define DEBUG_DATACACHE_SQLITE GNUNET_NO
34 * How much overhead do we assume per entry in the
37 #define OVERHEAD (sizeof(GNUNET_HashCode) + 32)
40 * Context for all functions in this plugin.
45 * Our execution environment.
47 struct GNUNET_DATACACHE_PluginEnvironment *env;
50 * Handle to the sqlite database.
55 * Filename used for the DB.
62 * Log an error message at log-level 'level' that indicates
63 * a failure of the command 'cmd' on file 'filename'
64 * with the message given by strerror(errno).
66 #define LOG_SQLITE(db, level, cmd) do { GNUNET_log(level, _("`%s' failed at %s:%d with error: %s\n"), cmd, __FILE__, __LINE__, sqlite3_errmsg(db)); } while(0)
69 #define SQLITE3_EXEC(db, cmd) do { emsg = NULL; if (SQLITE_OK != sqlite3_exec(db, cmd, NULL, NULL, &emsg)) { GNUNET_log(GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK, _("`%s' failed at %s:%d with error: %s\n"), "sqlite3_exec", __FILE__, __LINE__, emsg); sqlite3_free(emsg); } } while(0)
73 * @brief Prepare a SQL statement
76 sq_prepare (sqlite3 * dbh, const char *zSql, /* SQL statement, UTF-8 encoded */
77 sqlite3_stmt ** ppStmt)
78 { /* OUT: Statement handle */
80 return sqlite3_prepare (dbh,
82 strlen (zSql), ppStmt, (const char **) &dummy);
87 * Store an item in the datastore.
89 * @param key key to store data under
90 * @param size number of bytes in data
91 * @param data data to store
92 * @param type type of the value
93 * @param discard_time when to discard the value in any case
94 * @return 0 on error, number of bytes used otherwise
97 sqlite_plugin_put (void *cls,
98 const GNUNET_HashCode * key,
102 struct GNUNET_TIME_Absolute discard_time)
104 struct Plugin *plugin = cls;
107 #if DEBUG_DATACACHE_SQLITE
108 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
109 "Processing `%s' of %u bytes with key `%4s' and expiration %llums\n",
113 (unsigned long long) GNUNET_TIME_absolute_get_remaining (discard_time).value);
115 if (sq_prepare (plugin->dbh,
117 "(type, expire, key, value) "
118 "VALUES (?, ?, ?, ?)", &stmt) != SQLITE_OK)
120 GNUNET_log (GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
121 _("`%s' failed at %s:%d with error: %s\n"),
122 "sq_prepare", __FILE__, __LINE__,
123 sqlite3_errmsg (plugin->dbh));
126 if ( (SQLITE_OK != sqlite3_bind_int (stmt, 1, type)) ||
127 (SQLITE_OK != sqlite3_bind_int64 (stmt, 2, discard_time.value)) ||
128 (SQLITE_OK != sqlite3_bind_blob (stmt, 3, key, sizeof (GNUNET_HashCode),
129 SQLITE_TRANSIENT)) ||
130 (SQLITE_OK != sqlite3_bind_blob (stmt, 4, data, size, SQLITE_TRANSIENT)))
132 LOG_SQLITE (plugin->dbh,
133 GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
135 sqlite3_finalize (stmt);
138 if (SQLITE_DONE != sqlite3_step (stmt))
140 LOG_SQLITE (plugin->dbh,
141 GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
143 sqlite3_finalize (stmt);
146 if (SQLITE_OK != sqlite3_finalize (stmt))
147 LOG_SQLITE (plugin->dbh,
148 GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
150 return size + OVERHEAD;
155 * Iterate over the results for a particular key
159 * @param type entries of which type are relevant?
160 * @param iter maybe NULL (to just count)
161 * @return the number of results found
164 sqlite_plugin_get (void *cls,
165 const GNUNET_HashCode * key,
167 GNUNET_DATACACHE_Iterator iter,
170 struct Plugin *plugin = cls;
172 struct GNUNET_TIME_Absolute now;
180 now = GNUNET_TIME_absolute_get ();
181 #if DEBUG_DATACACHE_SQLITE
182 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
183 "Processing `%s' for key `%4s'\n",
187 if (sq_prepare (plugin->dbh,
188 "SELECT count(*) FROM ds090 WHERE key=? AND type=? AND expire >= ?",
191 GNUNET_log (GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
192 _("`%s' failed at %s:%d with error: %s\n"),
193 "sq_prepare", __FILE__, __LINE__,
194 sqlite3_errmsg (plugin->dbh));
197 sqlite3_bind_blob (stmt, 1, key, sizeof (GNUNET_HashCode),
199 sqlite3_bind_int (stmt, 2, type);
200 sqlite3_bind_int64 (stmt, 3, now.value);
201 if (SQLITE_ROW != sqlite3_step (stmt))
203 LOG_SQLITE (plugin->dbh,
204 GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
206 sqlite3_finalize (stmt);
209 total = sqlite3_column_int (stmt, 0);
210 sqlite3_finalize (stmt);
211 if ( (total == 0) || (iter == NULL) )
215 off = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, total);
218 off = (off + 1) % total;
219 GNUNET_snprintf (scratch,
221 "SELECT value FROM ds090 WHERE key=? AND type=? AND expire >= ? LIMIT 1 OFFSET %u",
223 if (sq_prepare (plugin->dbh, scratch, &stmt) != SQLITE_OK)
225 GNUNET_log (GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
226 _("`%s' failed at %s:%d with error: %s\n"),
227 "sq_prepare", __FILE__, __LINE__,
228 sqlite3_errmsg (plugin->dbh));
231 sqlite3_bind_blob (stmt, 1, key, sizeof (GNUNET_HashCode),
233 sqlite3_bind_int (stmt, 2, type);
234 sqlite3_bind_int64 (stmt, 3, now.value);
235 if (sqlite3_step (stmt) != SQLITE_ROW)
237 size = sqlite3_column_bytes (stmt, 0);
238 dat = sqlite3_column_blob (stmt, 0);
240 if (GNUNET_OK != iter (iter_cls,
246 sqlite3_finalize (stmt);
249 sqlite3_finalize (stmt);
256 * Delete the entry with the lowest expiration value
257 * from the datacache right now.
259 * @return GNUNET_OK on success, GNUNET_SYSERR on error
262 sqlite_plugin_del (void *cls)
264 struct Plugin *plugin = cls;
270 #if DEBUG_DATACACHE_SQLITE
271 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
277 if ((sq_prepare (plugin->dbh,
278 "SELECT type, key, value FROM ds090 ORDER BY expire ASC LIMIT 1",
279 &stmt) != SQLITE_OK) ||
280 (sq_prepare (plugin->dbh,
282 "WHERE key=? AND value=? AND type=?",
283 &dstmt) != SQLITE_OK))
285 GNUNET_log (GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
286 _("`%s' failed at %s:%d with error: %s\n"),
287 "sq_prepare", __FILE__, __LINE__, sqlite3_errmsg (plugin->dbh));
289 sqlite3_finalize (dstmt);
291 sqlite3_finalize (stmt);
292 return GNUNET_SYSERR;
294 if (SQLITE_ROW != sqlite3_step (stmt))
296 GNUNET_log (GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
297 _("`%s' failed at %s:%d with error: %s\n"),
298 "sqlite3_step", __FILE__, __LINE__,
299 sqlite3_errmsg (plugin->dbh));
300 sqlite3_finalize (dstmt);
301 sqlite3_finalize (stmt);
302 return GNUNET_SYSERR;
304 dtype = sqlite3_column_int (stmt, 0);
305 GNUNET_break (sqlite3_column_bytes (stmt, 1) == sizeof (GNUNET_HashCode));
306 dsize = sqlite3_column_bytes (stmt, 2);
307 sqlite3_bind_blob (dstmt,
308 1, sqlite3_column_blob (stmt, 1),
309 sizeof (GNUNET_HashCode),
311 sqlite3_bind_blob (dstmt,
312 2, sqlite3_column_blob (stmt, 2),
315 sqlite3_bind_int (dstmt, 3, dtype);
316 if (sqlite3_step (dstmt) != SQLITE_DONE)
318 GNUNET_log (GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
319 _("`%s' failed at %s:%d with error: %s\n"),
320 "sqlite3_step", __FILE__, __LINE__,
321 sqlite3_errmsg (plugin->dbh));
322 sqlite3_finalize (dstmt);
323 sqlite3_finalize (stmt);
324 return GNUNET_SYSERR;
326 plugin->env->delete_notify (plugin->env->cls,
327 sqlite3_column_blob (stmt, 1),
329 sqlite3_finalize (dstmt);
330 sqlite3_finalize (stmt);
336 * Entry point for the plugin.
339 libgnunet_plugin_datacache_sqlite_init (void *cls)
341 struct GNUNET_DATACACHE_PluginEnvironment *env = cls;
342 struct GNUNET_DATACACHE_PluginFunctions *api;
343 struct Plugin *plugin;
352 tmpdir = getenv ("TMPDIR");
353 tmpdir = tmpdir ? tmpdir : "/tmp";
355 #define TEMPLATE "/gnunet-dstoreXXXXXX"
356 tmpl = GNUNET_malloc (strlen (tmpdir) + sizeof (TEMPLATE) + 1);
357 strcpy (tmpl, tmpdir);
358 strcat (tmpl, TEMPLATE);
361 fn = (char *) GNUNET_malloc (MAX_PATH + 1);
362 plibc_conv_to_win_path (tmpl, fn);
375 fn_utf8 = GNUNET_STRINGS_to_utf8 (fn, strlen (fn),
377 nl_langinfo (CODESET)
379 "UTF-8" /* good luck */
382 if (SQLITE_OK != sqlite3_open (fn_utf8, &dbh))
385 GNUNET_free (fn_utf8);
390 SQLITE3_EXEC (dbh, "PRAGMA temp_store=MEMORY");
391 SQLITE3_EXEC (dbh, "PRAGMA synchronous=OFF");
392 SQLITE3_EXEC (dbh, "PRAGMA count_changes=OFF");
393 SQLITE3_EXEC (dbh, "PRAGMA page_size=4092");
395 "CREATE TABLE ds090 ("
396 " type INTEGER NOT NULL DEFAULT 0,"
397 " expire INTEGER NOT NULL DEFAULT 0,"
398 " key BLOB NOT NULL DEFAULT '',"
399 " value BLOB NOT NULL DEFAULT '')");
400 SQLITE3_EXEC (dbh, "CREATE INDEX idx_hashidx ON ds090 (key,type,expire)");
401 plugin = GNUNET_malloc (sizeof (struct Plugin));
404 plugin->fn = fn_utf8;
405 api = GNUNET_malloc (sizeof (struct GNUNET_DATACACHE_PluginFunctions));
407 api->get = &sqlite_plugin_get;
408 api->put = &sqlite_plugin_put;
409 api->del = &sqlite_plugin_del;
410 GNUNET_log_from (GNUNET_ERROR_TYPE_INFO,
411 "sqlite", _("Sqlite datacache running\n"));
417 * Exit point from the plugin.
420 libgnunet_plugin_datacache_sqlite_done (void *cls)
422 struct GNUNET_DATACACHE_PluginFunctions *api = cls;
423 struct Plugin *plugin = api->cls;
426 GNUNET_free (plugin->fn);
427 sqlite3_close (plugin->dbh);
428 GNUNET_free (plugin);
435 /* end of plugin_datacache_sqlite.c */