GNUnet 0.24.1-15-gab6ed22f1
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
83{
88
95 void *conv_cls;
96
103
107 const void *data;
108
112 size_t size;
113
117 unsigned int num_params;
118
119};
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
1002
1014 struct GNUNET_PQ_Context *db,
1015 const char *name,
1016 size_t *num,
1017 bool **bools);
1018
1030 struct GNUNET_PQ_Context *db,
1031 const char *name,
1032 size_t *num,
1033 uint16_t **dst);
1034
1046 struct GNUNET_PQ_Context *db,
1047 const char *name,
1048 size_t *num,
1049 uint32_t **dst);
1050
1062 struct GNUNET_PQ_Context *db,
1063 const char *name,
1064 size_t *num,
1065 uint64_t **dst);
1066
1067
1079 struct GNUNET_PQ_Context *db,
1080 const char *name,
1081 size_t *num,
1082 struct GNUNET_TIME_Absolute **dst);
1083
1095 struct GNUNET_PQ_Context *db,
1096 const char *name,
1097 size_t *num,
1098 struct GNUNET_TIME_Relative **dst);
1099
1112 struct GNUNET_PQ_Context *db,
1113 const char *name,
1114 size_t *num,
1115 struct GNUNET_TIME_Timestamp **dst);
1116
1129 struct GNUNET_PQ_Context *db,
1130 const char *name,
1131 size_t *num,
1132 size_t **sizes,
1133 void **dst);
1134
1135
1148 struct GNUNET_PQ_Context *db,
1149 const char *name,
1150 size_t size,
1151 size_t *num,
1152 void **dst);
1153
1154
1164#define GNUNET_PQ_result_spec_auto_array_from_type(db, name, num, dst) \
1165 GNUNET_PQ_result_spec_array_fixed_size ( \
1166 (db), \
1167 (name), \
1168 sizeof(*(dst)), \
1169 (num), \
1170 (void *) &(dst))
1171
1172
1184 struct GNUNET_PQ_Context *db,
1185 const char *name,
1186 size_t *num,
1187 char **dst);
1188
1189
1199 const char *name,
1200 struct GNUNET_CRYPTO_BlindSignPublicKey **public_key);
1201
1202
1212 const char *name,
1213 struct GNUNET_CRYPTO_BlindSignPrivateKey **private_key);
1214
1215/* ************************* pq.c functions ************************ */
1216
1226PGresult *
1228 const char *name,
1229 const struct GNUNET_PQ_QueryParam *params);
1230
1231
1244 struct GNUNET_PQ_ResultSpec *rs,
1245 int row);
1246
1247
1254void
1256
1257
1258/* ******************** pq_eval.c functions ************** */
1259
1260
1276 const char *statement_name,
1277 PGresult *result);
1278
1279
1298 const char *statement_name,
1299 const struct GNUNET_PQ_QueryParam *params);
1300
1301
1310typedef void
1312 PGresult *result,
1313 unsigned int num_results);
1314
1315
1333 const char *statement_name,
1334 const struct GNUNET_PQ_QueryParam *params,
1336 void *rh_cls);
1337
1338
1356 struct GNUNET_PQ_Context *db,
1357 const char *statement_name,
1358 const struct GNUNET_PQ_QueryParam *params,
1359 struct GNUNET_PQ_ResultSpec *rs);
1360
1361
1362/* ******************** pq_prepare.c functions ************** */
1363
1364
1370{
1374 const char *name;
1375
1379 const char *sql;
1380
1381};
1382
1383
1387#define GNUNET_PQ_PREPARED_STATEMENT_END \
1388 { \
1389 NULL, NULL \
1390 }
1391
1392
1401GNUNET_PQ_make_prepare (const char *name,
1402 const char *sql);
1403
1404
1416 const struct GNUNET_PQ_PreparedStatement *ps);
1417
1418
1432 const struct GNUNET_PQ_PreparedStatement *ps);
1433
1434
1435/* ******************** pq_exec.c functions ************** */
1436
1437
1443{
1447 const char *sql;
1448
1453};
1454
1455
1459#define GNUNET_PQ_EXECUTE_STATEMENT_END \
1460 { \
1461 NULL, GNUNET_SYSERR \
1462 }
1463
1464
1472GNUNET_PQ_make_execute (const char *sql);
1473
1474
1483GNUNET_PQ_make_try_execute (const char *sql);
1484
1485
1497 const struct GNUNET_PQ_ExecuteStatement *es);
1498
1499
1500/* ******************** pq_connect.c functions ************** */
1501
1502
1507{
1512
1518
1524
1525
1548struct GNUNET_PQ_Context *
1549GNUNET_PQ_connect (const char *config_str,
1550 const char *load_path,
1551 const struct GNUNET_PQ_ExecuteStatement *es,
1552 const struct GNUNET_PQ_PreparedStatement *ps);
1553
1554
1567 const char *buf);
1568
1569
1594struct GNUNET_PQ_Context *
1595GNUNET_PQ_connect2 (const char *config_str,
1596 const char *load_path,
1597 const char *auto_suffix,
1598 const struct GNUNET_PQ_ExecuteStatement *es,
1599 const struct GNUNET_PQ_PreparedStatement *ps,
1601
1602
1620struct GNUNET_PQ_Context *
1622 const char *section,
1623 const char *load_path_suffix,
1624 const struct GNUNET_PQ_ExecuteStatement *es,
1625 const struct GNUNET_PQ_PreparedStatement *ps);
1626
1627
1647struct GNUNET_PQ_Context *
1649 const char *section,
1650 const char *load_path_suffix,
1651 const struct GNUNET_PQ_ExecuteStatement *es,
1652 const struct GNUNET_PQ_PreparedStatement *ps,
1654
1655
1661void
1663
1664
1670void
1672
1673
1693 const struct GNUNET_DB_EventHeaderP *es,
1696 void *cb_cls);
1697
1698
1710void
1712
1713
1723void
1725
1726
1740void
1742 const struct GNUNET_DB_EventHeaderP *es,
1743 const void *extra,
1744 size_t extra_size);
1745
1746
1754char *
1756
1757
1771 const char *load_suffix);
1772
1773
1780void
1782
1783
1784#endif /* GNUNET_PQ_LIB_H_ */
1785
1786/* 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
Definition: gnunet-scrypt.c:47
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.
Definition: gnunet_db_lib.h:80
GNUNET_DB_QueryStatus
Status code returned from functions running database commands.
Definition: gnunet_db_lib.h:37
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.
Definition: gnunet_pq_lib.h:77
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.
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.
Definition: gnunet_pq_lib.h:60
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_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
Definition: gnunet_pq_lib.h:2
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_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
an RSA signature
Definition: crypto_rsa.c:65
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.
Definition: gnunet_db_lib.h:92
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.
Definition: gnunet_pq_lib.h:83
void * conv_cls
Closure for conv.
Definition: gnunet_pq_lib.h:95
const void * data
Data or NULL.
GNUNET_PQ_QueryConverter conv
Function for how to handle this type of entry.
Definition: gnunet_pq_lib.h:87
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.