/*
  This file is part of GNUnet
  Copyright (C) 2017 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
*/
/**
 * @file sq/sq_query_helper.c
 * @brief helper functions for queries
 * @author Christian Grothoff
 */
#include "platform.h"
#include "gnunet_sq_lib.h"


/**
 * Function called to convert input argument into SQL parameters.
 *
 * @param cls closure
 * @param data pointer to input argument
 * @param data_len number of bytes in @a data (if applicable)
 * @param stmt sqlite statement to bind parameters for
 * @param off offset of the argument to bind in @a stmt, numbered from 1,
 *            so immediately suitable for passing to `sqlite3_bind`-functions.
 * @return #GNUNET_SYSERR on error, #GNUNET_OK on success
 */
static int
bind_fixed_blob (void *cls,
                 const void *data,
                 size_t data_len,
                 sqlite3_stmt *stmt,
                 unsigned int off)
{
  if (SQLITE_OK !=
      sqlite3_bind_blob64 (stmt,
                           (int) off,
                           data,
                           (sqlite3_uint64) data_len,
                           SQLITE_TRANSIENT))
    return GNUNET_SYSERR;
  return GNUNET_OK;
}


/**
 * Generate query parameter for a buffer @a ptr of
 * @a ptr_size bytes.
 *
 * @param ptr pointer to the query parameter to pass
 * @oaran ptr_size number of bytes in @a ptr
 */
struct GNUNET_SQ_QueryParam
GNUNET_SQ_query_param_fixed_size (const void *ptr,
				  size_t ptr_size)
{
  struct GNUNET_SQ_QueryParam qp = {
    .conv = &bind_fixed_blob,
    .data = ptr,
    .size = ptr_size,
    .num_params = 1
  };
  return qp;
}


/**
 * Function called to convert input argument into SQL parameters.
 *
 * @param cls closure
 * @param data pointer to input argument
 * @param data_len number of bytes in @a data (if applicable)
 * @param stmt sqlite statement to bind parameters for
 * @param off offset of the argument to bind in @a stmt, numbered from 1,
 *            so immediately suitable for passing to `sqlite3_bind`-functions.
 * @return #GNUNET_SYSERR on error, #GNUNET_OK on success
 */
static int
bind_string (void *cls,
             const void *data,
             size_t data_len,
             sqlite3_stmt *stmt,
             unsigned int off)
{
  if (NULL == data)
  {
    if (SQLITE_OK !=
        sqlite3_bind_null (stmt,
                           (int) off))
      return GNUNET_SYSERR;
    return GNUNET_OK;
  }
  if (SQLITE_OK !=
      sqlite3_bind_text (stmt,
                         (int) off,
                         (const char *) data,
                         -1,
                         SQLITE_TRANSIENT))
    return GNUNET_SYSERR;
  return GNUNET_OK;
}


/**
 * Generate query parameter for a string.
 *
 * @param ptr pointer to the string query parameter to pass
 */
struct GNUNET_SQ_QueryParam
GNUNET_SQ_query_param_string (const char *ptr)
{
  struct GNUNET_SQ_QueryParam qp = {
    .conv = &bind_string,
    .data = ptr,
    .num_params = 1
  };
  return qp;
}


/**
 * Function called to convert input argument into SQL parameters.
 *
 * @param cls closure
 * @param data pointer to input argument
 * @param data_len number of bytes in @a data (if applicable)
 * @param stmt sqlite statement to bind parameters for
 * @param off offset of the argument to bind in @a stmt, numbered from 1,
 *            so immediately suitable for passing to `sqlite3_bind`-functions.
 * @return #GNUNET_SYSERR on error, #GNUNET_OK on success
 */
static int
bind_rsa_pub (void *cls,
              const void *data,
              size_t data_len,
              sqlite3_stmt *stmt,
              unsigned int off)
{
  const struct GNUNET_CRYPTO_RsaPublicKey *rsa = data;
  char *buf;
  size_t buf_size;

  GNUNET_break (NULL == cls);
  buf_size = GNUNET_CRYPTO_rsa_public_key_encode (rsa,
						  &buf);
  if (SQLITE_OK !=
      sqlite3_bind_blob64 (stmt,
                           (int) off,
                           buf,
                           (sqlite3_uint64) buf_size,
                           SQLITE_TRANSIENT))
  {
    GNUNET_free (buf);
    return GNUNET_SYSERR;
  }
  GNUNET_free (buf);
  return GNUNET_OK;
}


/**
 * Generate query parameter for an RSA public key.  The
 * database must contain a BLOB type in the respective position.
 *
 * @param x the query parameter to pass.
 */
