src/my/my_query_helper.c

   1 /*
   2      This file is part of GNUnet
   3      Copyright (C) 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 my/my_query_helper.c
  22  * @brief library to help with access to a MySQL database
  23  * @author Christian Grothoff
  24  * @author Christophe Genevey
  25  */
  26 #include "platform.h"
  27 #include <mysql/mysql.h>
  28 #include "gnunet_my_lib.h"
  29
  30
  31 /**
  32  * Function called to clean up memory allocated
  33  * by a #GNUNET_MY_QueryConverter.
  34  *
  35  * @param cls closure
  36  * @param qbind array of parameter to clean up
  37  */
  38 static void
  39 my_clean_query(void *cls,
  40                MYSQL_BIND *qbind)
  41 {
  42   (void)cls;
  43   GNUNET_free(qbind[0].buffer);
  44 }
  45
  46
  47 /**
  48  * Function called to convert input argument into SQL parameters.
  49  *
  50  * @param cls closure
  51  * @param pq data about the query
  52  * @param qbind array of parameters to initialize
  53  * @return -1 on error
  54  */
  55 static int
  56 my_conv_fixed_size(void *cls,
  57                    const struct GNUNET_MY_QueryParam *qp,
  58                    MYSQL_BIND *qbind)
  59 {
  60   (void)cls;
  61   GNUNET_assert(1 == qp->num_params);
  62   qbind->buffer = (void *)qp->data;
  63   qbind->buffer_length = qp->data_len;
  64   qbind->buffer_type = MYSQL_TYPE_BLOB;
  65
  66   return 1;
  67 }
  68
  69
  70 /**
  71  * Generate query parameter for a buffer @a ptr of
  72  * @a ptr_size bytes.
  73  *
  74  * @param ptr pointer to the query parameter to pass
  75  * @param ptr_size number of bytes in @a ptr
  76  */
  77 struct GNUNET_MY_QueryParam
  78 GNUNET_MY_query_param_fixed_size(const void *ptr,
  79                                  size_t ptr_size)
  80 {
  81   struct GNUNET_MY_QueryParam qp = {
  82     .conv = &my_conv_fixed_size,
  83     .cleaner = NULL,
  84     .conv_cls = NULL,
  85     .num_params = 1,
  86     .data = ptr,
  87     .data_len = (unsigned long)ptr_size
  88   };
  89
  90   return qp;
  91 }
  92
  93
  94 /**
  95  * Function called to convert input argument into SQL parameters.
  96  *
  97  * @param cls closure
  98  * @param pq data about the query
  99  * @param qbind array of parameters to initialize
 100  * @return -1 on error
 101  */
 102 static int
 103 my_conv_string(void *cls,
 104                const struct GNUNET_MY_QueryParam *qp,
 105                MYSQL_BIND *qbind)
 106 {
 107   (void)cls;
 108   GNUNET_assert(1 == qp->num_params);
 109   qbind->buffer = (void *)qp->data;
 110   qbind->buffer_length = qp->data_len;
 111   qbind->buffer_type = MYSQL_TYPE_STRING;
 112   return 1;
 113 }
 114
 115
 116 /**
 117  * Generate query parameter for a string
 118  *
 119  * @param ptr pointer to the string query parameter to pass
 120  */
 121 struct GNUNET_MY_QueryParam
 122 GNUNET_MY_query_param_string(const char *ptr)
 123 {
 124   struct GNUNET_MY_QueryParam qp = {
 125     .conv = &my_conv_string,
 126     .cleaner = NULL,
 127     .conv_cls = NULL,
 128     .num_params = 1,
 129     .data = ptr,
 130     .data_len = strlen(ptr)
 131   };
 132
 133   return qp;
 134 }
 135
 136
 137 /**
 138  * Function called to convert input argument into SQL parameters
 139  *
 140  * @param cls closure
 141  * @param pq data about the query
 142  * @param qbind array of parameters to initialize
 143  * @return -1 on error
 144  */
 145 static int
 146 my_conv_uint16(void *cls,
 147                const struct GNUNET_MY_QueryParam *qp,
 148                MYSQL_BIND *qbind)
 149 {
 150   (void)cls;
 151   GNUNET_assert(1 == qp->num_params);
 152   qbind->buffer = (void *)qp->data;
 153   qbind->buffer_length = sizeof(uint16_t);
 154   qbind->buffer_type = MYSQL_TYPE_SHORT;
 155   qbind->is_unsigned = 1;
 156   return 1;
 157 }
 158
 159
 160 /**
 161  * Generate query parameter for an uint16_t in host byte order.
 162  *
 163  * @param x pointer to the query parameter to pass
 164  */
 165 struct GNUNET_MY_QueryParam
 166 GNUNET_MY_query_param_uint16(const uint16_t *x)
 167 {
 168   struct GNUNET_MY_QueryParam res = {
 169     .conv = &my_conv_uint16,
 170     .cleaner = NULL,
 171     .conv_cls = NULL,
 172     .num_params = 1,
 173     .data = x,
 174     .data_len = sizeof(*x)
 175   };
 176
 177   return res;
 178 }
 179
 180
 181 /**
 182  * Function called to convert input argument into SQL parameters
 183  *
 184  * @param cls closure
 185  * @param pq data about the query
 186  * @param qbind array of parameters to initialize
 187  * @return -1 on error
 188  */
 189 static int
 190 my_conv_uint32(void *cls,
 191                const struct GNUNET_MY_QueryParam *qp,
 192                MYSQL_BIND *qbind)
 193 {
 194   (void)cls;
 195   GNUNET_assert(1 == qp->num_params);
 196   qbind->buffer = (void *)qp->data;
 197   qbind->buffer_length = sizeof(uint32_t);
 198   qbind->buffer_type = MYSQL_TYPE_LONG;
 199   qbind->is_unsigned = 1;
 200   return 1;
 201 }
 202
 203
 204 /**
 205  * Generate query parameter for an uint32_t in host byte order
 206  *
 207  * @param x pointer to the query parameter to pass
 208  */
 209 struct GNUNET_MY_QueryParam
 210 GNUNET_MY_query_param_uint32(const uint32_t *x)
 211 {
 212   struct GNUNET_MY_QueryParam res = {
 213     .conv = &my_conv_uint32,
 214     .cleaner = NULL,
 215     .conv_cls = NULL,
 216     .num_params = 1,
 217     .data = x,
 218     .data_len = sizeof(*x)
 219   };
 220
 221   return res;
 222 }
 223
 224
 225 /**
 226  * Function called to convert input argument into SQL parameters
 227  *
 228  * @param cls closure
 229  * @param pq data about the query
 230  * @param qbind array of parameters to initialize
 231  * @return -1 on error
 232  */
 233 static int
 234 my_conv_uint64(void *cls,
 235                const struct GNUNET_MY_QueryParam *qp,
 236                MYSQL_BIND * qbind)
 237 {
 238   (void)cls;
 239   GNUNET_assert(1 == qp->num_params);
 240   qbind->buffer = (void *)qp->data;
 241   qbind->buffer_length = sizeof(uint64_t);
 242   qbind->buffer_type = MYSQL_TYPE_LONGLONG;
 243   qbind->is_unsigned = 1;
 244   return 1;
 245 }
 246
 247
 248 /**
 249  * Generate query parameter for an uint64_t in host byte order
 250  *
 251  * @param x pointer to the query parameter to pass
 252  */
 253 struct GNUNET_MY_QueryParam
 254 GNUNET_MY_query_param_uint64(const uint64_t *x)
 255 {
 256   struct GNUNET_MY_QueryParam res = {
 257     .conv = &my_conv_uint64,
 258     .cleaner = NULL,
 259     .conv_cls = NULL,
 260     .num_params = 1,
 261     .data = x,
 262     .data_len = sizeof(*x)
 263   };
 264
 265   return res;
 266 }
 267
 268
 269 /**
 270  * Function called to convert input argument into SQL parameters
 271  *
 272  * @param cls closure
 273  * @param pq data about the query
 274  * @param qbind array of parameters to initialize
 275  * @return -1 on error
 276  */
 277 static int
 278 my_conv_rsa_public_key(void *cls,
 279                        const struct GNUNET_MY_QueryParam *qp,
 280                        MYSQL_BIND * qbind)
 281 {
 282   const struct GNUNET_CRYPTO_RsaPublicKey *rsa = qp->data;
 283   char *buf;
 284   size_t buf_size;
 285
 286   (void)cls;
 287   GNUNET_assert(1 == qp->num_params);
 288   buf_size = GNUNET_CRYPTO_rsa_public_key_encode(rsa,
 289                                                  &buf);
 290   qbind->buffer = (void *)buf;
 291   qbind->buffer_length = buf_size;
 292   qbind->buffer_type = MYSQL_TYPE_BLOB;
 293   return 1;
 294 }
 295
 296
 297 /**
 298  * Generate query parameter for an RSA public key. The
 299  * database must contain a BLOB type in the respective position.
 300  *
 301  * @param x the query parameter to pass
 302  * @return array entry for the query parameters to use
 303  */
 304 struct GNUNET_MY_QueryParam
 305 GNUNET_MY_query_param_rsa_public_key(const struct GNUNET_CRYPTO_RsaPublicKey *x)
 306 {
 307   struct GNUNET_MY_QueryParam res = {
 308     .conv = &my_conv_rsa_public_key,
 309     .cleaner = &my_clean_query,
 310     .conv_cls = NULL,
 311     .num_params = 1,
 312     .data = x,
 313     .data_len = 0
 314   };
 315
 316   return res;
 317 }
 318
 319
 320 /**
 321  * Function called to convert input argument into SQL parameters
 322  *
 323  *@param cls closure
 324  *@param pq data about the query
 325  *@param qbind array of parameters to initialize
 326  *@return -1 on error
 327  */
 328 static int
 329 my_conv_rsa_signature(void *cls,
 330                       const struct GNUNET_MY_QueryParam *qp,
 331                       MYSQL_BIND *qbind)
 332 {
 333   const struct GNUNET_CRYPTO_RsaSignature *sig = qp->data;
 334   char *buf;
 335   size_t buf_size;
 336
 337   (void)cls;
 338   GNUNET_assert(1 == qp->num_params);
 339   buf_size = GNUNET_CRYPTO_rsa_signature_encode(sig,
 340                                                 &buf);
 341   qbind->buffer = (void *)buf;
 342   qbind->buffer_length = buf_size;
 343   qbind->buffer_type = MYSQL_TYPE_BLOB;
 344   return 1;
 345 }
 346
 347
 348 /**
 349  * Generate query parameter for an RSA signature. The
 350  * database must contain a BLOB type in the respective position
 351  *
 352  * @param x the query parameter to pass
 353  * @return array entry for the query parameters to use
 354  */
 355 struct GNUNET_MY_QueryParam
 356 GNUNET_MY_query_param_rsa_signature(const struct GNUNET_CRYPTO_RsaSignature *x)
 357 {
 358   struct GNUNET_MY_QueryParam res = {
 359     .conv = &my_conv_rsa_signature,
 360     .cleaner = &my_clean_query,
 361     .conv_cls = NULL,
 362     .num_params = 1,
 363     .data = (x),
 364     .data_len = 0
 365   };
 366
 367   return res;
 368 }
 369
 370
 371 /**
 372  * Generate query parameter for an absolute time value.
 373  * The database must store a 64-bit integer.
 374  *
 375  * @param x pointer to the query parameter to pass
 376  * @return array entry for the query parameters to use
 377  */
 378 struct GNUNET_MY_QueryParam
 379 GNUNET_MY_query_param_absolute_time(const struct GNUNET_TIME_Absolute *x)
 380 {
 381   return GNUNET_MY_query_param_uint64(&x->abs_value_us);
 382 }
 383
 384
 385 /**
 386  * Generate query parameter for an absolute time value.
 387  * The database must store a 64-bit integer.
 388  *
 389  * @param x pointer to the query parameter to pass
 390  */
 391 struct GNUNET_MY_QueryParam
 392 GNUNET_MY_query_param_absolute_time_nbo(const struct GNUNET_TIME_AbsoluteNBO *x)
 393 {
 394   return GNUNET_MY_query_param_auto_from_type(&x->abs_value_us__);
 395 }
 396
 397
 398 /* end of my_query_helper.c */