src/pq/pq_query_helper.c

   1 /*
   2    This file is part of GNUnet
   3    Copyright (C) 2014, 2015, 2016 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  */
  20 /**
  21  * @file pq/pq_query_helper.c
  22  * @brief functions to initialize parameter arrays
  23  * @author Christian Grothoff
  24  */
  25 #include "platform.h"
  26 #include "gnunet_util_lib.h"
  27 #include "gnunet_pq_lib.h"
  28
  29
  30 /**
  31  * Function called to convert input argument into SQL parameters.
  32  *
  33  * @param cls closure
  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
  43  */
  44 static int
  45 qconv_fixed (void *cls,
  46              const void *data,
  47              size_t data_len,
  48              void *param_values[],
  49              int param_lengths[],
  50              int param_formats[],
  51              unsigned int param_length,
  52              void *scratch[],
  53              unsigned int scratch_length)
  54 {
  55   (void) scratch;
  56   (void) scratch_length;
  57   GNUNET_break (NULL == cls);
  58   if (1 != param_length)
  59     return -1;
  60   param_values[0] = (void *) data;
  61   param_lengths[0] = data_len;
  62   param_formats[0] = 1;
  63   return 0;
  64 }
  65
  66
  67 /**
  68  * Generate query parameter for a buffer @a ptr of
  69  * @a ptr_size bytes.
  70  *
  71  * @param ptr pointer to the query parameter to pass
  72  * @oaran ptr_size number of bytes in @a ptr
  73  */
  74 struct GNUNET_PQ_QueryParam
  75 GNUNET_PQ_query_param_fixed_size (const void *ptr,
  76                                   size_t ptr_size)
  77 {
  78   struct GNUNET_PQ_QueryParam res =
  79   { &qconv_fixed, NULL, ptr, ptr_size, 1 };
  80
  81   return res;
  82 }
  83
  84
  85 /**
  86  * Generate query parameter for a string.
  87  *
  88  * @param ptr pointer to the string query parameter to pass
  89  */
  90 struct GNUNET_PQ_QueryParam
  91 GNUNET_PQ_query_param_string (const char *ptr)
  92 {
  93   return GNUNET_PQ_query_param_fixed_size (ptr, strlen (ptr));
  94 }
  95
  96
  97 /**
  98  * Function called to convert input argument into SQL parameters.
  99  *
 100  * @param cls closure
 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
 110  */
 111 static int
 112 qconv_uint16 (void *cls,
 113               const void *data,
 114               size_t data_len,
 115               void *param_values[],
 116               int param_lengths[],
 117               int param_formats[],
 118               unsigned int param_length,
 119               void *scratch[],
 120               unsigned int scratch_length)
 121 {
 122   const uint16_t *u_hbo = data;
 123   uint16_t *u_nbo;
 124
 125   (void) scratch;
 126   (void) scratch_length;
 127   GNUNET_break (NULL == cls);
 128   if (1 != param_length)
 129     return -1;
 130   u_nbo = GNUNET_new (uint16_t);
 131   scratch[0] = u_nbo;
 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;
 136   return 1;
 137 }
 138
 139
 140 /**
 141  * Generate query parameter for an uint16_t in host byte order.
 142  *
 143  * @param x pointer to the query parameter to pass
 144  */
 145 struct GNUNET_PQ_QueryParam
 146 GNUNET_PQ_query_param_uint16 (const uint16_t *x)
 147 {
 148   struct GNUNET_PQ_QueryParam res =
 149   { &qconv_uint16, NULL, x, sizeof(*x), 1 };
 150
 151   return res;
 152 }
 153
 154
 155 /**
 156  * Function called to convert input argument into SQL parameters.
 157  *
 158  * @param cls closure
 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
 168  */
 169 static int
 170 qconv_uint32 (void *cls,
 171               const void *data,
 172               size_t data_len,
 173               void *param_values[],
 174               int param_lengths[],
 175               int param_formats[],
 176               unsigned int param_length,
 177               void *scratch[],
 178               unsigned int scratch_length)
 179 {
 180   const uint32_t *u_hbo = data;
 181   uint32_t *u_nbo;
 182
 183   (void) scratch;
 184   (void) scratch_length;
 185   GNUNET_break (NULL == cls);
 186   if (1 != param_length)
 187     return -1;
 188   u_nbo = GNUNET_new (uint32_t);
 189   scratch[0] = u_nbo;
 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;
 194   return 1;
 195 }
 196
 197
 198 /**
 199  * Generate query parameter for an uint32_t in host byte order.
 200  *
 201  * @param x pointer to the query parameter to pass
 202  */
 203 struct GNUNET_PQ_QueryParam
 204 GNUNET_PQ_query_param_uint32 (const uint32_t *x)
 205 {
 206   struct GNUNET_PQ_QueryParam res =
 207   { &qconv_uint32, NULL, x, sizeof(*x), 1 };
 208
 209   return res;
 210 }
 211
 212
 213 /**
 214  * Function called to convert input argument into SQL parameters.
 215  *
 216  * @param cls closure
 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
 226  */
 227 static int
 228 qconv_uint64 (void *cls,
 229               const void *data,
 230               size_t data_len,
 231               void *param_values[],
 232               int param_lengths[],
 233               int param_formats[],
 234               unsigned int param_length,
 235               void *scratch[],
 236               unsigned int scratch_length)
 237 {
 238   const uint64_t *u_hbo = data;
 239   uint64_t *u_nbo;
 240
 241   (void) scratch;
 242   (void) scratch_length;
 243   GNUNET_break (NULL == cls);
 244   if (1 != param_length)
 245     return -1;
 246   u_nbo = GNUNET_new (uint64_t);
 247   scratch[0] = u_nbo;
 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;
 252   return 1;
 253 }
 254
 255
 256 /**
 257  * Generate query parameter for an uint64_t in host byte order.
 258  *
 259  * @param x pointer to the query parameter to pass
 260  */
 261 struct GNUNET_PQ_QueryParam
 262 GNUNET_PQ_query_param_uint64 (const uint64_t *x)
 263 {
 264   struct GNUNET_PQ_QueryParam res =
 265   { &qconv_uint64, NULL, x, sizeof(*x), 1 };
 266
 267   return res;
 268 }
 269
 270
 271 /**
 272  * Function called to convert input argument into SQL parameters.
 273  *
 274  * @param cls closure
 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
 284  */
 285 static int
 286 qconv_rsa_public_key (void *cls,
 287                       const void *data,
 288                       size_t data_len,
 289                       void *param_values[],
 290                       int param_lengths[],
 291                       int param_formats[],
 292                       unsigned int param_length,
 293                       void *scratch[],
 294                       unsigned int scratch_length)
 295 {
 296   const struct GNUNET_CRYPTO_RsaPublicKey *rsa = data;
 297   char *buf;
 298   size_t buf_size;
 299
 300   GNUNET_break (NULL == cls);
 301   if (1 != param_length)
 302     return -1;
 303   buf_size = GNUNET_CRYPTO_rsa_public_key_encode (rsa,
 304                                                   &buf);
 305   scratch[0] = buf;
 306   param_values[0] = (void *) buf;
 307   param_lengths[0] = buf_size;
 308   param_formats[0] = 1;
 309   return 1;
 310 }
 311
 312
 313 /**
 314  * Generate query parameter for an RSA public key.  The
 315  * database must contain a BLOB type in the respective position.
 316  *
 317  * @param x the query parameter to pass
 318  * @return array entry for the query parameters to use
 319  */
 320 struct GNUNET_PQ_QueryParam
 321 GNUNET_PQ_query_param_rsa_public_key (const struct
 322                                       GNUNET_CRYPTO_RsaPublicKey *x)
 323 {
 324   struct GNUNET_PQ_QueryParam res =
 325   { &qconv_rsa_public_key, NULL, (x), 0, 1 };
 326
 327   return res;
 328 }
 329
 330
 331 /**
 332  * Function called to convert input argument into SQL parameters.
 333  *
 334  * @param cls closure
 335  * @param data pointer to input argument
 336  * @param data_len number of bytes in @a data (if applicable)
 337  * @param[out] param_values SQL data to set
 338  * @param[out] param_lengths SQL length data to set
 339  * @param[out] param_formats SQL format data to set
 340  * @param param_length number of entries available in the @a param_values, @a param_lengths and @a param_formats arrays
 341  * @param[out] scratch buffer for dynamic allocations (to be done via #GNUNET_malloc()
 342  * @param scratch_length number of entries left in @a scratch
 343  * @return -1 on error, number of offsets used in @a scratch otherwise
 344  */
 345 static int
 346 qconv_rsa_signature (void *cls,
 347                      const void *data,
 348                      size_t data_len,
 349                      void *param_values[],
 350                      int param_lengths[],
 351                      int param_formats[],
 352                      unsigned int param_length,
 353                      void *scratch[],
 354                      unsigned int scratch_length)
 355 {
 356   const struct GNUNET_CRYPTO_RsaSignature *sig = data;
 357   char *buf;
 358   size_t buf_size;
 359
 360   GNUNET_break (NULL == cls);
 361   if (1 != param_length)
 362     return -1;
 363   buf_size = GNUNET_CRYPTO_rsa_signature_encode (sig,
 364                                                  &buf);
 365   scratch[0] = buf;
 366   param_values[0] = (void *) buf;
 367   param_lengths[0] = buf_size;
 368   param_formats[0] = 1;
 369   return 1;
 370 }
 371
 372
 373 /**
 374  * Generate query parameter for an RSA signature.  The
 375  * database must contain a BLOB type in the respective position.
 376  *
 377  * @param x the query parameter to pass
 378  * @return array entry for the query parameters to use
 379  */
 380 struct GNUNET_PQ_QueryParam
 381 GNUNET_PQ_query_param_rsa_signature (const struct GNUNET_CRYPTO_RsaSignature *x)
 382 {
 383   struct GNUNET_PQ_QueryParam res =
 384   { &qconv_rsa_signature, NULL, (x), 0, 1 };
 385
 386   return res;
 387 }
 388
 389
 390 /**
 391  * Function called to convert input argument into SQL parameters.
 392  *
 393  * @param cls closure
 394  * @param data pointer to input argument
 395  * @param data_len number of bytes in @a data (if applicable)
 396  * @param[out] param_values SQL data to set
 397  * @param[out] param_lengths SQL length data to set
 398  * @param[out] param_formats SQL format data to set
 399  * @param param_length number of entries available in the @a param_values, @a param_lengths and @a param_formats arrays
 400  * @param[out] scratch buffer for dynamic allocations (to be done via #GNUNET_malloc()
 401  * @param scratch_length number of entries left in @a scratch
 402  * @return -1 on error, number of offsets used in @a scratch otherwise
 403  */
 404 static int
 405 qconv_abs_time (void *cls,
 406                 const void *data,
 407                 size_t data_len,
 408                 void *param_values[],
 409                 int param_lengths[],
 410                 int param_formats[],
 411                 unsigned int param_length,
 412                 void *scratch[],
 413                 unsigned int scratch_length)
 414 {
 415   const struct GNUNET_TIME_Absolute *u = data;
 416   struct GNUNET_TIME_Absolute abs;
 417   uint64_t *u_nbo;
 418
 419   GNUNET_break (NULL == cls);
 420   if (1 != param_length)
 421     return -1;
 422   abs = *u;
 423   if (abs.abs_value_us > INT64_MAX)
 424     abs.abs_value_us = INT64_MAX;
 425   u_nbo = GNUNET_new (uint64_t);
 426   scratch[0] = u_nbo;
 427   *u_nbo = GNUNET_htonll (abs.abs_value_us);
 428   param_values[0] = (void *) u_nbo;
 429   param_lengths[0] = sizeof(uint64_t);
 430   param_formats[0] = 1;
 431   return 1;
 432 }
 433
 434
 435 /**
 436  * Generate query parameter for an absolute time value.
 437  * The database must store a 64-bit integer.
 438  *
 439  * @param x pointer to the query parameter to pass
 440  * @return array entry for the query parameters to use
 441  */
 442 struct GNUNET_PQ_QueryParam
 443 GNUNET_PQ_query_param_absolute_time (const struct GNUNET_TIME_Absolute *x)
 444 {
 445   struct GNUNET_PQ_QueryParam res =
 446   { &qconv_abs_time, NULL, x, sizeof(*x), 1 };
 447
 448   return res;
 449 }
 450
 451
 452 /**
 453  * Generate query parameter for an absolute time value.
 454  * The database must store a 64-bit integer.
 455  *
 456  * @param x pointer to the query parameter to pass
 457  */
 458 struct GNUNET_PQ_QueryParam
 459 GNUNET_PQ_query_param_absolute_time_nbo (const struct
 460                                          GNUNET_TIME_AbsoluteNBO *x)
 461 {
 462   return GNUNET_PQ_query_param_auto_from_type (&x->abs_value_us__);
 463 }
 464
 465
 466 /* end of pq_query_helper.c */