gnunet_pq_lib.h

Go to the documentation of this file.

/*
   This file is part of GNUnet
   Copyright (C) 2016, 2017, 2020 GNUnet e.V.

   GNUnet is free software: you can redistribute it and/or modify it
   under the terms of the GNU Affero General Public License as published
   by the Free Software Foundation, either version 3 of the License,
   or (at your option) any later version.

   GNUnet is distributed in the hope that it will be useful, but
   WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   Affero General Public License for more details.

   You should have received a copy of the GNU Affero General Public License
   along with this program.  If not, see <http://www.gnu.org/licenses/>.

     SPDX-License-Identifier: AGPL3.0-or-later
 */
#ifndef GNUNET_PQ_LIB_H
#define GNUNET_PQ_LIB_H

#include <libpq-fe.h>
#include "gnunet_util_lib.h"
#include "gnunet_db_lib.h"

/* ************************* pq_query_helper.c functions ************************ */


typedef int
(*GNUNET_PQ_QueryConverter) (void *cls,
                             const void *data,
                             size_t data_len,
                             void *param_values[],
                             int param_lengths[],
                             int param_formats[],
                             unsigned int param_length,
                             void *scratch[],
                             unsigned int scratch_length);


struct GNUNET_PQ_QueryParam
{
  GNUNET_PQ_QueryConverter conv;

  void *conv_cls;

  const void *data;

  size_t size;

  unsigned int num_params;

};


#define GNUNET_PQ_query_param_end \
  {                               \
    NULL, NULL, NULL, 0, 0        \
  }


struct GNUNET_PQ_QueryParam
GNUNET_PQ_query_param_null (void);


struct GNUNET_PQ_QueryParam
GNUNET_PQ_query_param_fixed_size (const void *ptr,
                                  size_t ptr_size);


struct GNUNET_PQ_QueryParam
GNUNET_PQ_query_param_string (const char *ptr);


#define GNUNET_PQ_query_param_auto_from_type(x) \
  GNUNET_PQ_query_param_fixed_size ((x), sizeof(*(x)))


struct GNUNET_PQ_QueryParam
GNUNET_PQ_query_param_rsa_public_key (
  const struct GNUNET_CRYPTO_RsaPublicKey *x);


struct GNUNET_PQ_QueryParam
GNUNET_PQ_query_param_rsa_signature (
  const struct GNUNET_CRYPTO_RsaSignature *x);


struct GNUNET_PQ_QueryParam
GNUNET_PQ_query_param_relative_time (const struct GNUNET_TIME_Relative *x);


struct GNUNET_PQ_QueryParam
GNUNET_PQ_query_param_absolute_time (const struct GNUNET_TIME_Absolute *x);


struct GNUNET_PQ_QueryParam
GNUNET_PQ_query_param_absolute_time_nbo (
  const struct GNUNET_TIME_AbsoluteNBO *x);


struct GNUNET_PQ_QueryParam
GNUNET_PQ_query_param_uint16 (const uint16_t *x);


struct GNUNET_PQ_QueryParam
GNUNET_PQ_query_param_uint32 (const uint32_t *x);


struct GNUNET_PQ_QueryParam
GNUNET_PQ_query_param_uint64 (const uint64_t *x);


/* ************************* pq_result_helper.c functions ************************ */


typedef int
(*GNUNET_PQ_ResultConverter) (void *cls,
                              PGresult *result,
                              int row,
                              const char *fname,
                              size_t *dst_size,
                              void *dst);


typedef void
(*GNUNET_PQ_ResultCleanup) (void *cls,
                            void *rd);


struct GNUNET_PQ_ResultSpec
{
  GNUNET_PQ_ResultConverter conv;

  GNUNET_PQ_ResultCleanup cleaner;

  void *cls;

  void *dst;

  size_t dst_size;

  const char *fname;

  size_t *result_size;
  
  bool is_nullable;

  bool *is_null;

};


#define GNUNET_PQ_result_spec_end         \
  {                                       \
    NULL, NULL, NULL, NULL, 0, NULL, NULL \
  }


struct GNUNET_PQ_ResultSpec
GNUNET_PQ_result_spec_allow_null (struct GNUNET_PQ_ResultSpec rs,
                                  bool *is_null);


struct GNUNET_PQ_ResultSpec
GNUNET_PQ_result_spec_variable_size (const char *name,
                                     void **dst,
                                     size_t *sptr);


struct GNUNET_PQ_ResultSpec
GNUNET_PQ_result_spec_fixed_size (const char *name, void *dst, size_t dst_size);


#define GNUNET_PQ_result_spec_auto_from_type(name, dst) \
  GNUNET_PQ_result_spec_fixed_size (name, (dst), sizeof(*(dst)))


struct GNUNET_PQ_ResultSpec
GNUNET_PQ_result_spec_string (const char *name, char **dst);


struct GNUNET_PQ_ResultSpec
GNUNET_PQ_result_spec_rsa_public_key (const char *name,
                                      struct GNUNET_CRYPTO_RsaPublicKey **rsa);


struct GNUNET_PQ_ResultSpec
GNUNET_PQ_result_spec_rsa_signature (const char *name,
                                     struct GNUNET_CRYPTO_RsaSignature **sig);


