src/pq/pq.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.c
  22  * @brief helper functions for libpq (PostGres) interactions
  23  * @author Sree Harsha Totakura <sreeharsha@totakura.in>
  24  * @author Florian Dold
  25  * @author Christian Grothoff
  26  */
  27 #include "platform.h"
  28 #include "gnunet_util_lib.h"
  29 #include "gnunet_pq_lib.h"
  30
  31
  32 /**
  33  * Execute a prepared statement.
  34  *
  35  * @param db_conn database connection
  36  * @param name name of the prepared statement
  37  * @param params parameters to the statement
  38  * @return postgres result
  39  */
  40 PGresult *
  41 GNUNET_PQ_exec_prepared(PGconn *db_conn,
  42                         const char *name,
  43                         const struct GNUNET_PQ_QueryParam *params)
  44 {
  45   unsigned int len;
  46   unsigned int i;
  47
  48   GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
  49              "Running prepared statement `%s' on %p\n",
  50              name,
  51              db_conn);
  52   /* count the number of parameters */
  53   len = 0;
  54   for (i = 0; 0 != params[i].num_params; i++)
  55     len += params[i].num_params;
  56
  57   /* new scope to allow stack allocation without alloca */
  58   {
  59     /* Scratch buffer for temporary storage */
  60     void *scratch[len];
  61     /* Parameter array we are building for the query */
  62     void *param_values[len];
  63     int param_lengths[len];
  64     int param_formats[len];
  65     unsigned int off;
  66     /* How many entries in the scratch buffer are in use? */
  67     unsigned int soff;
  68     PGresult *res;
  69     int ret;
  70
  71     off = 0;
  72     soff = 0;
  73     for (i = 0; 0 != params[i].num_params; i++)
  74       {
  75         const struct GNUNET_PQ_QueryParam *x = &params[i];
  76
  77         ret = x->conv(x->conv_cls,
  78                       x->data,
  79                       x->size,
  80                       &param_values[off],
  81                       &param_lengths[off],
  82                       &param_formats[off],
  83                       x->num_params,
  84                       &scratch[soff],
  85                       len - soff);
  86         if (ret < 0)
  87           {
  88             for (off = 0; off < soff; off++)
  89               GNUNET_free(scratch[off]);
  90             return NULL;
  91           }
  92         soff += ret;
  93         off += x->num_params;
  94       }
  95     GNUNET_assert(off == len);
  96     GNUNET_log_from(GNUNET_ERROR_TYPE_DEBUG,
  97                     "pq",
  98                     "Executing prepared SQL statement `%s'\n",
  99                     name);
 100     res = PQexecPrepared(db_conn,
 101                          name,
 102                          len,
 103                          (const char **)param_values,
 104                          param_lengths,
 105                          param_formats,
 106                          1);
 107     for (off = 0; off < soff; off++)
 108       GNUNET_free(scratch[off]);
 109     return res;
 110   }
 111 }
 112
 113
 114 /**
 115  * Free all memory that was allocated in @a rs during
 116  * #GNUNET_PQ_extract_result().
 117  *
 118  * @param rs reult specification to clean up
 119  */
 120 void
 121 GNUNET_PQ_cleanup_result(struct GNUNET_PQ_ResultSpec *rs)
 122 {
 123   unsigned int i;
 124
 125   for (i = 0; NULL != rs[i].conv; i++)
 126     if (NULL != rs[i].cleaner)
 127       rs[i].cleaner(rs[i].cls,
 128                     rs[i].dst);
 129 }
 130
 131
 132 /**
 133  * Extract results from a query result according to the given
 134  * specification.
 135  *
 136  * @param result result to process
 137  * @param[in,out] rs result specification to extract for
 138  * @param row row from the result to extract
 139  * @return
 140  *   #GNUNET_YES if all results could be extracted
 141  *   #GNUNET_SYSERR if a result was invalid (non-existing field)
 142  */
 143 int
 144 GNUNET_PQ_extract_result(PGresult *result,
 145                          struct GNUNET_PQ_ResultSpec *rs,
 146                          int row)
 147 {
 148   unsigned int i;
 149   int ret;
 150
 151   for (i = 0; NULL != rs[i].conv; i++)
 152     {
 153       struct GNUNET_PQ_ResultSpec *spec;
 154
 155       spec = &rs[i];
 156       ret = spec->conv(spec->cls,
 157                        result,
 158                        row,
 159                        spec->fname,
 160                        &spec->dst_size,
 161                        spec->dst);
 162       if (GNUNET_OK != ret)
 163         {
 164           GNUNET_PQ_cleanup_result(rs);
 165           return GNUNET_SYSERR;
 166         }
 167       if (NULL != spec->result_size)
 168         *spec->result_size = spec->dst_size;
 169     }
 170   return GNUNET_OK;
 171 }
 172
 173
 174 /* end of pq/pq.c */