pq_query_helper.c

Go to the documentation of this file.

/*
   This file is part of GNUnet
   Copyright (C) 2014, 2015, 2016 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
 */
#include "platform.h"
#include "gnunet_util_lib.h"
#include "gnunet_pq_lib.h"


static int
qconv_fixed(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)
{
  (void)scratch;
  (void)scratch_length;
  GNUNET_break(NULL == cls);
  if (1 != param_length)
    return -1;
  param_values[0] = (void *)data;
  param_lengths[0] = data_len;
  param_formats[0] = 1;
  return 0;
}


struct GNUNET_PQ_QueryParam
GNUNET_PQ_query_param_fixed_size(const void *ptr,
                                 size_t ptr_size)
{
  struct GNUNET_PQ_QueryParam res =
  { &qconv_fixed, NULL, ptr, ptr_size, 1 };

  return res;
}


struct GNUNET_PQ_QueryParam
GNUNET_PQ_query_param_string(const char *ptr)
{
  return GNUNET_PQ_query_param_fixed_size(ptr, strlen(ptr));
}


static int
qconv_uint16(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)
{
  const uint16_t *u_hbo = data;
  uint16_t *u_nbo;

  (void)scratch;
  (void)scratch_length;
  GNUNET_break(NULL == cls);
  if (1 != param_length)
    return -1;
  u_nbo = GNUNET_new(uint16_t);
  scratch[0] = u_nbo;
  *u_nbo = htons(*u_hbo);
  param_values[0] = (void *)u_nbo;
  param_lengths[0] = sizeof(uint16_t);
  param_formats[0] = 1;
  return 1;
}


struct GNUNET_PQ_QueryParam
GNUNET_PQ_query_param_uint16(const uint16_t *x)
{
  struct GNUNET_PQ_QueryParam res =
  { &qconv_uint16, NULL, x, sizeof(*x), 1 };

  return res;
}


static int
qconv_uint32(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)
{
  const uint32_t *u_hbo = data;
  uint32_t *u_nbo;

  (void)scratch;
  (void)scratch_length;
  GNUNET_break(NULL == cls);
  if (1 != param_length)
    return -1;
  u_nbo = GNUNET_new(uint32_t);
  scratch[0] = u_nbo;
  *u_nbo = htonl(*u_hbo);
  param_values[0] = (void *)u_nbo;
  param_lengths[0] = sizeof(uint32_t);
  param_formats[0] = 1;
  return 1;
}


struct GNUNET_PQ_QueryParam
GNUNET_PQ_query_param_uint32(const uint32_t *x)
{
  struct GNUNET_PQ_QueryParam res =
  { &qconv_uint32, NULL, x, sizeof(*x), 1 };

  return res;
}


static int
qconv_uint64(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)
{
  const uint64_t *u_hbo = data;
  uint64_t *u_nbo;

  (void)scratch;
  (void)scratch_length;
  GNUNET_break(NULL == cls);
  if (1 != param_length)
    return -1;
  u_nbo = GNUNET_new(uint64_t);
  scratch[0] = u_nbo;
  *u_nbo = GNUNET_htonll(*u_hbo);
  param_values[0] = (void *)u_nbo;
  param_lengths[0] = sizeof(uint64_t);
  param_formats[0] = 1;
  return 1;
}


struct GNUNET_PQ_QueryParam
GNUNET_PQ_query_param_uint64(const uint64_t *x)
{
  struct GNUNET_PQ_QueryParam res =
  { &qconv_uint64, NULL, x, sizeof(*x), 1 };

  return res;
}


static int
qconv_rsa_public_key(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)
{
  const struct GNUNET_CRYPTO_RsaPublicKey *rsa = data;
  char *buf;
  size_t buf_size;

  GNUNET_break(NULL == cls);
  if (1 != param_length)
    return -1;
  buf_size = GNUNET_CRYPTO_rsa_public_key_encode(rsa,
                                                 &buf);
  scratch[0] = buf;
  param_values[0] = (void *)buf;
  param_lengths[0] = buf_size - 1; /* DB doesn't like the trailing \0 */
  param_formats[0] = 1;
  return 1;
}


struct GNUNET_PQ_QueryParam
GNUNET_PQ_query_param_rsa_public_key(const struct GNUNET_CRYPTO_RsaPublicKey *x)
{
  struct GNUNET_PQ_QueryParam res =
  { &qconv_rsa_public_key, NULL, (x), 0, 1 };

  return res;
}


static int
qconv_rsa_signature(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)
{
  const struct GNUNET_CRYPTO_RsaSignature *sig = data;
  char *buf;
  size_t buf_size;

  GNUNET_break(NULL == cls);
  if (1 != param_length)
    return -1;
  buf_size = GNUNET_CRYPTO_rsa_signature_encode(sig,
                                                &buf);
  scratch[0] = buf;
  param_values[0] = (void *)buf;
  param_lengths[0] = buf_size - 1; /* DB doesn't like the trailing \0 */
  param_formats[0] = 1;
  return 1;
}


struct GNUNET_PQ_QueryParam
GNUNET_PQ_query_param_rsa_signature(const struct GNUNET_CRYPTO_RsaSignature *x)
{
  struct GNUNET_PQ_QueryParam res =
  { &qconv_rsa_signature, NULL, (x), 0, 1 };

  return res;
}


static int
qconv_abs_time(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)
{
  const struct GNUNET_TIME_Absolute *u = data;
  struct GNUNET_TIME_Absolute abs;
  uint64_t *u_nbo;

  GNUNET_break(NULL == cls);
  if (1 != param_length)
    return -1;
  abs = *u;
  if (abs.abs_value_us > INT64_MAX)
    abs.abs_value_us = INT64_MAX;
  u_nbo = GNUNET_new(uint64_t);
  scratch[0] = u_nbo;
  *u_nbo = GNUNET_htonll(abs.abs_value_us);
  param_values[0] = (void *)u_nbo;
  param_lengths[0] = sizeof(uint64_t);
  param_formats[0] = 1;
  return 1;
}


struct GNUNET_PQ_QueryParam
GNUNET_PQ_query_param_absolute_time(const struct GNUNET_TIME_Absolute *x)
{
  struct GNUNET_PQ_QueryParam res =
  { &qconv_abs_time, NULL, x, sizeof(*x), 1 };

  return res;
}


struct GNUNET_PQ_QueryParam
GNUNET_PQ_query_param_absolute_time_nbo(const struct GNUNET_TIME_AbsoluteNBO *x)
{
  return GNUNET_PQ_query_param_auto_from_type(&x->abs_value_us__);
}


/* end of pq_query_helper.c */