GNUnet  0.19.2
plugin_datastore_postgres.c
Go to the documentation of this file.
1 /*
2  This file is part of GNUnet
3  Copyright (C) 2009-2017, 2022 GNUnet e.V.
4 
5  GNUnet is free software: you can redistribute it and/or modify it
6  under the terms of the GNU Affero General Public License as published
7  by the Free Software Foundation, either version 3 of the License,
8  or (at your option) any later version.
9 
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  Affero General Public License for more details.
14 
15  You should have received a copy of the GNU Affero General Public License
16  along with this program. If not, see <http://www.gnu.org/licenses/>.
17 
18  SPDX-License-Identifier: AGPL3.0-or-later
19  */
20 
26 #include "platform.h"
28 #include "gnunet_pq_lib.h"
29 
30 
41 #define BUSY_TIMEOUT GNUNET_TIME_UNIT_SECONDS
42 
43 
47 struct Plugin
48 {
53 
57  struct GNUNET_PQ_Context *dbh;
58 };
59 
60 
67 static enum GNUNET_GenericReturnValue
69 {
70 #define RESULT_COLUMNS "repl, type, prio, anonLevel, expire, hash, value, oid"
71  struct GNUNET_PQ_PreparedStatement ps[] = {
73  "SELECT " RESULT_COLUMNS
74  " FROM datastore.gn090"
75  " WHERE oid >= $1::bigint AND"
76  " (rvalue >= $2 OR 0 = $3::smallint) AND"
77  " (hash = $4 OR 0 = $5::smallint) AND"
78  " (type = $6 OR 0 = $7::smallint)"
79  " ORDER BY oid ASC LIMIT 1"),
81  "INSERT INTO datastore.gn090"
82  " (repl, type, prio, anonLevel, expire, rvalue, hash, vhash, value) "
83  "VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9)"),
84  GNUNET_PQ_make_prepare ("update",
85  "UPDATE datastore.gn090"
86  " SET prio = prio + $1,"
87  " repl = repl + $2,"
88  " expire = GREATEST(expire, $3)"
89  " WHERE hash = $4 AND vhash = $5"),
90  GNUNET_PQ_make_prepare ("decrepl",
91  "UPDATE datastore.gn090"
92  " SET repl = GREATEST (repl - 1, 0)"
93  " WHERE oid = $1"),
94  GNUNET_PQ_make_prepare ("select_non_anonymous",
95  "SELECT " RESULT_COLUMNS
96  " FROM datastore.gn090"
97  " WHERE anonLevel = 0 AND type = $1 AND oid >= $2::bigint"
98  " ORDER BY oid ASC LIMIT 1"),
99  GNUNET_PQ_make_prepare ("select_expiration_order",
100  "(SELECT " RESULT_COLUMNS
101  " FROM datastore.gn090"
102  " WHERE expire < $1 ORDER BY prio ASC LIMIT 1) "
103  "UNION "
104  "(SELECT " RESULT_COLUMNS
105  " FROM datastore.gn090"
106  " ORDER BY prio ASC LIMIT 1)"
107  " ORDER BY expire ASC LIMIT 1"),
108  GNUNET_PQ_make_prepare ("select_replication_order",
109  "SELECT " RESULT_COLUMNS
110  " FROM datastore.gn090"
111  " ORDER BY repl DESC,RANDOM() LIMIT 1"),
112  GNUNET_PQ_make_prepare ("delrow",
113  "DELETE FROM datastore.gn090"
114  " WHERE oid=$1"),
115  GNUNET_PQ_make_prepare ("remove",
116  "DELETE FROM datastore.gn090"
117  " WHERE hash = $1 AND"
118  " value = $2"),
119  GNUNET_PQ_make_prepare ("get_keys",
120  "SELECT hash"
121  " FROM datastore.gn090"),
122  GNUNET_PQ_make_prepare ("estimate_size",
123  "SELECT CASE WHEN NOT EXISTS"
124  " (SELECT 1 FROM datastore.gn090)"
125  " THEN 0"
126  " ELSE (SELECT SUM(LENGTH(value))+256*COUNT(*)"
127  " FROM datastore.gn090)"
128  "END AS total"),
130  };
131 #undef RESULT_COLUMNS
132 
133  plugin->dbh = GNUNET_PQ_connect_with_cfg (plugin->env->cfg,
134  "datastore-postgres",
135  "datastore-",
136  NULL,
137  ps);
138  if (NULL == plugin->dbh)
139  return GNUNET_SYSERR;
140  return GNUNET_OK;
141 }
142 
143 
151 static void
153  unsigned long long *estimate)
154 {
155  struct Plugin *plugin = cls;
156  uint64_t total;
157  struct GNUNET_PQ_QueryParam params[] = {
159  };
160  struct GNUNET_PQ_ResultSpec rs[] = {
162  &total),
164  };
166 
167  if (NULL == estimate)
168  return;
170  "estimate_size",
171  params,
172  rs);
174  {
175  *estimate = 0LL;
176  return;
177  }
178  *estimate = total;
179 }
180 
181 
198 static void
200  const struct GNUNET_HashCode *key,
201  bool absent,
202  uint32_t size,
203  const void *data,
204  enum GNUNET_BLOCK_Type type,
205  uint32_t priority,
206  uint32_t anonymity,
207  uint32_t replication,
209  PluginPutCont cont,
210  void *cont_cls)
211 {
212  struct Plugin *plugin = cls;
213  struct GNUNET_HashCode vhash;
215 
217  size,
218  &vhash);
219  if (! absent)
220  {
221  struct GNUNET_PQ_QueryParam params[] = {
222  GNUNET_PQ_query_param_uint32 (&priority),
228  };
230  "update",
231  params);
232  if (0 > ret)
233  {
234  cont (cont_cls,
235  key,
236  size,
238  _ ("Postgresql exec failure"));
239  return;
240  }
241  bool affected = (0 != ret);
242  if (affected)
243  {
244  cont (cont_cls,
245  key,
246  size,
247  GNUNET_NO,
248  NULL);
249  return;
250  }
251  }
252 
253  {
254  uint32_t utype = (uint32_t) type;
256  UINT64_MAX);
257  struct GNUNET_PQ_QueryParam params[] = {
260  GNUNET_PQ_query_param_uint32 (&priority),
268  };
269 
271  "put",
272  params);
273  if (0 > ret)
274  {
275  cont (cont_cls,
276  key,
277  size,
279  "Postgresql exec failure");
280  return;
281  }
282  }
283  plugin->env->duc (plugin->env->cls,
286  "datastore-postgres",
287  "Stored %u bytes in database\n",
288  (unsigned int) size);
289  cont (cont_cls,
290  key,
291  size,
292  GNUNET_OK,
293  NULL);
294 }
295 
296 
301 {
305  struct Plugin *plugin;
306 
311 
315  void *proc_cls;
316 };
317 
318 
327 static void
328 process_result (void *cls,
329  PGresult *res,
330  unsigned int num_results)
331 {
332  struct ProcessResultContext *prc = cls;
333  struct Plugin *plugin = prc->plugin;
334 
335  if (0 == num_results)
336  {
337  /* no result */
339  "datastore-postgres",
340  "Ending iteration (no more results)\n");
341  prc->proc (prc->proc_cls, NULL, 0, NULL, 0, 0, 0, 0,
343  return;
344  }
345  if (1 != num_results)
346  {
347  GNUNET_break (0);
348  prc->proc (prc->proc_cls, NULL, 0, NULL, 0, 0, 0, 0,
350  return;
351  }
352  /* Technically we don't need the loop here, but nicer in case
353  we ever relax the condition above. */
354  for (unsigned int i = 0; i < num_results; i++)
355  {
356  int iret;
357  uint64_t rowid;
358  uint32_t utype;
359  uint32_t anonymity;
360  uint32_t replication;
361  uint32_t priority;
362  size_t size;
363  void *data;
364  struct GNUNET_TIME_Absolute expiration_time;
365  struct GNUNET_HashCode key;
366  struct GNUNET_PQ_ResultSpec rs[] = {
368  GNUNET_PQ_result_spec_uint32 ("type", &utype),
369  GNUNET_PQ_result_spec_uint32 ("prio", &priority),
370  GNUNET_PQ_result_spec_uint32 ("anonLevel", &anonymity),
371  GNUNET_PQ_result_spec_absolute_time ("expire", &expiration_time),
374  GNUNET_PQ_result_spec_uint64 ("oid", &rowid),
376  };
377 
378  if (GNUNET_OK !=
380  rs,
381  i))
382  {
383  GNUNET_break (0);
384  prc->proc (prc->proc_cls, NULL, 0, NULL, 0, 0, 0, 0,
386  return;
387  }
388 
390  "datastore-postgres",
391  "Found result of size %u bytes and type %u in database\n",
392  (unsigned int) size,
393  (unsigned int) utype);
394  iret = prc->proc (prc->proc_cls,
395  &key,
396  size,
397  data,
398  (enum GNUNET_BLOCK_Type) utype,
399  priority,
400  anonymity,
401  replication,
402  expiration_time,
403  rowid);
404  if (iret == GNUNET_NO)
405  {
406  struct GNUNET_PQ_QueryParam param[] = {
409  };
410 
412  "Processor asked for item %u to be removed.\n",
413  (unsigned int) rowid);
414  if (0 <
416  "delrow",
417  param))
418  {
420  "datastore-postgres",
421  "Deleting %u bytes from database\n",
422  (unsigned int) size);
423  plugin->env->duc (plugin->env->cls,
426  "datastore-postgres",
427  "Deleted %u bytes from database\n",
428  (unsigned int) size);
429  }
430  }
432  } /* for (i) */
433 }
434 
435 
449 static void
451  uint64_t next_uid,
452  bool random,
453  const struct GNUNET_HashCode *key,
454  enum GNUNET_BLOCK_Type type,
456  void *proc_cls)
457 {
458  struct Plugin *plugin = cls;
459  uint32_t utype = type;
460  uint16_t use_rvalue = random;
461  uint16_t use_key = NULL != key;
462  uint16_t use_type = GNUNET_BLOCK_TYPE_ANY != type;
463  uint64_t rvalue;
464  struct GNUNET_PQ_QueryParam params[] = {
465  GNUNET_PQ_query_param_uint64 (&next_uid),
467  GNUNET_PQ_query_param_uint16 (&use_rvalue),
469  GNUNET_PQ_query_param_uint16 (&use_key),
471  GNUNET_PQ_query_param_uint16 (&use_type),
473  };
474  struct ProcessResultContext prc;
476 
477  if (random)
478  {
480  UINT64_MAX);
481  next_uid = 0;
482  }
483  else
484  {
485  rvalue = 0;
486  }
487  prc.plugin = plugin;
488  prc.proc = proc;
489  prc.proc_cls = proc_cls;
490 
492  "get",
493  params,
495  &prc);
496  if (0 > res)
497  proc (proc_cls, NULL, 0, NULL, 0, 0, 0, 0,
499 }
500 
501 
514 static void
516  uint64_t next_uid,
517  enum GNUNET_BLOCK_Type type,
519  void *proc_cls)
520 {
521  struct Plugin *plugin = cls;
522  uint32_t utype = type;
523  struct GNUNET_PQ_QueryParam params[] = {
525  GNUNET_PQ_query_param_uint64 (&next_uid),
527  };
528  struct ProcessResultContext prc;
530 
531  prc.plugin = plugin;
532  prc.proc = proc;
533  prc.proc_cls = proc_cls;
535  "select_non_anonymous",
536  params,
538  &prc);
539  if (0 > res)
540  proc (proc_cls, NULL, 0, NULL, 0, 0, 0, 0,
542 }
543 
544 
548 struct ReplCtx
549 {
553  struct Plugin *plugin;
554 
559 
563  void *proc_cls;
564 };
565 
566 
588 static int
589 repl_proc (void *cls,
590  const struct GNUNET_HashCode *key,
591  uint32_t size,
592  const void *data,
593  enum GNUNET_BLOCK_Type type,
594  uint32_t priority,
595  uint32_t anonymity,
596  uint32_t replication,
598  uint64_t uid)
599 {
600  struct ReplCtx *rc = cls;
601  struct Plugin *plugin = rc->plugin;
602  int ret;
603  struct GNUNET_PQ_QueryParam params[] = {
606  };
607  enum GNUNET_DB_QueryStatus qret;
608 
609  ret = rc->proc (rc->proc_cls,
610  key,
611  size,
612  data,
613  type,
614  priority,
615  anonymity,
616  replication,
617  expiration,
618  uid);
619  if (NULL == key)
620  return ret;
622  "decrepl",
623  params);
624  if (0 > qret)
625  return GNUNET_SYSERR;
626  return ret;
627 }
628 
629 
641 static void
644  void *proc_cls)
645 {
646  struct Plugin *plugin = cls;
647  struct GNUNET_PQ_QueryParam params[] = {
649  };
650  struct ReplCtx rc;
651  struct ProcessResultContext prc;
653 
654  rc.plugin = plugin;
655  rc.proc = proc;
656  rc.proc_cls = proc_cls;
657  prc.plugin = plugin;
658  prc.proc = &repl_proc;
659  prc.proc_cls = &rc;
661  "select_replication_order",
662  params,
664  &prc);
665  if (0 > res)
666  proc (proc_cls, NULL, 0, NULL, 0, 0, 0, 0,
668 }
669 
670 
679 static void
682  void *proc_cls)
683 {
684  struct Plugin *plugin = cls;
685  struct GNUNET_TIME_Absolute now = { 0 };
686  struct GNUNET_PQ_QueryParam params[] = {
689  };
690  struct ProcessResultContext prc;
691 
692  now = GNUNET_TIME_absolute_get ();
693  prc.plugin = plugin;
694  prc.proc = proc;
695  prc.proc_cls = proc_cls;
697  "select_expiration_order",
698  params,
700  &prc);
701 }
702 
703 
708 {
713 
717  void *proc_cls;
718 };
719 
720 
729 static void
730 process_keys (void *cls,
731  PGresult *result,
732  unsigned int num_results)
733 {
734  struct ProcessKeysContext *pkc = cls;
735 
736  for (unsigned i = 0; i < num_results; i++)
737  {
738  struct GNUNET_HashCode key;
739  struct GNUNET_PQ_ResultSpec rs[] = {
741  &key),
743  };
744 
745  if (GNUNET_OK !=
747  rs,
748  i))
749  {
750  GNUNET_break (0);
751  continue;
752  }
753  pkc->proc (pkc->proc_cls,
754  &key,
755  1);
757  }
758 }
759 
760 
768 static void
770  PluginKeyProcessor proc,
771  void *proc_cls)
772 {
773  struct Plugin *plugin = cls;
774  struct GNUNET_PQ_QueryParam params[] = {
776  };
777  struct ProcessKeysContext pkc;
778 
779  pkc.proc = proc;
780  pkc.proc_cls = proc_cls;
782  "get_keys",
783  params,
784  &process_keys,
785  &pkc);
786  proc (proc_cls,
787  NULL,
788  0);
789 }
790 
791 
797 static void
799 {
800  struct Plugin *plugin = cls;
801  struct GNUNET_PQ_ExecuteStatement es[] = {
802  GNUNET_PQ_make_execute ("DROP TABLE gn090"),
804  };
805 
806  if (GNUNET_OK !=
808  es))
810  "postgres",
811  _ ("Failed to drop table from database.\n"));
812 }
813 
814 
825 static void
827  const struct GNUNET_HashCode *key,
828  uint32_t size,
829  const void *data,
830  PluginRemoveCont cont,
831  void *cont_cls)
832 {
833  struct Plugin *plugin = cls;
835  struct GNUNET_PQ_QueryParam params[] = {
839  };
840 
842  "remove",
843  params);
844  if (0 > ret)
845  {
846  cont (cont_cls,
847  key,
848  size,
850  _ ("Postgresql exec failure"));
851  return;
852  }
854  {
855  cont (cont_cls,
856  key,
857  size,
858  GNUNET_NO,
859  NULL);
860  return;
861  }
862  plugin->env->duc (plugin->env->cls,
865  "datastore-postgres",
866  "Deleted %u bytes from database\n",
867  (unsigned int) size);
868  cont (cont_cls,
869  key,
870  size,
871  GNUNET_OK,
872  NULL);
873 }
874 
875 
882 void *
884 {
887  struct Plugin *plugin;
888 
889  plugin = GNUNET_new (struct Plugin);
890  plugin->env = env;
892  {
894  return NULL;
895  }
897  api->cls = plugin;
898  api->estimate_size = &postgres_plugin_estimate_size;
899  api->put = &postgres_plugin_put;
901  api->get_replication = &postgres_plugin_get_replication;
902  api->get_expiration = &postgres_plugin_get_expiration;
903  api->get_zero_anonymity = &postgres_plugin_get_zero_anonymity;
904  api->get_keys = &postgres_plugin_get_keys;
905  api->drop = &postgres_plugin_drop;
906  api->remove_key = &postgres_plugin_remove_key;
907  return api;
908 }
909 
910 
917 void *
919 {
921  struct Plugin *plugin = api->cls;
922 
925  GNUNET_free (api);
926  return NULL;
927 }
928 
929 
930 /* end of plugin_datastore_postgres.c */
struct GNUNET_MQ_Envelope * env
Definition: 005.c:1
GNUNET_BLOCK_Type
WARNING: This header is generated! In order to add DHT block types, you must register them in GANA,...
@ GNUNET_BLOCK_TYPE_ANY
Identifier for any block.
static char * expiration
Credential TTL.
Definition: gnunet-abd.c:96
static int ret
Return value of the commandline.
Definition: gnunet-abd.c:81
static int res
struct TestcasePlugin * plugin
The process handle to the testbed service.
static unsigned int replication
struct GNUNET_HashCode key
The key used in the DHT.
static unsigned int anonymity
uint32_t data
The data value.
static int result
Global testing status.
API for the database backend plugins.
GNUNET_DB_QueryStatus
Status code returned from functions running database commands.
Definition: gnunet_db_lib.h:37
@ GNUNET_DB_STATUS_SUCCESS_ONE_RESULT
The transaction succeeded, and yielded one result.
Definition: gnunet_db_lib.h:60
@ GNUNET_DB_STATUS_SUCCESS_NO_RESULTS
The transaction succeeded, but yielded zero results.
Definition: gnunet_db_lib.h:55
helper functions for Postgres DB interactions
struct GNUNET_PQ_QueryParam GNUNET_PQ_query_param_fixed_size(const void *ptr, size_t ptr_size)
Generate query parameter for a buffer ptr of ptr_size bytes.
struct GNUNET_PQ_QueryParam GNUNET_PQ_query_param_uint64(const uint64_t *x)
Generate query parameter for an uint16_t in host byte order.
#define GNUNET_PQ_query_param_auto_from_type(x)
Generate fixed-size query parameter with size determined by variable type.
enum GNUNET_DB_QueryStatus GNUNET_PQ_eval_prepared_multi_select(struct GNUNET_PQ_Context *db, const char *statement_name, const struct GNUNET_PQ_QueryParam *params, GNUNET_PQ_PostgresResultHandler rh, void *rh_cls)
Execute a named prepared statement that is a SELECT statement which may return multiple results in co...
Definition: pq_eval.c:209
struct GNUNET_PQ_ResultSpec GNUNET_PQ_result_spec_uint32(const char *name, uint32_t *u32)
uint32_t expected.
enum GNUNET_DB_QueryStatus GNUNET_PQ_eval_prepared_singleton_select(struct GNUNET_PQ_Context *db, const char *statement_name, const struct GNUNET_PQ_QueryParam *params, struct GNUNET_PQ_ResultSpec *rs)
Execute a named prepared statement that is a SELECT statement which must return a single result in co...
Definition: pq_eval.c:258
struct GNUNET_PQ_ExecuteStatement GNUNET_PQ_make_execute(const char *sql)
Create a struct GNUNET_PQ_ExecuteStatement where errors are fatal.
Definition: pq_exec.c:36
struct GNUNET_PQ_QueryParam GNUNET_PQ_query_param_absolute_time(const struct GNUNET_TIME_Absolute *x)
Generate query parameter for an absolute time value.
struct GNUNET_PQ_QueryParam GNUNET_PQ_query_param_uint16(const uint16_t *x)
Generate query parameter for an uint16_t in host byte order.
#define GNUNET_PQ_result_spec_auto_from_type(name, dst)
We expect a fixed-size result, with size determined by the type of * dst
enum GNUNET_GenericReturnValue GNUNET_PQ_exec_statements(struct GNUNET_PQ_Context *db, const struct GNUNET_PQ_ExecuteStatement *es)
Request execution of an array of statements es from Postgres.
Definition: pq_exec.c:67
struct GNUNET_PQ_ResultSpec GNUNET_PQ_result_spec_uint64(const char *name, uint64_t *u64)
uint64_t expected.
void GNUNET_PQ_disconnect(struct GNUNET_PQ_Context *db)
Disconnect from the database, destroying the prepared statements and releasing other associated resou...
Definition: pq_connect.c:542
struct GNUNET_PQ_ResultSpec GNUNET_PQ_result_spec_absolute_time(const char *name, struct GNUNET_TIME_Absolute *at)
Absolute time expected.
struct GNUNET_PQ_Context * GNUNET_PQ_connect_with_cfg(const struct GNUNET_CONFIGURATION_Handle *cfg, const char *section, const char *load_path_suffix, const struct GNUNET_PQ_ExecuteStatement *es, const struct GNUNET_PQ_PreparedStatement *ps)
Connect to a postgres database using the configuration option "CONFIG" in section.
Definition: pq_connect.c:477
struct GNUNET_PQ_PreparedStatement GNUNET_PQ_make_prepare(const char *name, const char *sql)
Create a struct GNUNET_PQ_PreparedStatement.
Definition: pq_prepare.c:30
#define GNUNET_PQ_query_param_end
End of query parameter specification.
Definition: gnunet_pq_lib.h:98
struct GNUNET_PQ_QueryParam GNUNET_PQ_query_param_uint32(const uint32_t *x)
Generate query parameter for an uint32_t in host byte order.
struct GNUNET_PQ_ResultSpec GNUNET_PQ_result_spec_variable_size(const char *name, void **dst, size_t *sptr)
Variable-size result expected.
void GNUNET_PQ_cleanup_result(struct GNUNET_PQ_ResultSpec *rs)
Free all memory that was allocated in rs during GNUNET_PQ_extract_result().
Definition: pq.c:122
#define GNUNET_PQ_PREPARED_STATEMENT_END
Terminator for prepared statement list.
enum GNUNET_GenericReturnValue GNUNET_PQ_extract_result(PGresult *result, struct GNUNET_PQ_ResultSpec *rs, int row)
Extract results from a query result according to the given specification.
Definition: pq.c:132
#define GNUNET_PQ_EXECUTE_STATEMENT_END
Terminator for executable statement list.
enum GNUNET_DB_QueryStatus GNUNET_PQ_eval_prepared_non_select(struct GNUNET_PQ_Context *db, const char *statement_name, const struct GNUNET_PQ_QueryParam *params)
Execute a named prepared statement that is NOT a SELECT statement in connection using the given param...
Definition: pq_eval.c:164
#define GNUNET_PQ_result_spec_end
End of result parameter specification.
uint64_t GNUNET_CRYPTO_random_u64(enum GNUNET_CRYPTO_Quality mode, uint64_t max)
Generate a random unsigned 64-bit value.
@ GNUNET_CRYPTO_QUALITY_WEAK
No good quality of the operation is needed (i.e., random numbers can be pseudo-random).
enum GNUNET_GenericReturnValue(* PluginDatumProcessor)(void *cls, const struct 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, uint64_t uid)
An processor over a set of items stored in the datastore.
void(* PluginPutCont)(void *cls, const struct GNUNET_HashCode *key, uint32_t size, int status, const char *msg)
Put continuation.
#define GNUNET_DATASTORE_ENTRY_OVERHEAD
How many bytes of overhead will we assume per entry in any DB (for reservations)?
void(* PluginKeyProcessor)(void *cls, const struct GNUNET_HashCode *key, unsigned int count)
An processor over a set of keys stored in the datastore.
void(* PluginRemoveCont)(void *cls, const struct GNUNET_HashCode *key, uint32_t size, int status, const char *msg)
Remove continuation.
void GNUNET_CRYPTO_hash(const void *block, size_t size, struct GNUNET_HashCode *ret)
Compute hash of a given block.
Definition: crypto_hash.c:41
#define GNUNET_log(kind,...)
#define GNUNET_log_from(kind, comp,...)
GNUNET_GenericReturnValue
Named constants for return values.
@ GNUNET_OK
@ GNUNET_NO
@ GNUNET_SYSERR
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur.
@ GNUNET_ERROR_TYPE_WARNING
@ GNUNET_ERROR_TYPE_DEBUG
#define GNUNET_new(type)
Allocate a struct or union of the given type.
#define GNUNET_free(ptr)
Wrapper around free.
struct GNUNET_TIME_Absolute GNUNET_TIME_absolute_get(void)
Get the current time.
Definition: time.c:111
#define GNUNET_TIME_UNIT_ZERO_ABS
Absolute time zero.
static unsigned int size
Size of the "table".
Definition: peer.c:68
#define _(String)
GNU gettext support macro.
Definition: platform.h:177
static void postgres_plugin_get_replication(void *cls, PluginDatumProcessor proc, void *proc_cls)
Get a random item for replication.
static void postgres_plugin_estimate_size(void *cls, unsigned long long *estimate)
Get an estimate of how much space the database is currently using.
static int repl_proc(void *cls, const struct 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, uint64_t uid)
Wrapper for the iterator for 'sqlite_plugin_replication_get'.
static void postgres_plugin_drop(void *cls)
Drop database.
static void process_result(void *cls, PGresult *res, unsigned int num_results)
Function invoked to process the result and call the processor of cls.
#define RESULT_COLUMNS
void * libgnunet_plugin_datastore_postgres_done(void *cls)
Exit point from the plugin.
static void postgres_plugin_get_key(void *cls, uint64_t next_uid, bool random, const struct GNUNET_HashCode *key, enum GNUNET_BLOCK_Type type, PluginDatumProcessor proc, void *proc_cls)
Get one of the results for a particular key in the datastore.
static void postgres_plugin_get_zero_anonymity(void *cls, uint64_t next_uid, enum GNUNET_BLOCK_Type type, PluginDatumProcessor proc, void *proc_cls)
Select a subset of the items in the datastore and call the given iterator for each of them.
static enum GNUNET_GenericReturnValue init_connection(struct Plugin *plugin)
Get a database handle.
static void postgres_plugin_remove_key(void *cls, const struct GNUNET_HashCode *key, uint32_t size, const void *data, PluginRemoveCont cont, void *cont_cls)
Remove a particular key in the datastore.
void * libgnunet_plugin_datastore_postgres_init(void *cls)
Entry point for the plugin.
static void postgres_plugin_get_expiration(void *cls, PluginDatumProcessor proc, void *proc_cls)
Get a random item for expiration.
static void process_keys(void *cls, PGresult *result, unsigned int num_results)
Function to be called with the results of a SELECT statement that has returned num_results results.
static void postgres_plugin_get_keys(void *cls, PluginKeyProcessor proc, void *proc_cls)
Get all of the keys in the datastore.
static void postgres_plugin_put(void *cls, const struct GNUNET_HashCode *key, bool absent, 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, PluginPutCont cont, void *cont_cls)
Store an item in the datastore.
GNUNET_BLOCK_GetKeyFunction get_key
Obtain the key for a given block (if possible).
void * cls
Closure for all of the callbacks.
The datastore service will pass a pointer to a struct of this type as the first and only argument to ...
Each plugin is required to return a pointer to a struct of this type as the return value from its ent...
void * cls
Closure to use for all of the following callbacks (except "next_request").
A 512-bit hashcode.
Handle to Postgres database.
Definition: pq.h:36
Information needed to run a list of SQL statements using GNUNET_PQ_exec_statements().
Information needed to prepare a list of SQL statements using GNUNET_PQ_prepare_statements().
Description of a DB query parameter.
Definition: gnunet_pq_lib.h:66
Description of a DB result cell.
void * cls
Closure for conv and cleaner.
Time for absolute times used by GNUnet, in microseconds.
Handle for a plugin.
Definition: block.c:38
struct GNUNET_BLOCK_PluginFunctions * api
Plugin API.
Definition: block.c:47
struct GNUNET_DATACACHE_PluginEnvironment * env
Our execution environment.
struct GNUNET_PQ_Context * dbh
Native Postgres database handle.
Closure for process_keys.
PluginKeyProcessor proc
Function to call for each key.
void * proc_cls
Closure for proc.
Closure for process_result.
struct Plugin * plugin
The plugin handle.
void * proc_cls
Closure for proc.
PluginDatumProcessor proc
Function to call on each result.
Context for repl_proc() function.
void * proc_cls
Closure for proc.
PluginDatumProcessor proc
Function to call for the result (or the NULL).
struct Plugin * plugin
Plugin handle.
enum GNUNET_TESTBED_UnderlayLinkModelType type
the type of this model