GNUnet debian-0.24.3-29-g453fda2cf
 
Loading...
Searching...
No Matches
gnunet_pq_lib.h
Go to the documentation of this file.
1/*
2 This file is part of GNUnet
3 Copyright (C) 2016, 2017, 2020-2022 GNUnet e.V.
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 */
25#ifndef GNUNET_PQ_LIB_H
26#define GNUNET_PQ_LIB_H
27
28
29#include <libpq-fe.h>
30#include <stdint.h>
31#include "gnunet_common.h"
32#include "gnunet_time_lib.h"
33#include "gnunet_util_lib.h"
34#include "gnunet_db_lib.h"
35#include "postgres_ext.h"
36
41
42/* ************************* pq_query_helper.c functions ************************ */
43
44
59typedef int
60(*GNUNET_PQ_QueryConverter) (void *cls,
61 const void *data,
62 size_t data_len,
63 void *param_values[],
64 int param_lengths[],
65 int param_formats[],
66 unsigned int param_length,
67 void *scratch[],
68 unsigned int scratch_length);
69
76typedef void
78
120
127void
129 const struct GNUNET_PQ_QueryParam *params);
130
134#define GNUNET_PQ_query_param_end \
135 { \
136 .conv = NULL, \
137 .conv_cls = NULL, \
138 .data = NULL, \
139 .size = 0, \
140 .num_params = 0 \
141 }
142
143
151
152
162GNUNET_PQ_query_param_fixed_size (const void *ptr,
163 size_t ptr_size);
164
165
173GNUNET_PQ_query_param_string (const char *ptr);
174
175
184
195 struct GNUNET_PQ_Context *db,
196 const char *name,
197 Oid *oid);
198
199
208{
209 uint32_t ndim; /* number of dimensions. we only support ndim = 1 */
210 uint32_t has_null;
211 uint32_t oid; /* oid of the elements */
212 uint32_t dim; /* size of the array */
213 uint32_t lbound; /* index value of first element in the db (default: 1). */
214} __attribute__((packed));
215
216
227 unsigned int num,
228 const bool *elements,
229 struct GNUNET_PQ_Context *db);
230
242 unsigned int num,
243 const uint16_t *elements,
244 struct GNUNET_PQ_Context *db);
245
257 unsigned int num,
258 const uint32_t *elements,
259 struct GNUNET_PQ_Context *db);
260
272 unsigned int num,
273 const uint64_t *elements,
274 struct GNUNET_PQ_Context *db);
275
288 unsigned int num,
289 const void *elements,
290 const size_t *sizes,
291 struct GNUNET_PQ_Context *db);
292
306 unsigned int num,
307 const void *elements[static num],
308 const size_t *sizes,
309 struct GNUNET_PQ_Context *db);
310
323 unsigned int num,
324 const void *elements,
325 size_t same_size,
326 struct GNUNET_PQ_Context *db);
327
337#define GNUNET_PQ_query_param_array_auto_from_type(num, elements, db) \
338 GNUNET_PQ_query_param_array_bytes_same_size ((num), \
339 (elements), \
340 sizeof(*(elements)), \
341 (db))
342
355 unsigned int num,
356 const void *elements[static num],
357 size_t same_size,
358 struct GNUNET_PQ_Context *db);
359
360
371#define GNUNET_PQ_query_param_array_ptrs_auto_from_type(num, elements, db) \
372 GNUNET_PQ_query_param_array_ptrs_bytes_same_size ((num), \
373 (const void **) ( \
374 elements), \
375 sizeof(*(elements[0])) \
376 , \
377 (db))
378
379
390 unsigned int num,
391 const char *elements,
392 struct GNUNET_PQ_Context *db);
393
394
405 unsigned int num,
406 const char *elements[static num],
407 struct GNUNET_PQ_Context *db);
408
409
417#define GNUNET_PQ_query_param_auto_from_type(x) \
418 GNUNET_PQ_query_param_fixed_size ((x), sizeof(*(x)))
419
429 unsigned int num,
430 const struct GNUNET_TIME_Absolute *elements,
431 struct GNUNET_PQ_Context *db);
432
442 unsigned int num,
443 const struct GNUNET_TIME_Absolute *elements[],
444 struct GNUNET_PQ_Context *db);
445
455 unsigned int num,
456 const struct GNUNET_TIME_Relative *elements,
457 struct GNUNET_PQ_Context *db);
458
468 unsigned int num,
469 const struct GNUNET_TIME_Relative *elements[],
470 struct GNUNET_PQ_Context *db);
471
481 unsigned int num,
482 const struct GNUNET_TIME_Timestamp *elements,
483 struct GNUNET_PQ_Context *db);
484
494 unsigned int num,
495 const struct GNUNET_TIME_Timestamp *elements[],
496 struct GNUNET_PQ_Context *db);
497
507 const struct GNUNET_CRYPTO_RsaPublicKey *x);
508
509
519 const struct GNUNET_CRYPTO_RsaSignature *x);
520
521
531
532
542
543
553
554
564 const struct GNUNET_TIME_AbsoluteNBO *x);
565
566
576 const struct GNUNET_TIME_TimestampNBO *x);
577
578
586GNUNET_PQ_query_param_uint16 (const uint16_t *x);
587
588
596GNUNET_PQ_query_param_uint32 (const uint32_t *x);
597
598
606GNUNET_PQ_query_param_uint64 (const uint64_t *x);
607
608
616GNUNET_PQ_query_param_int16 (const int16_t *x);
617
625GNUNET_PQ_query_param_int64 (const int64_t *x);
626
638
647 const struct GNUNET_CRYPTO_BlindSignPrivateKey *priv);
648
657 const struct GNUNET_CRYPTO_UnblindedSignature *sig);
658
667 const struct GNUNET_CRYPTO_BlindedSignature *b_sig);
668
669/* ************************* pq_result_helper.c functions ************************ */
670
671
686typedef enum GNUNET_GenericReturnValue
687(*GNUNET_PQ_ResultConverter)(void *cls,
688 PGresult *result,
689 int row,
690 const char *fname,
691 size_t *dst_size,
692 void *dst);
693
694
702typedef void
703(*GNUNET_PQ_ResultCleanup) (void *cls,
704 void *rd);
705
706
711{
716
721
725 void *cls;
726
730 void *dst;
731
737 size_t dst_size;
738
742 const char *fname;
743
747 size_t *result_size;
748
753
758 bool *is_null;
759
761
762
768#define GNUNET_PQ_result_spec_end \
769 { \
770 .conv = NULL, \
771 .cleaner = NULL, \
772 .cls = NULL, \
773 .dst = NULL, \
774 .dst_size = 0, \
775 .fname = NULL, \
776 .result_size = NULL, \
777 .is_nullable = false, \
778 .is_null = NULL \
779 }
780
781
793 bool *is_null);
794
795
806 void **dst,
807 size_t *sptr);
808
809
820 void *dst,
821 size_t dst_size);
822
823
831#define GNUNET_PQ_result_spec_auto_from_type(name, dst) \
832 GNUNET_PQ_result_spec_fixed_size (name, (dst), sizeof(*(dst)))
833
834
844 char **dst);
845
846
856 bool *dst);
857
858
868 struct GNUNET_CRYPTO_RsaPublicKey **rsa);
869
870
880 struct GNUNET_CRYPTO_RsaSignature **sig);
881
882
892 struct GNUNET_TIME_Absolute *at);
893
894
904 struct GNUNET_TIME_Timestamp *t);
905
906
916 struct GNUNET_TIME_Relative *rt);
917
918
928 struct GNUNET_TIME_AbsoluteNBO *at);
929
930
940 struct GNUNET_TIME_TimestampNBO *tn);
941
942
952 uint16_t *u16);
953
954
964 uint32_t *u32);
965
966
976 uint64_t *u64);
977
978
988 int16_t *i16);
989
990
1000 int64_t *i64);
1001
1016 struct GNUNET_PQ_ResultSpec rs,
1017 bool **is_nulls);
1018
1030 struct GNUNET_PQ_Context *db,
1031 const char *name,
1032 size_t *num,
1033 bool **bools);
1034
1046 struct GNUNET_PQ_Context *db,
1047 const char *name,
1048 size_t *num,
1049 uint16_t **dst);
1050
1062 struct GNUNET_PQ_Context *db,
1063 const char *name,
1064 size_t *num,
1065 uint32_t **dst);
1066
1078 struct GNUNET_PQ_Context *db,
1079 const char *name,
1080 size_t *num,
1081 uint64_t **dst);
1082
1083
1095 struct GNUNET_PQ_Context *db,
1096 const char *name,
1097 size_t *num,
1098 struct GNUNET_TIME_Absolute **dst);
1099
1111 struct GNUNET_PQ_Context *db,
1112 const char *name,
1113 size_t *num,
1114 struct GNUNET_TIME_Relative **dst);
1115
1128 struct GNUNET_PQ_Context *db,
1129 const char *name,
1130 size_t *num,
1131 struct GNUNET_TIME_Timestamp **dst);
1132
1145 struct GNUNET_PQ_Context *db,
1146 const char *name,
1147 size_t *num,
1148 size_t **sizes,
1149 void **dst);
1150
1151
1164 struct GNUNET_PQ_Context *db,
1165 const char *name,
1166 size_t size,
1167 size_t *num,
1168 void **dst);
1169
1170
1180#define GNUNET_PQ_result_spec_auto_array_from_type(db, name, num, dst) \
1181 GNUNET_PQ_result_spec_array_fixed_size ( \
1182 (db), \
1183 (name), \
1184 sizeof(*(dst)), \
1185 (num), \
1186 (void *) &(dst))
1187
1188
1200 struct GNUNET_PQ_Context *db,
1201 const char *name,
1202 size_t *num,
1203 char **dst);
1204
1205
1215 const char *name,
1216 struct GNUNET_CRYPTO_BlindSignPublicKey **public_key);
1217
1218
1228 const char *name,
1229 struct GNUNET_CRYPTO_BlindedSignature **b_sig);
1230
1231
1241 const char *name,
1242 struct GNUNET_CRYPTO_UnblindedSignature **ub_sig);
1243
1244
1254 const char *name,
1255 struct GNUNET_CRYPTO_BlindSignPrivateKey **private_key);
1256
1257/* ************************* pq.c functions ************************ */
1258
1268PGresult *
1270 const char *name,
1271 const struct GNUNET_PQ_QueryParam *params);
1272
1273
1286 struct GNUNET_PQ_ResultSpec *rs,
1287 int row);
1288
1289
1296void
1298
1299
1300/* ******************** pq_eval.c functions ************** */
1301
1302
1318 const char *statement_name,
1319 PGresult *result);
1320
1321
1340 const char *statement_name,
1341 const struct GNUNET_PQ_QueryParam *params);
1342
1343
1352typedef void
1354 PGresult *result,
1355 unsigned int num_results);
1356
1357
1375 const char *statement_name,
1376 const struct GNUNET_PQ_QueryParam *params,
1378 void *rh_cls);
1379
1380
1398 struct GNUNET_PQ_Context *db,
1399 const char *statement_name,
1400 const struct GNUNET_PQ_QueryParam *params,
1401 struct GNUNET_PQ_ResultSpec *rs);
1402
1403
1404/* ******************** pq_prepare.c functions ************** */
1405
1406
1412{
1416 const char *name;
1417
1421 const char *sql;
1422
1423};
1424
1425
1429#define GNUNET_PQ_PREPARED_STATEMENT_END \
1430 { \
1431 NULL, NULL \
1432 }
1433
1434
1443GNUNET_PQ_make_prepare (const char *name,
1444 const char *sql);
1445
1446
1458 const struct GNUNET_PQ_PreparedStatement *ps);
1459
1460
1474 const struct GNUNET_PQ_PreparedStatement *ps);
1475
1476
1477/* ******************** pq_exec.c functions ************** */
1478
1479
1485{
1489 const char *sql;
1490
1495};
1496
1497
1501#define GNUNET_PQ_EXECUTE_STATEMENT_END \
1502 { \
1503 NULL, GNUNET_SYSERR \
1504 }
1505
1506
1514GNUNET_PQ_make_execute (const char *sql);
1515
1516
1525GNUNET_PQ_make_try_execute (const char *sql);
1526
1527
1539 const struct GNUNET_PQ_ExecuteStatement *es);
1540
1541
1542/* ******************** pq_connect.c functions ************** */
1543
1544
1566
1567
1590struct GNUNET_PQ_Context *
1591GNUNET_PQ_connect (const char *config_str,
1592 const char *load_path,
1593 const struct GNUNET_PQ_ExecuteStatement *es,
1594 const struct GNUNET_PQ_PreparedStatement *ps);
1595
1596
1609 const char *buf);
1610
1611
1636struct GNUNET_PQ_Context *
1637GNUNET_PQ_connect2 (const char *config_str,
1638 const char *load_path,
1639 const char *auto_suffix,
1640 const struct GNUNET_PQ_ExecuteStatement *es,
1641 const struct GNUNET_PQ_PreparedStatement *ps,
1643
1644
1662struct GNUNET_PQ_Context *
1664 const char *section,
1665 const char *load_path_suffix,
1666 const struct GNUNET_PQ_ExecuteStatement *es,
1667 const struct GNUNET_PQ_PreparedStatement *ps);
1668
1669
1689struct GNUNET_PQ_Context *
1691 const char *section,
1692 const char *load_path_suffix,
1693 const struct GNUNET_PQ_ExecuteStatement *es,
1694 const struct GNUNET_PQ_PreparedStatement *ps,
1696
1697
1703void
1705
1706
1712void
1714
1715
1735 const struct GNUNET_DB_EventHeaderP *es,
1738 void *cb_cls);
1739
1740
1752void
1754
1755
1765void
1767
1768
1782void
1784 const struct GNUNET_DB_EventHeaderP *es,
1785 const void *extra,
1786 size_t extra_size);
1787
1788
1796char *
1798
1799
1813 const char *load_suffix);
1814
1815
1822void
1824
1825
1826#endif /* GNUNET_PQ_LIB_H_ */
1827
1828/* end of include/gnunet_pq_lib.h */
static struct GNUNET_CONFIGURATION_Handle * cfg
Our configuration.
Definition gnunet-arm.c:108
static struct GNUNET_TIME_Relative timeout
User defined timestamp for completing operations.
Definition gnunet-arm.c:118
static struct GNUNET_PEERSTORE_Handle * ps
Handle to the PEERSTORE service.
static char * data
The data to insert into the dht.
static char * name
Name (label) of the records to list.
static struct GNUNET_GNSRECORD_Data rd[50]
The record data under a single label.
static int result
Global testing status.
static struct GNUNET_CRYPTO_EddsaPublicKey pub
static struct GNUNET_FS_DirectoryBuilder * db
static struct GNUNET_SCHEDULER_Task * t
Main task.
commonly used definitions; globals in this file are exempt from the rule that the module name ("commo...
shared definitions for transactional databases
void(* GNUNET_DB_EventCallback)(void *cls, const void *extra, size_t extra_size)
Function called on events received from Postgres.
GNUNET_DB_QueryStatus
Status code returned from functions running database commands.
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.
void(* GNUNET_PQ_PostgresResultHandler)(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.
struct GNUNET_PQ_QueryParam GNUNET_PQ_query_param_array_ptrs_rel_time(unsigned int num, const struct GNUNET_TIME_Relative *elements[], struct GNUNET_PQ_Context *db)
Generate query parameter for an array of relative time stamps (pointers)
struct GNUNET_PQ_QueryParam GNUNET_PQ_query_param_uint64(const uint64_t *x)
Generate query parameter for an uint64_t in host byte order.
struct GNUNET_PQ_ResultSpec GNUNET_PQ_result_spec_timestamp_nbo(const char *name, struct GNUNET_TIME_TimestampNBO *tn)
Timestamp expected.
void GNUNET_PQ_reconnect(struct GNUNET_PQ_Context *db)
Reinitialize the database db.
Definition pq_connect.c:562
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:165
struct GNUNET_PQ_ResultSpec GNUNET_PQ_result_spec_blind_sign_pub(const char *name, struct GNUNET_CRYPTO_BlindSignPublicKey **public_key)
Blind sign public key expected.
void GNUNET_PQ_event_do_poll(struct GNUNET_PQ_Context *db)
Poll for events right now.
Definition pq_event.c:189
struct GNUNET_PQ_ResultSpec GNUNET_PQ_result_spec_uint32(const char *name, uint32_t *u32)
uint32_t expected.
struct GNUNET_PQ_QueryParam GNUNET_PQ_query_param_array_abs_time(unsigned int num, const struct GNUNET_TIME_Absolute *elements, struct GNUNET_PQ_Context *db)
Generate query parameter for an array of absolute time stamps (continuous)
struct GNUNET_PQ_QueryParam GNUNET_PQ_query_param_null(void)
Generate query parameter to create a NULL value.
struct GNUNET_PQ_QueryParam GNUNET_PQ_query_param_array_ptrs_timestamp(unsigned int num, const struct GNUNET_TIME_Timestamp *elements[], struct GNUNET_PQ_Context *db)
Generate query parameter for an array of time stamps (pointers)
struct GNUNET_PQ_QueryParam GNUNET_PQ_query_param_blind_sign_pub(const struct GNUNET_CRYPTO_BlindSignPublicKey *pub)
Generate query parameter for a blind sign public key.
struct GNUNET_PQ_ResultSpec GNUNET_PQ_result_spec_array_variable_size(struct GNUNET_PQ_Context *db, const char *name, size_t *num, size_t **sizes, void **dst)
Array of variable-size result expected.
struct GNUNET_PQ_QueryParam GNUNET_PQ_query_param_array_ptrs_abs_time(unsigned int num, const struct GNUNET_TIME_Absolute *elements[], struct GNUNET_PQ_Context *db)
Generate query parameter for an array of absolute time stamps (pointers)
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:700
struct GNUNET_PQ_QueryParam GNUNET_PQ_query_param_array_uint32(unsigned int num, const uint32_t *elements, struct GNUNET_PQ_Context *db)
Generate query parameter for an array of uint32_t in host byte order.
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:199
struct GNUNET_DB_EventHandler * GNUNET_PQ_event_listen(struct GNUNET_PQ_Context *db, const struct GNUNET_DB_EventHeaderP *es, struct GNUNET_TIME_Relative timeout, GNUNET_DB_EventCallback cb, void *cb_cls)
Register callback to be invoked on events of type es.
Definition pq_event.c:467
struct GNUNET_PQ_ResultSpec GNUNET_PQ_result_spec_array_fixed_size(struct GNUNET_PQ_Context *db, const char *name, size_t size, size_t *num, void **dst)
Array of fixed-size result expected.
struct GNUNET_PQ_ResultSpec GNUNET_PQ_result_spec_int16(const char *name, int16_t *i16)
int16_t expected.
void(* GNUNET_PQ_QueryConverter_Cleanup)(void *cls)
Function called to cleanup the closure of SQL parameters converter.
struct GNUNET_PQ_QueryParam GNUNET_PQ_query_param_unblinded_sig(const struct GNUNET_CRYPTO_UnblindedSignature *sig)
Generate query parameter for an unblinded signature of variable size.
struct GNUNET_PQ_ResultSpec GNUNET_PQ_result_spec_blinded_sig(const char *name, struct GNUNET_CRYPTO_BlindedSignature **b_sig)
Blinded signature expected.
void GNUNET_PQ_event_notify(struct GNUNET_PQ_Context *db, const struct GNUNET_DB_EventHeaderP *es, const void *extra, size_t extra_size)
Notify all that listen on es of an event.
Definition pq_event.c:559
struct GNUNET_PQ_ResultSpec GNUNET_PQ_result_spec_array_timestamp(struct GNUNET_PQ_Context *db, const char *name, size_t *num, struct GNUNET_TIME_Timestamp **dst)
array of relative time expected.
struct GNUNET_PQ_QueryParam GNUNET_PQ_query_param_array_ptrs_bytes(unsigned int num, const void *elements[static num], const size_t *sizes, struct GNUNET_PQ_Context *db)
Generate query parameter for an array of buffers elements, with sizes sizes.
struct GNUNET_PQ_Context * GNUNET_PQ_connect2(const char *config_str, const char *load_path, const char *auto_suffix, const struct GNUNET_PQ_ExecuteStatement *es, const struct GNUNET_PQ_PreparedStatement *ps, enum GNUNET_PQ_Options flags)
Create a connection to the Postgres database using config_str for the configuration.
Definition pq_connect.c:260
char * GNUNET_PQ_get_event_notify_channel(const struct GNUNET_DB_EventHeaderP *es)
Compute the channel that one should notify upon for the given event specification.
Definition pq_event.c:544
void GNUNET_PQ_cleanup_query_params_closures(const struct GNUNET_PQ_QueryParam *params)
Must be called to cleanup memory from closures after the query parameters have been used as much as n...
Definition pq.c:126
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:30
struct GNUNET_PQ_QueryParam GNUNET_PQ_query_param_absolute_time(const struct GNUNET_TIME_Absolute *x)
Generate query parameter for an absolute time value.
enum GNUNET_GenericReturnValue GNUNET_PQ_prepare_once(struct GNUNET_PQ_Context *db, const struct GNUNET_PQ_PreparedStatement *ps)
Request creation of prepared statements ps from Postgres, but do not automatically re-prepare the sta...
Definition pq_prepare.c:43
struct GNUNET_PQ_QueryParam GNUNET_PQ_query_param_relative_time(const struct GNUNET_TIME_Relative *x)
Generate query parameter for a relative time value.
struct GNUNET_PQ_QueryParam GNUNET_PQ_query_param_array_uint64(unsigned int num, const uint64_t *elements, struct GNUNET_PQ_Context *db)
Generate query parameter for an array of uint64 in host byte order.
struct GNUNET_PQ_QueryParam GNUNET_PQ_query_param_int64(const int64_t *x)
Generate query parameter for an int64_t in host byte order.
struct GNUNET_PQ_QueryParam GNUNET_PQ_query_param_uint16(const uint16_t *x)
Generate query parameter for an uint16_t in host byte order.
struct GNUNET_PQ_ResultSpec GNUNET_PQ_result_spec_fixed_size(const char *name, void *dst, size_t dst_size)
Fixed-size result expected.
struct GNUNET_PQ_ResultSpec GNUNET_PQ_result_spec_array_bool(struct GNUNET_PQ_Context *db, const char *name, size_t *num, bool **bools)
array of bool expected.
struct GNUNET_PQ_QueryParam GNUNET_PQ_query_param_rsa_public_key(const struct GNUNET_CRYPTO_RsaPublicKey *x)
Generate query parameter for an RSA public key.
struct GNUNET_PQ_ResultSpec GNUNET_PQ_result_spec_bool(const char *name, bool *dst)
boolean expected.
void(* GNUNET_PQ_ResultCleanup)(void *cls, void *rd)
Function called to clean up memory allocated by a GNUNET_PQ_ResultConverter.
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:54
struct GNUNET_PQ_ResultSpec GNUNET_PQ_result_spec_absolute_time_nbo(const char *name, struct GNUNET_TIME_AbsoluteNBO *at)
Absolute time expected.
enum GNUNET_GenericReturnValue GNUNET_PQ_prepare_statements(struct GNUNET_PQ_Context *db, const struct GNUNET_PQ_PreparedStatement *ps)
Request creation of prepared statements ps from Postgres.
Definition pq_prepare.c:88
struct GNUNET_PQ_QueryParam GNUNET_PQ_query_param_array_bool(unsigned int num, const bool *elements, struct GNUNET_PQ_Context *db)
Generate query parameter for an array of bool in host byte order.
int(* GNUNET_PQ_QueryConverter)(void *cls, const void *data, size_t data_len, void *param_values[], int param_lengths[], int param_formats[], unsigned int param_length, void *scratch[], unsigned int scratch_length)
Function called to convert input argument into SQL parameters.
struct GNUNET_PQ_QueryParam GNUNET_PQ_query_param_absolute_time_nbo(const struct GNUNET_TIME_AbsoluteNBO *x)
Generate query parameter for an absolute time value.
struct GNUNET_PQ_QueryParam GNUNET_PQ_query_param_array_ptrs_string(unsigned int num, const char *elements[static num], struct GNUNET_PQ_Context *db)
Generate query parameter for an array of strings (pointers)
struct GNUNET_PQ_ResultSpec GNUNET_PQ_result_spec_uint64(const char *name, uint64_t *u64)
uint64_t expected.
struct GNUNET_PQ_QueryParam GNUNET_PQ_query_param_array_bytes(unsigned int num, const void *elements, const size_t *sizes, struct GNUNET_PQ_Context *db)
Generate query parameter for an array of buffers elements, each of corresponding size given in sizes.
struct GNUNET_PQ_QueryParam GNUNET_PQ_query_param_bool(bool b)
Pass a boolean into a query.
struct GNUNET_PQ_ResultSpec GNUNET_PQ_result_spec_string(const char *name, char **dst)
0-terminated string expected.
void GNUNET_PQ_reconnect_if_down(struct GNUNET_PQ_Context *db)
Reinitialize the database db if the connection is down.
Definition pq_connect.c:449
enum GNUNET_DB_QueryStatus GNUNET_PQ_eval_result(struct GNUNET_PQ_Context *db, const char *statement_name, PGresult *result)
Check the result's error code to see what happened.
Definition pq_eval.c:46
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:765
enum GNUNET_GenericReturnValue(* GNUNET_PQ_ResultConverter)(void *cls, PGresult *result, int row, const char *fname, size_t *dst_size, void *dst)
Extract data from a Postgres database result at row row.
struct GNUNET_PQ_ResultSpec GNUNET_PQ_result_spec_array_allow_nulls(struct GNUNET_PQ_ResultSpec rs, bool **is_nulls)
Allow NULL values in an array to be found in the database for the given value.
struct GNUNET_PQ_ResultSpec GNUNET_PQ_result_spec_allow_null(struct GNUNET_PQ_ResultSpec rs, bool *is_null)
Allow NULL value to be found in the database for the given value.
struct GNUNET_PQ_ResultSpec GNUNET_PQ_result_spec_array_uint16(struct GNUNET_PQ_Context *db, const char *name, size_t *num, uint16_t **dst)
array of uint16_t expected.
struct GNUNET_PQ_QueryParam GNUNET_PQ_query_param_blind_sign_priv(const struct GNUNET_CRYPTO_BlindSignPrivateKey *priv)
Generate query parameter for a blind sign private key of variable size.
struct GNUNET_PQ_ResultSpec GNUNET_PQ_result_spec_absolute_time(const char *name, struct GNUNET_TIME_Absolute *at)
Absolute time expected.
struct GNUNET_PQ_ResultSpec GNUNET_PQ_result_spec_int64(const char *name, int64_t *i64)
int64_t expected.
struct GNUNET_PQ_QueryParam GNUNET_PQ_query_param_blinded_sig(const struct GNUNET_CRYPTO_BlindedSignature *b_sig)
Generate query parameter for a blinded signature of variable size.
struct GNUNET_PQ_ResultSpec GNUNET_PQ_result_spec_uint16(const char *name, uint16_t *u16)
uint16_t expected.
struct GNUNET_PQ_ResultSpec GNUNET_PQ_result_spec_array_string(struct GNUNET_PQ_Context *db, const char *name, size_t *num, char **dst)
Array of 0-terminated strings expected.
struct GNUNET_PQ_QueryParam GNUNET_PQ_query_param_array_timestamp(unsigned int num, const struct GNUNET_TIME_Timestamp *elements, struct GNUNET_PQ_Context *db)
Generate query parameter for an array of time stamps (continuous)
struct GNUNET_PQ_QueryParam GNUNET_PQ_query_param_array_rel_time(unsigned int num, const struct GNUNET_TIME_Relative *elements, struct GNUNET_PQ_Context *db)
Generate query parameter for an array of relative time stamps (continuous)
struct GNUNET_PQ_QueryParam GNUNET_PQ_query_param_array_uint16(unsigned int num, const uint16_t *elements, struct GNUNET_PQ_Context *db)
Generate query parameter for an array of uint16_t in host byte order.
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
struct GNUNET_PQ_ExecuteStatement GNUNET_PQ_make_try_execute(const char *sql)
Create a struct GNUNET_PQ_ExecuteStatement where errors should be tolerated.
Definition pq_exec.c:42
struct GNUNET_PQ_QueryParam GNUNET_PQ_query_param_uint32(const uint32_t *x)
Generate query parameter for an uint32_t in host byte order.
PGresult * GNUNET_PQ_exec_prepared(struct GNUNET_PQ_Context *db, const char *name, const struct GNUNET_PQ_QueryParam *params)
Execute a prepared statement.
Definition pq.c:33
struct GNUNET_PQ_ResultSpec GNUNET_PQ_result_spec_relative_time(const char *name, struct GNUNET_TIME_Relative *rt)
Relative time expected.
struct GNUNET_PQ_QueryParam GNUNET_PQ_query_param_timestamp(const struct GNUNET_TIME_Timestamp *x)
Generate query parameter for a timestamp.
GNUNET_PQ_Options
Flags to control PQ operation.
@ GNUNET_PQ_FLAG_DROP
Dropping database.
@ GNUNET_PQ_FLAG_CHECK_CURRENT
Check database version is current.
@ GNUNET_PQ_FLAG_NONE
Traditional default.
struct GNUNET_PQ_Context * GNUNET_PQ_connect_with_cfg2(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, enum GNUNET_PQ_Options flags)
Connect to a postgres database using the configuration option "CONFIG" in section.
Definition pq_connect.c:716
struct GNUNET_PQ_ResultSpec GNUNET_PQ_result_spec_variable_size(const char *name, void **dst, size_t *sptr)
Variable-size result expected.
struct GNUNET_PQ_QueryParam GNUNET_PQ_query_param_int16(const int16_t *x)
Generate query parameter for an int16_t in host byte order.
struct GNUNET_PQ_ResultSpec GNUNET_PQ_result_spec_rsa_public_key(const char *name, struct GNUNET_CRYPTO_RsaPublicKey **rsa)
RSA public key 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:142
struct GNUNET_PQ_QueryParam GNUNET_PQ_query_param_timestamp_nbo(const struct GNUNET_TIME_TimestampNBO *x)
Generate query parameter for a timestamp in NBO.
struct GNUNET_PQ_ResultSpec GNUNET_PQ_result_spec_array_uint64(struct GNUNET_PQ_Context *db, const char *name, size_t *num, uint64_t **dst)
array of uint64_t expected.
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:152
struct GNUNET_PQ_ResultSpec GNUNET_PQ_result_spec_array_abs_time(struct GNUNET_PQ_Context *db, const char *name, size_t *num, struct GNUNET_TIME_Absolute **dst)
array of absolute time expected.
uint32_t oid
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:135
void GNUNET_PQ_event_listen_cancel(struct GNUNET_DB_EventHandler *eh)
Stop notifications.
Definition pq_event.c:509
struct GNUNET_PQ_ResultSpec GNUNET_PQ_result_spec_array_rel_time(struct GNUNET_PQ_Context *db, const char *name, size_t *num, struct GNUNET_TIME_Relative **dst)
array of relative time expected.
struct GNUNET_PQ_ResultSpec GNUNET_PQ_result_spec_rsa_signature(const char *name, struct GNUNET_CRYPTO_RsaSignature **sig)
RSA signature expected.
struct GNUNET_PQ_ResultSpec __attribute__
struct GNUNET_PQ_QueryParam GNUNET_PQ_query_param_array_ptrs_bytes_same_size(unsigned int num, const void *elements[static num], size_t same_size, struct GNUNET_PQ_Context *db)
Generate query parameter for an array of pointers to buffers elements, each of the same size size.
struct GNUNET_PQ_ResultSpec GNUNET_PQ_result_spec_array_uint32(struct GNUNET_PQ_Context *db, const char *name, size_t *num, uint32_t **dst)
array of uint32_t expected.
struct GNUNET_PQ_QueryParam GNUNET_PQ_query_param_array_string(unsigned int num, const char *elements, struct GNUNET_PQ_Context *db)
Generate query parameter for an array of strings (continuous)
struct GNUNET_PQ_ResultSpec GNUNET_PQ_result_spec_blind_sign_priv(const char *name, struct GNUNET_CRYPTO_BlindSignPrivateKey **private_key)
Blind sign private key expected.
struct GNUNET_PQ_QueryParam GNUNET_PQ_query_param_string(const char *ptr)
Generate query parameter for a string.
struct GNUNET_PQ_ResultSpec GNUNET_PQ_result_spec_timestamp(const char *name, struct GNUNET_TIME_Timestamp *t)
Timestamp expected.
struct GNUNET_PQ_QueryParam GNUNET_PQ_query_param_array_bytes_same_size(unsigned int num, const void *elements, size_t same_size, struct GNUNET_PQ_Context *db)
Generate query parameter for an array of buffers elements, each of the same size size.
enum GNUNET_GenericReturnValue GNUNET_PQ_get_oid_by_name(struct GNUNET_PQ_Context *db, const char *name, Oid *oid)
Returns the oid for a given datatype by name.
Definition pq_connect.c:461
struct GNUNET_PQ_QueryParam GNUNET_PQ_query_param_rsa_signature(const struct GNUNET_CRYPTO_RsaSignature *x)
Generate query parameter for an RSA signature.
enum GNUNET_GenericReturnValue GNUNET_PQ_exec_sql(struct GNUNET_PQ_Context *db, const char *buf)
Execute SQL statements from buf against db.
Definition pq_connect.c:318
struct GNUNET_PQ_ResultSpec GNUNET_PQ_result_spec_unblinded_sig(const char *name, struct GNUNET_CRYPTO_UnblindedSignature **ub_sig)
Unblinded signature expected.
struct GNUNET_PQ_Context * GNUNET_PQ_connect(const char *config_str, const char *load_path, const struct GNUNET_PQ_ExecuteStatement *es, const struct GNUNET_PQ_PreparedStatement *ps)
Create a connection to the Postgres database using config_str for the configuration.
Definition pq_connect.c:243
enum GNUNET_GenericReturnValue GNUNET_PQ_run_sql(struct GNUNET_PQ_Context *db, const char *load_suffix)
Within the db context, run all the SQL files in the load path where the name starts with the load_suf...
Definition pq_connect.c:400
Functions related to time.
GNUNET_GenericReturnValue
Named constants for return values.
static unsigned int size
Size of the "table".
Definition peer.c:68
Type of private signing keys for blind signing.
Type of public signing keys for blind signatures.
Type for blinded signatures.
The public information of an RSA key pair.
Definition crypto_rsa.c:53
Type of (unblinded) signatures.
Handle for an active LISTENer to the database.
Definition pq_event.c:34
void * cb_cls
Closure for cb.
Definition pq_event.c:48
GNUNET_DB_EventCallback cb
Function to call on events.
Definition pq_event.c:43
Header of a structure that describes an event channel we may subscribe to or notify on.
The header for a postgresql array in binary format.
Handle to Postgres database.
Definition pq.h:36
struct GNUNET_PQ_ExecuteStatement * es
Statements to execute upon connection.
Definition pq.h:45
enum GNUNET_PQ_Options flags
Flags controlling the connection.
Definition pq.h:106
char * load_path
Path to load SQL files from.
Definition pq.h:70
char * config_str
Configuration to use to connect to the DB.
Definition pq.h:65
char * auto_suffix
Suffix to append to path to load on startup.
Definition pq.h:75
Information needed to run a list of SQL statements using GNUNET_PQ_exec_statements().
const char * sql
Actual SQL statement.
int ignore_errors
Should we ignore errors?
Information needed to prepare a list of SQL statements using GNUNET_PQ_prepare_statements().
const char * name
Name of the statement.
const char * sql
Actual SQL statement.
Description of a DB query parameter.
void * conv_cls
Closure for conv.
const void * data
Data or NULL.
GNUNET_PQ_QueryConverter conv
Function for how to handle this type of entry.
unsigned int num_params
Number of parameters eaten by this operation.
GNUNET_PQ_QueryConverter_Cleanup conv_cls_cleanup
Function to cleanup the closure conv_cls, may be NULL.
size_t size
Size of data.
Description of a DB result cell.
const char * fname
Field name of the desired result.
bool * is_null
Points to a location where we should store "true" if the result found is NULL, and otherwise "false".
void * dst
Destination for the data.
bool is_nullable
True if NULL is allowed for a value in the database.
void * cls
Closure for conv and cleaner.
GNUNET_PQ_ResultConverter conv
What is the format of the result?
size_t * result_size
Where to store actual size of the result.
GNUNET_PQ_ResultCleanup cleaner
Function to clean up result data, NULL if cleanup is not necessary.
size_t dst_size
Allowed size for the data, 0 for variable-size (in this case, the type of dst is a void ** and we nee...
Time for absolute time used by GNUnet, in microseconds and in network byte order.
Time for absolute times used by GNUnet, in microseconds.
Time for relative time used by GNUnet, in microseconds.
Time for timestamps used by GNUnet, in seconds and in network byte order.
Time for timestamps used by GNUnet, in microseconds rounded to seconds.