struct GNUNET_SQ_QueryParam
GNUNET_SQ_query_param_rsa_public_key (const struct GNUNET_CRYPTO_RsaPublicKey *x)
{
 struct GNUNET_SQ_QueryParam qp = {
    .conv = &bind_rsa_pub,
    .data = x,
    .num_params = 1
  };
 return qp;
}


/**
 * Function called to convert input argument into SQL parameters.
 *
 * @param cls closure
 * @param data pointer to input argument
 * @param data_len number of bytes in @a data (if applicable)
 * @param stmt sqlite statement to bind parameters for
 * @param off offset of the argument to bind in @a stmt, numbered from 1,
 *            so immediately suitable for passing to `sqlite3_bind`-functions.
 * @return #GNUNET_SYSERR on error, #GNUNET_OK on success
 */
static int
bind_rsa_sig (void *cls,
              const void *data,
              size_t data_len,
              sqlite3_stmt *stmt,
              unsigned int off)
{
  const struct GNUNET_CRYPTO_RsaSignature *sig = data;
  char *buf;
  size_t buf_size;

  GNUNET_break (NULL == cls);
  buf_size = GNUNET_CRYPTO_rsa_signature_encode (sig,
						 &buf);
  if (SQLITE_OK !=
      sqlite3_bind_blob64 (stmt,
                           (int) off,
                           buf,
                           (sqlite3_uint64) buf_size,
                           SQLITE_TRANSIENT))
  {
    GNUNET_free (buf);
    return GNUNET_SYSERR;
  }
  GNUNET_free (buf);
  return GNUNET_OK;
}


/**
 * Generate query parameter for an RSA signature.  The
 * database must contain a BLOB type in the respective position.
 *
 * @param x the query parameter to pass
 */
struct GNUNET_SQ_QueryParam
GNUNET_SQ_query_param_rsa_signature (const struct GNUNET_CRYPTO_RsaSignature *x)
{
 struct GNUNET_SQ_QueryParam qp = {
    .conv = &bind_rsa_sig,
    .data = x,
    .num_params = 1
  };
 return qp;
}


/**
 * Function called to convert input argument into SQL parameters.
 *
 * @param cls closure
 * @param data pointer to input argument
 * @param data_len number of bytes in @a data (if applicable)
 * @param stmt sqlite statement to bind parameters for
 * @param off offset of the argument to bind in @a stmt, numbered from 1,
 *            so immediately suitable for passing to `sqlite3_bind`-functions.
 * @return #GNUNET_SYSERR on error, #GNUNET_OK on success
 */
static int
bind_abstime (void *cls,
              const void *data,
              size_t data_len,
              sqlite3_stmt *stmt,
              unsigned int off)
{
  const struct GNUNET_TIME_Absolute *u = data;
  struct GNUNET_TIME_Absolute abs;

  abs = *u;
  if (abs.abs_value_us > INT64_MAX)
    abs.abs_value_us = INT64_MAX;
  GNUNET_assert (sizeof (uint64_t) == data_len);
  if (SQLITE_OK !=
      sqlite3_bind_int64 (stmt,
                          (int) off,
                          (sqlite3_int64) abs.abs_value_us))
    return GNUNET_SYSERR;
  return GNUNET_OK;
}


/**
 * Generate query parameter for an absolute time value.
 * The database must store a 64-bit integer.
 *
 * @param x pointer to the query parameter to pass
 */
struct GNUNET_SQ_QueryParam
GNUNET_SQ_query_param_absolute_time (const struct GNUNET_TIME_Absolute *x)
{
 struct GNUNET_SQ_QueryParam qp = {
    .conv = &bind_abstime,
    .data = x,
    .size = sizeof (struct GNUNET_TIME_Absolute),
    .num_params = 1
  };
  return qp;
}


/**
 * Function called to convert input argument into SQL parameters.
 *
 * @param cls closure
 * @param data pointer to input argument
 * @param data_len number of bytes in @a data (if applicable)
 * @param stmt sqlite statement to bind parameters for
 * @param off offset of the argument to bind in @a stmt, numbered from 1,
 *            so immediately suitable for passing to `sqlite3_bind`-functions.
 * @return #GNUNET_SYSERR on error, #GNUNET_OK on success
 */
static int
bind_nbotime (void *cls,
              const void *data,
              size_t data_len,
              sqlite3_stmt *stmt,
              unsigned int off)
{
  const struct GNUNET_TIME_AbsoluteNBO *u = data;
  struct GNUNET_TIME_Absolute abs;

  abs = GNUNET_TIME_absolute_ntoh (*u);
  if (abs.abs_value_us > INT64_MAX)
    abs.abs_value_us = INT64_MAX;
  GNUNET_assert (sizeof (uint64_t) == data_len);
  if (SQLITE_OK !=
      sqlite3_bind_int64 (stmt,
                          (int) off,
                          (sqlite3_int64) abs.abs_value_us))
    return GNUNET_SYSERR;
  return GNUNET_OK;
}


