2 * This file is part of GNUnet
3 * (C) 2009-2013 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 3, 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 namestore/plugin_namestore_postgres.c
23 * @brief postgres-based namestore backend
24 * @author Christian Grothoff
27 #include "gnunet_namestore_plugin.h"
28 #include "gnunet_namestore_service.h"
29 #include "gnunet_gnsrecord_lib.h"
30 #include "gnunet_postgres_lib.h"
31 #include "namestore.h"
35 * After how many ms "busy" should a DB operation fail for good?
36 * A low value makes sure that we are more responsive to requests
37 * (especially PUTs). A high value guarantees a higher success
38 * rate (SELECTs in iterate can take several seconds despite LIMIT=1).
40 * The default value of 1s should ensure that users do not experience
41 * huge latencies while at the same time allowing operations to succeed
42 * with reasonable probability.
44 #define BUSY_TIMEOUT_MS 1000
48 * Log an error message at log-level 'level' that indicates
49 * a failure of the command 'cmd' on file 'filename'
50 * with the message given by strerror(errno).
52 #define LOG_POSTGRES(db, level, cmd) do { GNUNET_log_from (level, "namestore-postgres", _("`%s' failed at %s:%d with error: %s\n"), cmd, __FILE__, __LINE__, sqlite3_errmsg(db->dbh)); } while(0)
54 #define LOG(kind,...) GNUNET_log_from (kind, "namestore-postgres", __VA_ARGS__)
58 * Context for all functions in this plugin.
63 const struct GNUNET_CONFIGURATION_Handle *cfg;
66 * Native Postgres database handle.
74 * Create our database indices.
76 * @param dbh handle to the database
79 create_indices (PGconn * dbh)
83 GNUNET_POSTGRES_exec (dbh,
84 "CREATE INDEX ir_pkey_reverse ON ns097records (zone_private_key,pkey)")) ||
86 GNUNET_POSTGRES_exec (dbh,
87 "CREATE INDEX ir_pkey_iter ON ns097records (zone_private_key,rvalue)")) ||
89 GNUNET_POSTGRES_exec (dbh, "CREATE INDEX it_iter ON ns097records (rvalue)")) ||
91 GNUNET_POSTGRES_exec (dbh, "CREATE INDEX ir_label ON ns097records (label)")) )
92 LOG (GNUNET_ERROR_TYPE_ERROR,
93 _("Failed to create indices\n"));
98 * Initialize the database connections and associated
99 * data structures (create tables and indices
100 * as needed as well).
102 * @param plugin the plugin context (state for this module)
103 * @return GNUNET_OK on success
106 database_setup (struct Plugin *plugin)
110 plugin->dbh = GNUNET_POSTGRES_connect (plugin->cfg,
111 "namestore-postgres");
112 if (NULL == plugin->dbh)
113 return GNUNET_SYSERR;
115 GNUNET_CONFIGURATION_get_value_yesno (plugin->cfg,
116 "namestore-postgres",
121 "CREATE TEMPORARY TABLE ns097records ("
122 " zone_private_key BYTEA NOT NULL DEFAULT '',"
123 " pkey BYTEA DEFAULT '',"
124 " rvalue BYTEA NOT NULL DEFAULT '',"
125 " record_count INTEGER NOT NULL DEFAULT 0,"
126 " record_data BYTEA NOT NULL DEFAULT '',"
127 " label TEXT NOT NULL DEFAULT ''"
134 "CREATE TABLE ns097records ("
135 " zone_private_key BYTEA NOT NULL DEFAULT '',"
136 " pkey BYTEA DEFAULT '',"
137 " rvalue BYTEA NOT NULL DEFAULT '',"
138 " record_count INTEGER NOT NULL DEFAULT 0,"
139 " record_data BYTEA NOT NULL DEFAULT '',"
140 " label TEXT NOT NULL DEFAULT ''"
143 if ( (NULL == res) ||
144 ((PQresultStatus (res) != PGRES_COMMAND_OK) &&
145 (0 != strcmp ("42P07", /* duplicate table */
148 PG_DIAG_SQLSTATE)))))
150 (void) GNUNET_POSTGRES_check_result (plugin->dbh, res,
151 PGRES_COMMAND_OK, "CREATE TABLE",
153 PQfinish (plugin->dbh);
155 return GNUNET_SYSERR;
157 create_indices (plugin->dbh);
160 GNUNET_POSTGRES_prepare (plugin->dbh,
162 "INSERT INTO ns097records (zone_private_key, pkey, rvalue, record_count, record_data, label) VALUES "
163 "($1, $2, $3, $4, $5, $6)", 6)) ||
165 GNUNET_POSTGRES_prepare (plugin->dbh,
167 "DELETE FROM ns097records WHERE zone_private_key=$1 AND label=$2", 2)) ||
169 GNUNET_POSTGRES_prepare (plugin->dbh,
171 "SELECT record_count,record_data,label FROM ns097records"
172 " WHERE zone_private_key=$1 AND pkey=$2", 2)) ||
174 GNUNET_POSTGRES_prepare (plugin->dbh,
176 "SELECT record_count, record_data, label FROM ns097records"
177 " WHERE zone_private_key=$1 ORDER BY rvalue LIMIT 1 OFFSET $2", 2)) ||
179 GNUNET_POSTGRES_prepare (plugin->dbh,
181 "SELECT record_count,record_data,label,zone_private_key"
182 " FROM ns097records ORDER BY rvalue LIMIT 1 OFFSET $1", 1)) ||
184 GNUNET_POSTGRES_prepare (plugin->dbh,
186 "SELECT record_count,record_data,label,zone_private_key"
187 " FROM ns097records WHERE records zone_private_key=$1 AND label=$2", 2)))
189 PQfinish (plugin->dbh);
191 return GNUNET_SYSERR;
198 * Store a record in the datastore. Removes any existing record in the
199 * same zone with the same name.
201 * @param cls closure (internal context for the plugin)
202 * @param zone_key private key of the zone
203 * @param label name that is being mapped (at most 255 characters long)
204 * @param rd_count number of entries in @a rd array
205 * @param rd array of records with data to store
206 * @return #GNUNET_OK on success, else #GNUNET_SYSERR
209 namestore_postgres_store_records (void *cls,
210 const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone_key,
212 unsigned int rd_count,
213 const struct GNUNET_GNSRECORD_Data *rd)
215 struct Plugin *plugin = cls;
216 struct GNUNET_CRYPTO_EcdsaPublicKey pkey;
218 uint32_t rd_count_nbo = htonl ((uint32_t) rd_count);
222 memset (&pkey, 0, sizeof (pkey));
223 for (i=0;i<rd_count;i++)
224 if (GNUNET_GNSRECORD_TYPE_PKEY == rd[i].record_type)
226 GNUNET_break (sizeof (struct GNUNET_CRYPTO_EcdsaPublicKey) == rd[i].data_size);
232 rvalue = GNUNET_CRYPTO_random_u64 (GNUNET_CRYPTO_QUALITY_WEAK, UINT64_MAX);
233 data_size = GNUNET_GNSRECORD_records_get_size (rd_count, rd);
234 if (data_size > 64 * 65536)
237 return GNUNET_SYSERR;
240 char data[data_size];
241 const char *paramValues[] = {
242 (const char *) zone_key,
243 (const char *) &pkey,
244 (const char *) &rvalue,
245 (const char *) &rd_count_nbo,
249 int paramLengths[] = {
253 sizeof (rd_count_nbo),
257 const int paramFormats[] = { 1, 1, 1, 1, 1, 1 };
260 if (data_size != GNUNET_GNSRECORD_records_serialize (rd_count, rd,
264 return GNUNET_SYSERR;
268 PQexecPrepared (plugin->dbh, "store_records", 6,
269 paramValues, paramLengths, paramFormats, 1);
271 GNUNET_POSTGRES_check_result (plugin->dbh,
276 return GNUNET_SYSERR;
284 * A statement has been run. We should evaluate the result, and if possible
285 * call the given @a iter with the result.
287 * @param plugin plugin context
288 * @param res result from the statement that was run (to be cleaned up)
289 * @param zone_key private key of the zone, could be NULL, in which case we should
290 * get the zone from @a res
291 * @param iter iterator to call with the result
292 * @param iter_cls closure for @a iter
293 * @return #GNUNET_OK on success, #GNUNET_NO if there were no results, #GNUNET_SYSERR on error
296 get_record_and_call_iterator (struct Plugin *plugin,
298 const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone_key,
299 GNUNET_NAMESTORE_RecordIterator iter, void *iter_cls)
303 uint32_t record_count;
309 GNUNET_POSTGRES_check_result (plugin->dbh, res, PGRES_TUPLES_OK,
313 LOG (GNUNET_ERROR_TYPE_DEBUG,
314 "Failing lookup (postgres error)\n");
315 return GNUNET_SYSERR;
317 if (0 == (cnt = PQntuples (res)))
320 LOG (GNUNET_ERROR_TYPE_DEBUG,
321 "Ending iteration (no more results)\n");
325 GNUNET_assert (1 == cnt);
326 GNUNET_assert (3 + ((NULL == zone_key) ? 1 : 0) == PQnfields (res));
327 if (NULL == zone_key)
329 if (sizeof (struct GNUNET_CRYPTO_EcdsaPrivateKey) != PQgetlength (res, 0, 3))
333 return GNUNET_SYSERR;
335 zone_key = (const struct GNUNET_CRYPTO_EcdsaPrivateKey *) PQgetvalue (res, 0, 3);
337 if (sizeof (uint32_t) != PQfsize (res, 0))
341 return GNUNET_SYSERR;
344 record_count = ntohl (*(uint32_t *) PQgetvalue (res, 0, 0));
345 data = PQgetvalue (res, 0, 1);
346 data_size = PQgetlength (res, 0, 1);
347 label = PQgetvalue (res, 0, 2);
348 label_len = PQgetlength (res, 0, 1);
349 if (record_count > 64 * 1024)
351 /* sanity check, don't stack allocate far too much just
352 because database might contain a large value here */
355 return GNUNET_SYSERR;
358 struct GNUNET_GNSRECORD_Data rd[record_count];
359 char buf[label_len + 1];
361 memcpy (buf, label, label_len);
362 buf[label_len] = '\0';
364 GNUNET_GNSRECORD_records_deserialize (data_size, data,
369 return GNUNET_SYSERR;
371 iter (iter_cls, zone_key, buf, record_count, rd);
379 * Lookup records in the datastore for which we are the authority.
381 * @param cls closure (internal context for the plugin)
382 * @param zone private key of the zone
383 * @param label name of the record in the zone
384 * @param iter function to call with the result
385 * @param iter_cls closure for @a iter
386 * @return #GNUNET_OK on success, else #GNUNET_SYSERR
389 namestore_postgres_lookup_records (void *cls,
390 const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone, const char *label,
391 GNUNET_NAMESTORE_RecordIterator iter, void *iter_cls)
393 struct Plugin *plugin = cls;
394 const char *paramValues[] = {
398 int paramLengths[] = {
402 const int paramFormats[] = { 1, 1 };
405 res = PQexecPrepared (plugin->dbh,
407 paramValues, paramLengths, paramFormats,
409 return get_record_and_call_iterator (plugin,
417 * Iterate over the results for a particular key and zone in the
418 * datastore. Will return at most one result to the iterator.
420 * @param cls closure (internal context for the plugin)
421 * @param zone hash of public key of the zone, NULL to iterate over all zones
422 * @param offset offset in the list of all matching records
423 * @param iter function to call with the result
424 * @param iter_cls closure for @a iter
425 * @return #GNUNET_OK on success, #GNUNET_NO if there were no results, #GNUNET_SYSERR on error
428 namestore_postgres_iterate_records (void *cls,
429 const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone,
431 GNUNET_NAMESTORE_RecordIterator iter, void *iter_cls)
433 struct Plugin *plugin = cls;
434 uint64_t offset_be = GNUNET_htonll (offset);
438 const char *paramValues[] = {
439 (const char *) &offset_be
441 int paramLengths[] = {
444 const int paramFormats[] = { 1 };
447 res = PQexecPrepared (plugin->dbh,
448 "iterate_all_zones", 1,
449 paramValues, paramLengths, paramFormats,
451 return get_record_and_call_iterator (plugin,
458 const char *paramValues[] = {
460 (const char *) &offset_be
462 int paramLengths[] = {
466 const int paramFormats[] = { 1, 1 };
469 res = PQexecPrepared (plugin->dbh,
471 paramValues, paramLengths, paramFormats,
473 return get_record_and_call_iterator (plugin,
482 * Look for an existing PKEY delegation record for a given public key.
483 * Returns at most one result to the iterator.
485 * @param cls closure (internal context for the plugin)
486 * @param zone private key of the zone to look up in, never NULL
487 * @param value_zone public key of the target zone (value), never NULL
488 * @param iter function to call with the result
489 * @param iter_cls closure for @a iter
490 * @return #GNUNET_OK on success, #GNUNET_NO if there were no results, #GNUNET_SYSERR on error
493 namestore_postgres_zone_to_name (void *cls,
494 const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone,
495 const struct GNUNET_CRYPTO_EcdsaPublicKey *value_zone,
496 GNUNET_NAMESTORE_RecordIterator iter, void *iter_cls)
498 struct Plugin *plugin = cls;
499 const char *paramValues[] = {
501 (const char *) value_zone
503 int paramLengths[] = {
507 const int paramFormats[] = { 1, 1 };
510 res = PQexecPrepared (plugin->dbh,
512 paramValues, paramLengths, paramFormats,
514 return get_record_and_call_iterator (plugin,
522 * Shutdown database connection and associate data
525 * @param plugin the plugin context (state for this module)
528 database_shutdown (struct Plugin *plugin)
530 PQfinish (plugin->dbh);
536 * Entry point for the plugin.
538 * @param cls the "struct GNUNET_NAMESTORE_PluginEnvironment*"
539 * @return NULL on error, othrewise the plugin context
542 libgnunet_plugin_namestore_postgres_init (void *cls)
544 static struct Plugin plugin;
545 const struct GNUNET_CONFIGURATION_Handle *cfg = cls;
546 struct GNUNET_NAMESTORE_PluginFunctions *api;
548 if (NULL != plugin.cfg)
549 return NULL; /* can only initialize once! */
550 memset (&plugin, 0, sizeof (struct Plugin));
552 if (GNUNET_OK != database_setup (&plugin))
554 database_shutdown (&plugin);
557 api = GNUNET_new (struct GNUNET_NAMESTORE_PluginFunctions);
559 api->store_records = &namestore_postgres_store_records;
560 api->iterate_records = &namestore_postgres_iterate_records;
561 api->zone_to_name = &namestore_postgres_zone_to_name;
562 api->lookup_records = &namestore_postgres_lookup_records;
563 LOG (GNUNET_ERROR_TYPE_INFO,
564 _("Postgres database running\n"));
570 * Exit point from the plugin.
572 * @param cls the plugin context (as returned by "init")
573 * @return always NULL
576 libgnunet_plugin_namestore_postgres_done (void *cls)
578 struct GNUNET_NAMESTORE_PluginFunctions *api = cls;
579 struct Plugin *plugin = api->cls;
581 database_shutdown (plugin);
584 LOG (GNUNET_ERROR_TYPE_DEBUG,
585 "postgres plugin is finished\n");
589 /* end of plugin_namestore_postgres.c */