GNUnet  0.10.x
sq_query_helper.c
Go to the documentation of this file.
1 /*
2  This file is part of GNUnet
3  Copyright (C) 2017 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 #include "platform.h"
26 #include "gnunet_sq_lib.h"
27 
28 
40 static int
41 bind_fixed_blob (void *cls,
42  const void *data,
43  size_t data_len,
44  sqlite3_stmt *stmt,
45  unsigned int off)
46 {
47  if (SQLITE_OK !=
48  sqlite3_bind_blob64 (stmt,
49  (int) off,
50  data,
51  (sqlite3_uint64) data_len,
52  SQLITE_TRANSIENT))
53  return GNUNET_SYSERR;
54  return GNUNET_OK;
55 }
56 
57 
67  size_t ptr_size)
68 {
69  struct GNUNET_SQ_QueryParam qp = {
71  .data = ptr,
72  .size = ptr_size,
73  .num_params = 1
74  };
75  return qp;
76 }
77 
78 
90 static int
91 bind_string (void *cls,
92  const void *data,
93  size_t data_len,
94  sqlite3_stmt *stmt,
95  unsigned int off)
96 {
97  if (NULL == data)
98  {
99  if (SQLITE_OK !=
100  sqlite3_bind_null (stmt,
101  (int) off))
102  return GNUNET_SYSERR;
103  return GNUNET_OK;
104  }
105  if (SQLITE_OK !=
106  sqlite3_bind_text (stmt,
107  (int) off,
108  (const char *) data,
109  -1,
110  SQLITE_TRANSIENT))
111  return GNUNET_SYSERR;
112  return GNUNET_OK;
113 }
114 
115 
123 {
124  struct GNUNET_SQ_QueryParam qp = {
125  .conv = &bind_string,
126  .data = ptr,
127  .num_params = 1
128  };
129  return qp;
130 }
131 
132 
144 static int
145 bind_rsa_pub (void *cls,
146  const void *data,
147  size_t data_len,
148  sqlite3_stmt *stmt,
149  unsigned int off)
150 {
151  const struct GNUNET_CRYPTO_RsaPublicKey *rsa = data;
152  char *buf;
153  size_t buf_size;
154 
155  GNUNET_break (NULL == cls);
156  buf_size = GNUNET_CRYPTO_rsa_public_key_encode (rsa,
157  &buf);
158  if (SQLITE_OK !=
159  sqlite3_bind_blob64 (stmt,
160  (int) off,
161  buf,
162  (sqlite3_uint64) buf_size,
163  SQLITE_TRANSIENT))
164  {
165  GNUNET_free (buf);
166  return GNUNET_SYSERR;
167  }
168  GNUNET_free (buf);
169  return GNUNET_OK;
170 }
171 
172 
181 {
182  struct GNUNET_SQ_QueryParam qp = {
183  .conv = &bind_rsa_pub,
184  .data = x,
185  .num_params = 1
186  };
187  return qp;
188 }
189 
190 
202 static int
203 bind_rsa_sig (void *cls,
204  const void *data,
205  size_t data_len,
206  sqlite3_stmt *stmt,
207  unsigned int off)
208 {
209  const struct GNUNET_CRYPTO_RsaSignature *sig = data;
210  char *buf;
211  size_t buf_size;
212 
213  GNUNET_break (NULL == cls);
214  buf_size = GNUNET_CRYPTO_rsa_signature_encode (sig,
215  &buf);
216  if (SQLITE_OK !=
217  sqlite3_bind_blob64 (stmt,
218  (int) off,
219  buf,
220  (sqlite3_uint64) buf_size,
221  SQLITE_TRANSIENT))
222  {
223  GNUNET_free (buf);
224  return GNUNET_SYSERR;
225  }
226  GNUNET_free (buf);
227  return GNUNET_OK;
228 }
229 
230 
239 {
240  struct GNUNET_SQ_QueryParam qp = {
241  .conv = &bind_rsa_sig,
242  .data = x,
243  .num_params = 1
244  };
245  return qp;
246 }
247 
248 
260 static int
261 bind_abstime (void *cls,
262  const void *data,
263  size_t data_len,
264  sqlite3_stmt *stmt,
265  unsigned int off)
266 {
267  const struct GNUNET_TIME_Absolute *u = data;
268  struct GNUNET_TIME_Absolute abs;
269 
270  abs = *u;
271  if (abs.abs_value_us > INT64_MAX)
272  abs.abs_value_us = INT64_MAX;
273  GNUNET_assert (sizeof (uint64_t) == data_len);
274  if (SQLITE_OK !=
275  sqlite3_bind_int64 (stmt,
276  (int) off,
277  (sqlite3_int64) abs.abs_value_us))
278  return GNUNET_SYSERR;
279  return GNUNET_OK;
280 }
281 
282 
291 {
292  struct GNUNET_SQ_QueryParam qp = {
293  .conv = &bind_abstime,
294  .data = x,
295  .size = sizeof (struct GNUNET_TIME_Absolute),
296  .num_params = 1
297  };
298  return qp;
299 }
300 
301 
313 static int
314 bind_nbotime (void *cls,
315  const void *data,
316  size_t data_len,
317  sqlite3_stmt *stmt,
318  unsigned int off)
319 {
320  const struct GNUNET_TIME_AbsoluteNBO *u = data;
321  struct GNUNET_TIME_Absolute abs;
322 
323  abs = GNUNET_TIME_absolute_ntoh (*u);
324  if (abs.abs_value_us > INT64_MAX)
325  abs.abs_value_us = INT64_MAX;
326  GNUNET_assert (sizeof (uint64_t) == data_len);
327  if (SQLITE_OK !=
328  sqlite3_bind_int64 (stmt,
329  (int) off,
330  (sqlite3_int64) abs.abs_value_us))
331  return GNUNET_SYSERR;
332  return GNUNET_OK;
333 }
334 
335 
344 {
345  struct GNUNET_SQ_QueryParam qp = {
346  .conv = &bind_nbotime,
347  .data = x,
348  .size = sizeof (struct GNUNET_TIME_AbsoluteNBO),
349  .num_params = 1
350  };
351  return qp;
352 }
353 
354 
366 static int
367 bind_u16 (void *cls,
368  const void *data,
369  size_t data_len,
370  sqlite3_stmt *stmt,
371  unsigned int off)
372 {
373  const uint16_t *u = data;
374 
375  GNUNET_assert (sizeof (uint16_t) == data_len);
376  if (SQLITE_OK !=
377  sqlite3_bind_int (stmt,
378  (int) off,
379  (int) *u))
380  return GNUNET_SYSERR;
381  return GNUNET_OK;
382 }
383 
384 
391 GNUNET_SQ_query_param_uint16 (const uint16_t *x)
392 {
393  struct GNUNET_SQ_QueryParam qp = {
394  .conv = &bind_u16,
395  .data = x,
396  .size = sizeof (uint16_t),
397  .num_params = 1
398  };
399  return qp;
400 }
401 
402 
414 static int
415 bind_u32 (void *cls,
416  const void *data,
417  size_t data_len,
418  sqlite3_stmt *stmt,
419  unsigned int off)
420 {
421  const uint32_t *u = data;
422 
423  GNUNET_assert (sizeof (uint32_t) == data_len);
424  if (SQLITE_OK !=
425  sqlite3_bind_int64 (stmt,
426  (int) off,
427  (sqlite3_int64) *u))
428  return GNUNET_SYSERR;
429  return GNUNET_OK;
430 }
431 
438 GNUNET_SQ_query_param_uint32 (const uint32_t *x)
439 {
440  struct GNUNET_SQ_QueryParam qp = {
441  .conv = &bind_u32,
442  .data = x,
443  .size = sizeof (uint32_t),
444  .num_params = 1
445  };
446  return qp;
447 }
448 
449 
461 static int
462 bind_u64 (void *cls,
463  const void *data,
464  size_t data_len,
465  sqlite3_stmt *stmt,
466  unsigned int off)
467 {
468  const uint64_t *u = data;
469 
470  GNUNET_assert (sizeof (uint64_t) == data_len);
471  if (SQLITE_OK !=
472  sqlite3_bind_int64 (stmt,
473  (int) off,
474  (sqlite3_int64) *u))
475  return GNUNET_SYSERR;
476  return GNUNET_OK;
477 }
478 
479 
486 GNUNET_SQ_query_param_uint64 (const uint64_t *x)
487 {
488  struct GNUNET_SQ_QueryParam qp = {
489  .conv = &bind_u64,
490  .data = x,
491  .size = sizeof (uint64_t),
492  .num_params = 1
493  };
494  return qp;
495 }
496 
497 /* end of sq_query_helper.c */
struct GNUNET_TIME_Absolute GNUNET_TIME_absolute_ntoh(struct GNUNET_TIME_AbsoluteNBO a)
Convert absolute time from network byte order.
Definition: time.c:670
static int bind_fixed_blob(void *cls, const void *data, size_t data_len, sqlite3_stmt *stmt, unsigned int off)
Function called to convert input argument into SQL parameters.
an RSA signature
Definition: crypto_rsa.c:63
static int bind_u16(void *cls, const void *data, size_t data_len, sqlite3_stmt *stmt, unsigned int off)
Function called to convert input argument into SQL parameters.
struct GNUNET_SQ_QueryParam GNUNET_SQ_query_param_uint64(const uint64_t *x)
Generate query parameter for an uint16_t in host byte order.
unsigned int num_params
Number of parameters eaten by this operation.
Definition: gnunet_sq_lib.h:80
static int bind_rsa_sig(void *cls, const void *data, size_t data_len, sqlite3_stmt *stmt, unsigned int off)
Function called to convert input argument into SQL parameters.
size_t GNUNET_CRYPTO_rsa_public_key_encode(const struct GNUNET_CRYPTO_RsaPublicKey *key, char **buffer)
Encode the public key in a format suitable for storing it into a file.
Definition: crypto_rsa.c:318
struct GNUNET_SQ_QueryParam GNUNET_SQ_query_param_string(const char *ptr)
Generate query parameter for a string.
size_t GNUNET_CRYPTO_rsa_signature_encode(const struct GNUNET_CRYPTO_RsaSignature *sig, char **buffer)
Encode the given signature in a format suitable for storing it into a file.
Definition: crypto_rsa.c:966
struct GNUNET_SQ_QueryParam GNUNET_SQ_query_param_rsa_signature(const struct GNUNET_CRYPTO_RsaSignature *x)
Generate query parameter for an RSA signature.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:78
struct GNUNET_SQ_QueryParam GNUNET_SQ_query_param_uint16(const uint16_t *x)
Generate query parameter for an uint16_t in host byte order.
static int bind_u32(void *cls, const void *data, size_t data_len, sqlite3_stmt *stmt, unsigned int off)
Function called to convert input argument into SQL parameters.
Time for absolute time used by GNUnet, in microseconds and in network byte order. ...
uint64_t abs_value_us
The actual value.
The public information of an RSA key pair.
Definition: crypto_rsa.c:51
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
struct GNUNET_SQ_QueryParam GNUNET_SQ_query_param_fixed_size(const void *ptr, size_t ptr_size)
Generate query parameter for a buffer ptr of ptr_size bytes.
static int bind_nbotime(void *cls, const void *data, size_t data_len, sqlite3_stmt *stmt, unsigned int off)
Function called to convert input argument into SQL parameters.
struct GNUNET_SQ_QueryParam GNUNET_SQ_query_param_rsa_public_key(const struct GNUNET_CRYPTO_RsaPublicKey *x)
Generate query parameter for an RSA public key.
struct GNUNET_SQ_QueryParam GNUNET_SQ_query_param_absolute_time_nbo(const struct GNUNET_TIME_AbsoluteNBO *x)
Generate query parameter for an absolute time value.
static char buf[2048]
static int bind_abstime(void *cls, const void *data, size_t data_len, sqlite3_stmt *stmt, unsigned int off)
Function called to convert input argument into SQL parameters.
static int bind_u64(void *cls, const void *data, size_t data_len, sqlite3_stmt *stmt, unsigned int off)
Function called to convert input argument into SQL parameters.
#define GNUNET_SYSERR
Definition: gnunet_common.h:79
struct GNUNET_SQ_QueryParam GNUNET_SQ_query_param_absolute_time(const struct GNUNET_TIME_Absolute *x)
Generate query parameter for an absolute time value.
helper functions for Sqlite3 DB interactions
Description of a DB query parameter.
Definition: gnunet_sq_lib.h:54
static int bind_rsa_pub(void *cls, const void *data, size_t data_len, sqlite3_stmt *stmt, unsigned int off)
Function called to convert input argument into SQL parameters.
size_t size
Size of data.
Definition: gnunet_sq_lib.h:75
struct GNUNET_SQ_QueryParam GNUNET_SQ_query_param_uint32(const uint32_t *x)
Generate query parameter for an uint32_t in host byte order.
GNUNET_SQ_QueryConverter conv
Function for how to handle this type of entry.
Definition: gnunet_sq_lib.h:60
Time for absolute times used by GNUnet, in microseconds.
uint32_t data
The data value.
static int bind_string(void *cls, const void *data, size_t data_len, sqlite3_stmt *stmt, unsigned int off)
Function called to convert input argument into SQL parameters.
#define GNUNET_free(ptr)
Wrapper around free.