/**
 * Generate query parameter for an absolute time value.
 * The database must store a 64-bit integer.
 *
 * @param x pointer to the query parameter to pass
 */
struct GNUNET_SQ_QueryParam
GNUNET_SQ_query_param_absolute_time_nbo (const struct GNUNET_TIME_AbsoluteNBO *x)
{
 struct GNUNET_SQ_QueryParam qp = {
    .conv = &bind_nbotime,
    .data = x,
    .size = sizeof (struct GNUNET_TIME_AbsoluteNBO),
    .num_params = 1
  };
  return qp;
}


/**
 * Function called to convert input argument into SQL parameters.
 *
 * @param cls closure
 * @param data pointer to input argument
 * @param data_len number of bytes in @a data (if applicable)
 * @param stmt sqlite statement to bind parameters for
 * @param off offset of the argument to bind in @a stmt, numbered from 1,
 *            so immediately suitable for passing to `sqlite3_bind`-functions.
 * @return #GNUNET_SYSERR on error, #GNUNET_OK on success
 */
static int
bind_u16 (void *cls,
          const void *data,
          size_t data_len,
          sqlite3_stmt *stmt,
          unsigned int off)
{
  const uint16_t *u = data;

  GNUNET_assert (sizeof (uint16_t) == data_len);
  if (SQLITE_OK !=
      sqlite3_bind_int (stmt,
                        (int) off,
                        (int) *u))
    return GNUNET_SYSERR;
  return GNUNET_OK;
}


/**
 * Generate query parameter for an uint16_t in host byte order.
 *
 * @param x pointer to the query parameter to pass
 */
struct GNUNET_SQ_QueryParam
GNUNET_SQ_query_param_uint16 (const uint16_t *x)
{
 struct GNUNET_SQ_QueryParam qp = {
    .conv = &bind_u16,
    .data = x,
    .size = sizeof (uint16_t),
    .num_params = 1
  };
  return qp;
}


/**
 * Function called to convert input argument into SQL parameters.
 *
 * @param cls closure
 * @param data pointer to input argument
 * @param data_len number of bytes in @a data (if applicable)
 * @param stmt sqlite statement to bind parameters for
 * @param off offset of the argument to bind in @a stmt, numbered from 1,
 *            so immediately suitable for passing to `sqlite3_bind`-functions.
 * @return #GNUNET_SYSERR on error, #GNUNET_OK on success
 */
static int
bind_u32 (void *cls,
          const void *data,
          size_t data_len,
          sqlite3_stmt *stmt,
          unsigned int off)
{
  const uint32_t *u = data;

  GNUNET_assert (sizeof (uint32_t) == data_len);
  if (SQLITE_OK !=
      sqlite3_bind_int64 (stmt,
                          (int) off,
                          (sqlite3_int64) *u))
    return GNUNET_SYSERR;
  return GNUNET_OK;
}

/**
 * Generate query parameter for an uint32_t in host byte order.
 *
 * @param x pointer to the query parameter to pass
 */
struct GNUNET_SQ_QueryParam
GNUNET_SQ_query_param_uint32 (const uint32_t *x)
{
 struct GNUNET_SQ_QueryParam qp = {
    .conv = &bind_u32,
    .data = x,
    .size = sizeof (uint32_t),
    .num_params = 1
  };
  return qp;
}


/**
 * Function called to convert input argument into SQL parameters.
 *
 * @param cls closure
 * @param data pointer to input argument
 * @param data_len number of bytes in @a data (if applicable)
 * @param stmt sqlite statement to bind parameters for
 * @param off offset of the argument to bind in @a stmt, numbered from 1,
 *            so immediately suitable for passing to `sqlite3_bind`-functions.
 * @return #GNUNET_SYSERR on error, #GNUNET_OK on success
 */
static int
bind_u64 (void *cls,
          const void *data,
          size_t data_len,
          sqlite3_stmt *stmt,
          unsigned int off)
{
  const uint64_t *u = data;

  GNUNET_assert (sizeof (uint64_t) == data_len);
  if (SQLITE_OK !=
      sqlite3_bind_int64 (stmt,
                          (int) off,
                          (sqlite3_int64) *u))
    return GNUNET_SYSERR;
  return GNUNET_OK;
}


/**
 * Generate query parameter for an uint16_t in host byte order.
 *
 * @param x pointer to the query parameter to pass
 */
struct GNUNET_SQ_QueryParam
GNUNET_SQ_query_param_uint64 (const uint64_t *x)
{
  struct GNUNET_SQ_QueryParam qp = {
    .conv = &bind_u64,
    .data = x,
    .size = sizeof (uint64_t),
    .num_params = 1
  };
  return qp;
}

/* end of sq_query_helper.c */