2 This file is part of GNUnet
3 Copyright (C) 2014, 2015, 2016 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.
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.
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/>.
18 SPDX-License-Identifier: AGPL3.0-or-later
21 * @file pq/pq_query_helper.c
22 * @brief functions to initialize parameter arrays
23 * @author Christian Grothoff
26 #include "gnunet_util_lib.h"
27 #include "gnunet_pq_lib.h"
31 * Function called to convert input argument into SQL parameters.
34 * @param data pointer to input argument
35 * @param data_len number of bytes in @a data (if applicable)
36 * @param[out] param_values SQL data to set
37 * @param[out] param_lengths SQL length data to set
38 * @param[out] param_formats SQL format data to set
39 * @param param_length number of entries available in the @a param_values, @a param_lengths and @a param_formats arrays
40 * @param[out] scratch buffer for dynamic allocations (to be done via #GNUNET_malloc()
41 * @param scratch_length number of entries left in @a scratch
42 * @return -1 on error, number of offsets used in @a scratch otherwise
45 qconv_fixed(void *cls,
51 unsigned int param_length,
53 unsigned int scratch_length)
57 GNUNET_break(NULL == cls);
58 if (1 != param_length)
60 param_values[0] = (void *)data;
61 param_lengths[0] = data_len;
68 * Generate query parameter for a buffer @a ptr of
71 * @param ptr pointer to the query parameter to pass
72 * @oaran ptr_size number of bytes in @a ptr
74 struct GNUNET_PQ_QueryParam
75 GNUNET_PQ_query_param_fixed_size(const void *ptr,
78 struct GNUNET_PQ_QueryParam res =
79 { &qconv_fixed, NULL, ptr, ptr_size, 1 };
86 * Generate query parameter for a string.
88 * @param ptr pointer to the string query parameter to pass
90 struct GNUNET_PQ_QueryParam
91 GNUNET_PQ_query_param_string(const char *ptr)
93 return GNUNET_PQ_query_param_fixed_size(ptr, strlen(ptr));
98 * Function called to convert input argument into SQL parameters.
101 * @param data pointer to input argument
102 * @param data_len number of bytes in @a data (if applicable)
103 * @param[out] param_values SQL data to set
104 * @param[out] param_lengths SQL length data to set
105 * @param[out] param_formats SQL format data to set
106 * @param param_length number of entries available in the @a param_values, @a param_lengths and @a param_formats arrays
107 * @param[out] scratch buffer for dynamic allocations (to be done via #GNUNET_malloc()
108 * @param scratch_length number of entries left in @a scratch
109 * @return -1 on error, number of offsets used in @a scratch otherwise
112 qconv_uint16(void *cls,
115 void *param_values[],
118 unsigned int param_length,
120 unsigned int scratch_length)
122 const uint16_t *u_hbo = data;
126 (void)scratch_length;
127 GNUNET_break(NULL == cls);
128 if (1 != param_length)
130 u_nbo = GNUNET_new(uint16_t);
132 *u_nbo = htons(*u_hbo);
133 param_values[0] = (void *)u_nbo;
134 param_lengths[0] = sizeof(uint16_t);
135 param_formats[0] = 1;
141 * Generate query parameter for an uint16_t in host byte order.
143 * @param x pointer to the query parameter to pass
145 struct GNUNET_PQ_QueryParam
146 GNUNET_PQ_query_param_uint16(const uint16_t *x)
148 struct GNUNET_PQ_QueryParam res =
149 { &qconv_uint16, NULL, x, sizeof(*x), 1 };
156 * Function called to convert input argument into SQL parameters.
159 * @param data pointer to input argument
160 * @param data_len number of bytes in @a data (if applicable)
161 * @param[out] param_values SQL data to set
162 * @param[out] param_lengths SQL length data to set
163 * @param[out] param_formats SQL format data to set
164 * @param param_length number of entries available in the @a param_values, @a param_lengths and @a param_formats arrays
165 * @param[out] scratch buffer for dynamic allocations (to be done via #GNUNET_malloc()
166 * @param scratch_length number of entries left in @a scratch
167 * @return -1 on error, number of offsets used in @a scratch otherwise
170 qconv_uint32(void *cls,
173 void *param_values[],
176 unsigned int param_length,
178 unsigned int scratch_length)
180 const uint32_t *u_hbo = data;
184 (void)scratch_length;
185 GNUNET_break(NULL == cls);
186 if (1 != param_length)
188 u_nbo = GNUNET_new(uint32_t);
190 *u_nbo = htonl(*u_hbo);
191 param_values[0] = (void *)u_nbo;
192 param_lengths[0] = sizeof(uint32_t);
193 param_formats[0] = 1;
199 * Generate query parameter for an uint32_t in host byte order.
201 * @param x pointer to the query parameter to pass
203 struct GNUNET_PQ_QueryParam
204 GNUNET_PQ_query_param_uint32(const uint32_t *x)
206 struct GNUNET_PQ_QueryParam res =
207 { &qconv_uint32, NULL, x, sizeof(*x), 1 };
214 * Function called to convert input argument into SQL parameters.
217 * @param data pointer to input argument
218 * @param data_len number of bytes in @a data (if applicable)
219 * @param[out] param_values SQL data to set
220 * @param[out] param_lengths SQL length data to set
221 * @param[out] param_formats SQL format data to set
222 * @param param_length number of entries available in the @a param_values, @a param_lengths and @a param_formats arrays
223 * @param[out] scratch buffer for dynamic allocations (to be done via #GNUNET_malloc()
224 * @param scratch_length number of entries left in @a scratch
225 * @return -1 on error, number of offsets used in @a scratch otherwise
228 qconv_uint64(void *cls,
231 void *param_values[],
234 unsigned int param_length,
236 unsigned int scratch_length)
238 const uint64_t *u_hbo = data;
242 (void)scratch_length;
243 GNUNET_break(NULL == cls);
244 if (1 != param_length)
246 u_nbo = GNUNET_new(uint64_t);
248 *u_nbo = GNUNET_htonll(*u_hbo);
249 param_values[0] = (void *)u_nbo;
250 param_lengths[0] = sizeof(uint64_t);
251 param_formats[0] = 1;
257 * Generate query parameter for an uint64_t in host byte order.
259 * @param x pointer to the query parameter to pass
261 struct GNUNET_PQ_QueryParam
262 GNUNET_PQ_query_param_uint64(const uint64_t *x)
264 struct GNUNET_PQ_QueryParam res =
265 { &qconv_uint64, NULL, x, sizeof(*x), 1 };
272 * Function called to convert input argument into SQL parameters.
275 * @param data pointer to input argument
276 * @param data_len number of bytes in @a data (if applicable)
277 * @param[out] param_values SQL data to set
278 * @param[out] param_lengths SQL length data to set
279 * @param[out] param_formats SQL format data to set
280 * @param param_length number of entries available in the @a param_values, @a param_lengths and @a param_formats arrays
281 * @param[out] scratch buffer for dynamic allocations (to be done via #GNUNET_malloc()
282 * @param scratch_length number of entries left in @a scratch
283 * @return -1 on error, number of offsets used in @a scratch otherwise
286 qconv_rsa_public_key(void *cls,
289 void *param_values[],
292 unsigned int param_length,
294 unsigned int scratch_length)
296 const struct GNUNET_CRYPTO_RsaPublicKey *rsa = data;
300 GNUNET_break(NULL == cls);
301 if (1 != param_length)
303 buf_size = GNUNET_CRYPTO_rsa_public_key_encode(rsa,
306 param_values[0] = (void *)buf;
307 param_lengths[0] = buf_size - 1; /* DB doesn't like the trailing \0 */
308 param_formats[0] = 1;
314 * Generate query parameter for an RSA public key. The
315 * database must contain a BLOB type in the respective position.
317 * @param x the query parameter to pass
318 * @return array entry for the query parameters to use
320 struct GNUNET_PQ_QueryParam
321 GNUNET_PQ_query_param_rsa_public_key(const struct GNUNET_CRYPTO_RsaPublicKey *x)
323 struct GNUNET_PQ_QueryParam res =
324 { &qconv_rsa_public_key, NULL, (x), 0, 1 };
331 * Function called to convert input argument into SQL parameters.
334 * @param data pointer to input argument
335 * @param data_len number of bytes in @a data (if applicable)
336 * @param[out] param_values SQL data to set
337 * @param[out] param_lengths SQL length data to set
338 * @param[out] param_formats SQL format data to set
339 * @param param_length number of entries available in the @a param_values, @a param_lengths and @a param_formats arrays
340 * @param[out] scratch buffer for dynamic allocations (to be done via #GNUNET_malloc()
341 * @param scratch_length number of entries left in @a scratch
342 * @return -1 on error, number of offsets used in @a scratch otherwise
345 qconv_rsa_signature(void *cls,
348 void *param_values[],
351 unsigned int param_length,
353 unsigned int scratch_length)
355 const struct GNUNET_CRYPTO_RsaSignature *sig = data;
359 GNUNET_break(NULL == cls);
360 if (1 != param_length)
362 buf_size = GNUNET_CRYPTO_rsa_signature_encode(sig,
365 param_values[0] = (void *)buf;
366 param_lengths[0] = buf_size - 1; /* DB doesn't like the trailing \0 */
367 param_formats[0] = 1;
373 * Generate query parameter for an RSA signature. The
374 * database must contain a BLOB type in the respective position.
376 * @param x the query parameter to pass
377 * @return array entry for the query parameters to use
379 struct GNUNET_PQ_QueryParam
380 GNUNET_PQ_query_param_rsa_signature(const struct GNUNET_CRYPTO_RsaSignature *x)
382 struct GNUNET_PQ_QueryParam res =
383 { &qconv_rsa_signature, NULL, (x), 0, 1 };
390 * Function called to convert input argument into SQL parameters.
393 * @param data pointer to input argument
394 * @param data_len number of bytes in @a data (if applicable)
395 * @param[out] param_values SQL data to set
396 * @param[out] param_lengths SQL length data to set
397 * @param[out] param_formats SQL format data to set
398 * @param param_length number of entries available in the @a param_values, @a param_lengths and @a param_formats arrays
399 * @param[out] scratch buffer for dynamic allocations (to be done via #GNUNET_malloc()
400 * @param scratch_length number of entries left in @a scratch
401 * @return -1 on error, number of offsets used in @a scratch otherwise
404 qconv_abs_time(void *cls,
407 void *param_values[],
410 unsigned int param_length,
412 unsigned int scratch_length)
414 const struct GNUNET_TIME_Absolute *u = data;
415 struct GNUNET_TIME_Absolute abs;
418 GNUNET_break(NULL == cls);
419 if (1 != param_length)
422 if (abs.abs_value_us > INT64_MAX)
423 abs.abs_value_us = INT64_MAX;
424 u_nbo = GNUNET_new(uint64_t);
426 *u_nbo = GNUNET_htonll(abs.abs_value_us);
427 param_values[0] = (void *)u_nbo;
428 param_lengths[0] = sizeof(uint64_t);
429 param_formats[0] = 1;
435 * Generate query parameter for an absolute time value.
436 * The database must store a 64-bit integer.
438 * @param x pointer to the query parameter to pass
439 * @return array entry for the query parameters to use
441 struct GNUNET_PQ_QueryParam
442 GNUNET_PQ_query_param_absolute_time(const struct GNUNET_TIME_Absolute *x)
444 struct GNUNET_PQ_QueryParam res =
445 { &qconv_abs_time, NULL, x, sizeof(*x), 1 };
452 * Generate query parameter for an absolute time value.
453 * The database must store a 64-bit integer.
455 * @param x pointer to the query parameter to pass
457 struct GNUNET_PQ_QueryParam
458 GNUNET_PQ_query_param_absolute_time_nbo(const struct GNUNET_TIME_AbsoluteNBO *x)
460 return GNUNET_PQ_query_param_auto_from_type(&x->abs_value_us__);
464 /* end of pq_query_helper.c */