GNUnet  0.17.6
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, 2021 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  */
25 #ifndef GNUNET_PQ_LIB_H
26 #define GNUNET_PQ_LIB_H
27 
28 #include <libpq-fe.h>
29 #include "gnunet_util_lib.h"
30 #include "gnunet_db_lib.h"
31 
32 /* ************************* pq_query_helper.c functions ************************ */
33 
34 
49 typedef int
50 (*GNUNET_PQ_QueryConverter) (void *cls,
51  const void *data,
52  size_t data_len,
53  void *param_values[],
54  int param_lengths[],
55  int param_formats[],
56  unsigned int param_length,
57  void *scratch[],
58  unsigned int scratch_length);
59 
60 
65 {
70 
74  void *conv_cls;
75 
79  const void *data;
80 
84  size_t size;
85 
89  unsigned int num_params;
90 
91 };
92 
93 
97 #define GNUNET_PQ_query_param_end \
98  { \
99  .conv = NULL, \
100  .conv_cls = NULL, \
101  .data = NULL, \
102  .size = 0, \
103  .num_params = 0 \
104  }
105 
106 
114 
115 
125 GNUNET_PQ_query_param_fixed_size (const void *ptr,
126  size_t ptr_size);
127 
128 
136 GNUNET_PQ_query_param_string (const char *ptr);
137 
138 
147 
148 
156 #define GNUNET_PQ_query_param_auto_from_type(x) \
157  GNUNET_PQ_query_param_fixed_size ((x), sizeof(*(x)))
158 
159 
169  const struct GNUNET_CRYPTO_RsaPublicKey *x);
170 
171 
181  const struct GNUNET_CRYPTO_RsaSignature *x);
182 
183 
193 
194 
204 
205 
215 
216 
226  const struct GNUNET_TIME_AbsoluteNBO *x);
227 
228 
238  const struct GNUNET_TIME_TimestampNBO *t);
239 
240 
248 GNUNET_PQ_query_param_uint16 (const uint16_t *x);
249 
250 
258 GNUNET_PQ_query_param_uint32 (const uint32_t *x);
259 
260 
268 GNUNET_PQ_query_param_uint64 (const uint64_t *x);
269 
270 
271 /* ************************* pq_result_helper.c functions ************************ */
272 
273 
288 typedef enum GNUNET_GenericReturnValue
289 (*GNUNET_PQ_ResultConverter)(void *cls,
290  PGresult *result,
291  int row,
292  const char *fname,
293  size_t *dst_size,
294  void *dst);
295 
296 
304 typedef void
305 (*GNUNET_PQ_ResultCleanup) (void *cls,
306  void *rd);
307 
308 
313 {
318 
324 
328  void *cls;
329 
333  void *dst;
334 
340  size_t dst_size;
341 
345  const char *fname;
346 
350  size_t *result_size;
351 
356 
363  bool *is_null;
364 
365 };
366 
367 
373 #define GNUNET_PQ_result_spec_end \
374  { \
375  .conv = NULL, \
376  .cleaner = NULL, \
377  .cls = NULL, \
378  .dst = NULL, \
379  .dst_size = 0, \
380  .fname = NULL, \
381  .result_size = NULL, \
382  .is_nullable = false, \
383  .is_null = NULL \
384  }
385 
386 
399  bool *is_null);
400 
401 
412  void **dst,
413  size_t *sptr);
414 
415 
426  void *dst,
427  size_t dst_size);
428 
429 
437 #define GNUNET_PQ_result_spec_auto_from_type(name, dst) \
438  GNUNET_PQ_result_spec_fixed_size (name, (dst), sizeof(*(dst)))
439 
440 
450  char **dst);
451 
452 
461 GNUNET_PQ_result_spec_bool (const char *name,
462  bool *dst);
463 
464 
474  struct GNUNET_CRYPTO_RsaPublicKey **rsa);
475 
476 
486  struct GNUNET_CRYPTO_RsaSignature **sig);
487 
488 
498  struct GNUNET_TIME_Absolute *at);
499 
500 
510  struct GNUNET_TIME_Timestamp *t);
511 
512 
522  struct GNUNET_TIME_Relative *rt);
523 
524 
534  struct GNUNET_TIME_AbsoluteNBO *at);
535 
536 
546  struct GNUNET_TIME_TimestampNBO *tn);
547 
548 
558  uint16_t *u16);
559 
560 
570  uint32_t *u32);
571 
572 
582  uint64_t *u64);
583 
584 
585 /* ************************* pq.c functions ************************ */
586 
590 struct GNUNET_PQ_Context;
591 
592 
602 PGresult *
604  const char *name,
605  const struct GNUNET_PQ_QueryParam *params);
606 
607 
620  struct GNUNET_PQ_ResultSpec *rs,
621  int row);
622 
623 
630 void
632 
633 
634 /* ******************** pq_eval.c functions ************** */
635 
636 
652  const char *statement_name,
653  PGresult *result);
654 
655 
674  const char *statement_name,
675  const struct GNUNET_PQ_QueryParam *params);
676 
677 
686 typedef void
687 (*GNUNET_PQ_PostgresResultHandler) (void *cls,
688  PGresult *result,
689  unsigned int num_results);
690 
691 
709  const char *statement_name,
710  const struct GNUNET_PQ_QueryParam *params,
712  void *rh_cls);
713 
714 
732  struct GNUNET_PQ_Context *db,
733  const char *statement_name,
734  const struct GNUNET_PQ_QueryParam *params,
735  struct GNUNET_PQ_ResultSpec *rs);
736 
737 
738 /* ******************** pq_prepare.c functions ************** */
739 
740 
746 {
750  const char *name;
751 
755  const char *sql;
756 
760  unsigned int num_arguments;
761 
762 };
763 
764 
768 #define GNUNET_PQ_PREPARED_STATEMENT_END \
769  { \
770  NULL, NULL, 0 \
771  }
772 
773 
783 GNUNET_PQ_make_prepare (const char *name,
784  const char *sql,
785  unsigned int num_args);
786 
787 
799  const struct GNUNET_PQ_PreparedStatement *ps);
800 
801 
802 /* ******************** pq_exec.c functions ************** */
803 
804 
810 {
814  const char *sql;
815 
820 };
821 
822 
826 #define GNUNET_PQ_EXECUTE_STATEMENT_END \
827  { \
828  NULL, GNUNET_SYSERR \
829  }
830 
831 
839 GNUNET_PQ_make_execute (const char *sql);
840 
841 
850 GNUNET_PQ_make_try_execute (const char *sql);
851 
852 
864  const struct GNUNET_PQ_ExecuteStatement *es);
865 
866 
867 /* ******************** pq_connect.c functions ************** */
868 
869 
874 {
879 
885 
890 };
891 
892 
915 struct GNUNET_PQ_Context *
916 GNUNET_PQ_connect (const char *config_str,
917  const char *load_path,
918  const struct GNUNET_PQ_ExecuteStatement *es,
919  const struct GNUNET_PQ_PreparedStatement *ps);
920 
921 
934  const char *buf);
935 
936 
961 struct GNUNET_PQ_Context *
962 GNUNET_PQ_connect2 (const char *config_str,
963  const char *load_path,
964  const char *auto_suffix,
965  const struct GNUNET_PQ_ExecuteStatement *es,
966  const struct GNUNET_PQ_PreparedStatement *ps,
967  enum GNUNET_PQ_Options flags);
968 
969 
987 struct GNUNET_PQ_Context *
989  const char *section,
990  const char *load_path_suffix,
991  const struct GNUNET_PQ_ExecuteStatement *es,
992  const struct GNUNET_PQ_PreparedStatement *ps);
993 
994 
1013 struct GNUNET_PQ_Context *
1015  const char *section,
1016  const char *load_path_suffix,
1017  const struct GNUNET_PQ_ExecuteStatement *es,
1018  const struct GNUNET_PQ_PreparedStatement *ps,
1019  enum GNUNET_PQ_Options flags);
1020 
1021 
1027 void
1029 
1030 
1036 void
1038 
1039 
1057 struct GNUNET_DB_EventHandler *
1059  const struct GNUNET_DB_EventHeaderP *es,
1062  void *cb_cls);
1063 
1064 
1076 void
1078 
1079 
1094 void
1096  const struct GNUNET_DB_EventHeaderP *es,
1097  const void *extra,
1098  size_t extra_size);
1099 
1100 
1112  const char *load_path);
1113 
1114 
1121 void
1123 
1124 
1125 #endif /* GNUNET_PQ_LIB_H_ */
1126 
1127 /* end of include/gnunet_pq_lib.h */
static const struct GNUNET_CONFIGURATION_Handle * cfg
Configuration we are using.
Definition: gnunet-abd.c:36
static struct GNUNET_TIME_Relative timeout
Desired timeout for the lookup (default is no timeout).
Definition: gnunet-abd.c:61
uint32_t data
The data value.
static int result
Global testing status.
static struct GNUNET_FS_DirectoryBuilder * db
Definition: gnunet-search.c:94
static char buf[2048]
static struct GNUNET_SCHEDULER_Task * t
Main task.
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:79
GNUNET_DB_QueryStatus
Status code returned from functions running database commands.
Definition: gnunet_db_lib.h:36
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_uint64(const uint64_t *x)
Generate query parameter for an uint16_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.
struct GNUNET_PQ_QueryParam GNUNET_PQ_query_param_timestamp_nbo(const struct GNUNET_TIME_TimestampNBO *t)
Generate query parameter for a timestamp in NBO.
void GNUNET_PQ_reconnect(struct GNUNET_PQ_Context *db)
Reinitialize the database db.
Definition: pq_connect.c:325
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.
struct GNUNET_PQ_QueryParam GNUNET_PQ_query_param_null(void)
Generate query parameter to create a NULL value.
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_PreparedStatement GNUNET_PQ_make_prepare(const char *name, const char *sql, unsigned int num_args)
Create a struct GNUNET_PQ_PreparedStatement.
Definition: pq_prepare.c:38
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:516
enum GNUNET_GenericReturnValue GNUNET_PQ_run_sql(struct GNUNET_PQ_Context *db, const char *load_path)
Within the db context, run all the SQL files from the load_path from 0000-9999.sql (as long as the fi...
Definition: pq_connect.c:223
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:439
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_relative_time(const struct GNUNET_TIME_Relative *x)
Generate query parameter for a relative 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.
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_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:76
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:62
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:85
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:50
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_ResultSpec GNUNET_PQ_result_spec_uint64(const char *name, uint64_t *u64)
uint64_t expected.
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:313
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:59
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:526
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_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:68
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:32
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_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:461
struct GNUNET_PQ_ResultSpec GNUNET_PQ_result_spec_uint16(const char *name, uint16_t *u16)
uint16_t expected.
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:55
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_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_ResultSpec GNUNET_PQ_result_spec_variable_size(const char *name, void **dst, size_t *sptr)
Variable-size result expected.
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:122
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
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
void GNUNET_PQ_event_listen_cancel(struct GNUNET_DB_EventHandler *eh)
Stop notifications.
Definition: pq_event.c:481
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:477
struct GNUNET_PQ_ResultSpec GNUNET_PQ_result_spec_rsa_signature(const char *name, struct GNUNET_CRYPTO_RsaSignature **sig)
RSA signature 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_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:143
GNUNET_GenericReturnValue
Named constants for return values.
Definition: gnunet_common.h:96
const char * name
The public information of an RSA key pair.
Definition: crypto_rsa.c:52
an RSA signature
Definition: crypto_rsa.c:64
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:91
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:85
char * load_path
Path to load SQL files from.
Definition: pq.h:60
struct GNUNET_PQ_PreparedStatement * ps
Prepared statements.
Definition: pq.h:50
char * config_str
Configuration to use to connect to the DB.
Definition: pq.h:55
char * auto_suffix
Suffix to append to path to load on startup.
Definition: pq.h:65
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().
unsigned int num_arguments
Number of arguments included in sql.
const char * name
Name of the statement.
const char * sql
Actual SQL statement.
Description of a DB query parameter.
Definition: gnunet_pq_lib.h:65
void * conv_cls
Closure for conv.
Definition: gnunet_pq_lib.h:74
const void * data
Data or NULL.
Definition: gnunet_pq_lib.h:79
GNUNET_PQ_QueryConverter conv
Function for how to handle this type of entry.
Definition: gnunet_pq_lib.h:69
unsigned int num_params
Number of parameters eaten by this operation.
Definition: gnunet_pq_lib.h:89
size_t size
Size of data.
Definition: gnunet_pq_lib.h:84
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.
Rounded time for timestamps used by GNUnet, in seconds.