struct GNUNET_PQ_ResultSpec
GNUNET_PQ_result_spec_absolute_time (const char *name,
                                     struct GNUNET_TIME_Absolute *at);


struct GNUNET_PQ_ResultSpec
GNUNET_PQ_result_spec_relative_time (const char *name,
                                     struct GNUNET_TIME_Relative *rt);


struct GNUNET_PQ_ResultSpec
GNUNET_PQ_result_spec_absolute_time_nbo (const char *name,
                                         struct GNUNET_TIME_AbsoluteNBO *at);


struct GNUNET_PQ_ResultSpec
GNUNET_PQ_result_spec_uint16 (const char *name, uint16_t *u16);


struct GNUNET_PQ_ResultSpec
GNUNET_PQ_result_spec_uint32 (const char *name, uint32_t *u32);


struct GNUNET_PQ_ResultSpec
GNUNET_PQ_result_spec_uint64 (const char *name, uint64_t *u64);


/* ************************* pq.c functions ************************ */

struct GNUNET_PQ_Context;


PGresult *
GNUNET_PQ_exec_prepared (struct GNUNET_PQ_Context *db,
                         const char *name,
                         const struct GNUNET_PQ_QueryParam *params);


int
GNUNET_PQ_extract_result (PGresult *result,
                          struct GNUNET_PQ_ResultSpec *rs,
                          int row);


void
GNUNET_PQ_cleanup_result (struct GNUNET_PQ_ResultSpec *rs);


/* ******************** pq_eval.c functions ************** */


enum GNUNET_DB_QueryStatus
GNUNET_PQ_eval_result (struct GNUNET_PQ_Context *db,
                       const char *statement_name,
                       PGresult *result);


enum GNUNET_DB_QueryStatus
GNUNET_PQ_eval_prepared_non_select (struct GNUNET_PQ_Context *db,
                                    const char *statement_name,
                                    const struct GNUNET_PQ_QueryParam *params);


typedef void
(*GNUNET_PQ_PostgresResultHandler) (void *cls,
                                    PGresult *result,
                                    unsigned int num_results);


enum GNUNET_DB_QueryStatus
GNUNET_PQ_eval_prepared_multi_select (struct GNUNET_PQ_Context *db,
                                      const char *statement_name,
                                      const struct GNUNET_PQ_QueryParam *params,
                                      GNUNET_PQ_PostgresResultHandler rh,
                                      void *rh_cls);


enum GNUNET_DB_QueryStatus
GNUNET_PQ_eval_prepared_singleton_select (struct GNUNET_PQ_Context *db,
                                          const char *statement_name,
                                          const struct
                                          GNUNET_PQ_QueryParam *params,
                                          struct GNUNET_PQ_ResultSpec *rs);


/* ******************** pq_prepare.c functions ************** */


struct GNUNET_PQ_PreparedStatement
{
  const char *name;

  const char *sql;

  unsigned int num_arguments;

};


#define GNUNET_PQ_PREPARED_STATEMENT_END \
  {                                      \
    NULL, NULL, 0                        \
  }


struct GNUNET_PQ_PreparedStatement
GNUNET_PQ_make_prepare (const char *name,
                        const char *sql,
                        unsigned int num_args);


int
GNUNET_PQ_prepare_statements (struct GNUNET_PQ_Context *db,
                              const struct GNUNET_PQ_PreparedStatement *ps);


/* ******************** pq_exec.c functions ************** */


struct GNUNET_PQ_ExecuteStatement
{
  const char *sql;

  int ignore_errors;
};


#define GNUNET_PQ_EXECUTE_STATEMENT_END \
  {                                     \
    NULL, GNUNET_SYSERR                 \
  }


struct GNUNET_PQ_ExecuteStatement
GNUNET_PQ_make_execute (const char *sql);


struct GNUNET_PQ_ExecuteStatement
GNUNET_PQ_make_try_execute (const char *sql);


int
GNUNET_PQ_exec_statements (struct GNUNET_PQ_Context *db,
                           const struct GNUNET_PQ_ExecuteStatement *es);


/* ******************** pq_connect.c functions ************** */


struct GNUNET_PQ_Context *
GNUNET_PQ_connect (const char *config_str,
                   const char *load_path,
                   const struct GNUNET_PQ_ExecuteStatement *es,
                   const struct GNUNET_PQ_PreparedStatement *ps);


struct GNUNET_PQ_Context *
GNUNET_PQ_connect_with_cfg (const struct GNUNET_CONFIGURATION_Handle *cfg,
                            const char *section,
                            const char *load_path_suffix,
                            const struct GNUNET_PQ_ExecuteStatement *es,
                            const struct GNUNET_PQ_PreparedStatement *ps);


void
GNUNET_PQ_reconnect_if_down (struct GNUNET_PQ_Context *db);


void
GNUNET_PQ_reconnect (struct GNUNET_PQ_Context *db);


int
GNUNET_PQ_run_sql (struct GNUNET_PQ_Context *db,
                   const char *load_path);


void
GNUNET_PQ_disconnect (struct GNUNET_PQ_Context *db);


#endif /* GNUNET_PQ_LIB_H_ */

/* end of include/gnunet_pq_lib.h */