uncrustify as demanded.

1 files changed, 144 insertions, 138 deletions

diff --git a/src/pq/pq_query_helper.c b/src/pq/pq_query_helper.c
index a6ce3c5d8..c3b86ee3d 100644
--- a/src/pq/pq_query_helper.c
+++ b/src/pq/pq_query_helper.c
@@ -1,22 +1,22 @@
- /*
-  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
-*/
+/*
+   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
+ */
 /**
  * @file pq/pq_query_helper.c
  * @brief functions to initialize parameter arrays
@@ -42,22 +42,22 @@
  * @return -1 on error, number of offsets used in @a scratch otherwise
  */
 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)
+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);
+  (void)scratch;
+  (void)scratch_length;
+  GNUNET_break(NULL == cls);
   if (1 != param_length)
     return -1;
-  param_values[0] = (void *) data;
+  param_values[0] = (void *)data;
   param_lengths[0] = data_len;
   param_formats[0] = 1;
   return 0;
@@ -72,11 +72,12 @@ qconv_fixed (void *cls,
  * @oaran ptr_size number of bytes in @a ptr
  */
 struct GNUNET_PQ_QueryParam
-GNUNET_PQ_query_param_fixed_size (const void *ptr,
-                                  size_t ptr_size)
+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 };
+  { &qconv_fixed, NULL, ptr, ptr_size, 1 };
+
   return res;
 }
 
@@ -87,9 +88,9 @@ GNUNET_PQ_query_param_fixed_size (const void *ptr,
  * @param ptr pointer to the string query parameter to pass
  */
 struct GNUNET_PQ_QueryParam
-GNUNET_PQ_query_param_string (const char *ptr)
+GNUNET_PQ_query_param_string(const char *ptr)
 {
-  return GNUNET_PQ_query_param_fixed_size (ptr, strlen (ptr));
+  return GNUNET_PQ_query_param_fixed_size(ptr, strlen(ptr));
 }
 
 
@@ -108,29 +109,29 @@ GNUNET_PQ_query_param_string (const char *ptr)
  * @return -1 on error, number of offsets used in @a scratch otherwise
  */
 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)
+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);
+  (void)scratch;
+  (void)scratch_length;
+  GNUNET_break(NULL == cls);
   if (1 != param_length)
     return -1;
-  u_nbo = GNUNET_new (uint16_t);
+  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);
+  *u_nbo = htons(*u_hbo);
+  param_values[0] = (void *)u_nbo;
+  param_lengths[0] = sizeof(uint16_t);
   param_formats[0] = 1;
   return 1;
 }
@@ -142,10 +143,11 @@ qconv_uint16 (void *cls,
  * @param x pointer to the query parameter to pass
  */
 struct GNUNET_PQ_QueryParam
-GNUNET_PQ_query_param_uint16 (const uint16_t *x)
+GNUNET_PQ_query_param_uint16(const uint16_t *x)
 {
   struct GNUNET_PQ_QueryParam res =
-    { &qconv_uint16, NULL, x, sizeof (*x), 1 };
+  { &qconv_uint16, NULL, x, sizeof(*x), 1 };
+
   return res;
 }
 
@@ -165,29 +167,29 @@ GNUNET_PQ_query_param_uint16 (const uint16_t *x)
  * @return -1 on error, number of offsets used in @a scratch otherwise
  */
 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)
+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);
+  (void)scratch;
+  (void)scratch_length;
+  GNUNET_break(NULL == cls);
   if (1 != param_length)
     return -1;
-  u_nbo = GNUNET_new (uint32_t);
+  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);
+  *u_nbo = htonl(*u_hbo);
+  param_values[0] = (void *)u_nbo;
+  param_lengths[0] = sizeof(uint32_t);
   param_formats[0] = 1;
   return 1;
 }
@@ -199,10 +201,11 @@ qconv_uint32 (void *cls,
  * @param x pointer to the query parameter to pass
  */
 struct GNUNET_PQ_QueryParam
-GNUNET_PQ_query_param_uint32 (const uint32_t *x)
+GNUNET_PQ_query_param_uint32(const uint32_t *x)
 {
   struct GNUNET_PQ_QueryParam res =
-    { &qconv_uint32, NULL, x, sizeof (*x), 1 };
+  { &qconv_uint32, NULL, x, sizeof(*x), 1 };
+
   return res;
 }
 
@@ -222,29 +225,29 @@ GNUNET_PQ_query_param_uint32 (const uint32_t *x)
  * @return -1 on error, number of offsets used in @a scratch otherwise
  */
 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)
+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);
+  (void)scratch;
+  (void)scratch_length;
+  GNUNET_break(NULL == cls);
   if (1 != param_length)
     return -1;
-  u_nbo = GNUNET_new (uint64_t);
+  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);
+  *u_nbo = GNUNET_htonll(*u_hbo);
+  param_values[0] = (void *)u_nbo;
+  param_lengths[0] = sizeof(uint64_t);
   param_formats[0] = 1;
   return 1;
 }
@@ -256,10 +259,11 @@ qconv_uint64 (void *cls,
  * @param x pointer to the query parameter to pass
  */
 struct GNUNET_PQ_QueryParam
-GNUNET_PQ_query_param_uint64 (const uint64_t *x)
+GNUNET_PQ_query_param_uint64(const uint64_t *x)
 {
   struct GNUNET_PQ_QueryParam res =
-    { &qconv_uint64, NULL, x, sizeof (*x), 1 };
+  { &qconv_uint64, NULL, x, sizeof(*x), 1 };
+
   return res;
 }
 
@@ -279,27 +283,27 @@ GNUNET_PQ_query_param_uint64 (const uint64_t *x)
  * @return -1 on error, number of offsets used in @a scratch otherwise
  */
 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)
+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);
+  GNUNET_break(NULL == cls);
   if (1 != param_length)
     return -1;
-  buf_size = GNUNET_CRYPTO_rsa_public_key_encode (rsa,
-                                                  &buf);
+  buf_size = GNUNET_CRYPTO_rsa_public_key_encode(rsa,
+                                                 &buf);
   scratch[0] = buf;
-  param_values[0] = (void *) 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;
@@ -314,10 +318,11 @@ qconv_rsa_public_key (void *cls,
  * @return array entry for the query parameters to use
  */
 struct GNUNET_PQ_QueryParam
-GNUNET_PQ_query_param_rsa_public_key (const struct GNUNET_CRYPTO_RsaPublicKey *x)
+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 };
+  { &qconv_rsa_public_key, NULL, (x), 0, 1 };
+
   return res;
 }
 
@@ -337,27 +342,27 @@ GNUNET_PQ_query_param_rsa_public_key (const struct GNUNET_CRYPTO_RsaPublicKey *x
  * @return -1 on error, number of offsets used in @a scratch otherwise
  */
 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)
+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);
+  GNUNET_break(NULL == cls);
   if (1 != param_length)
     return -1;
-  buf_size = GNUNET_CRYPTO_rsa_signature_encode (sig,
-                                                 &buf);
+  buf_size = GNUNET_CRYPTO_rsa_signature_encode(sig,
+                                                &buf);
   scratch[0] = buf;
-  param_values[0] = (void *) 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;
@@ -372,10 +377,11 @@ qconv_rsa_signature (void *cls,
  * @return array entry for the query parameters to use
  */
 struct GNUNET_PQ_QueryParam
-GNUNET_PQ_query_param_rsa_signature (const struct GNUNET_CRYPTO_RsaSignature *x)
+GNUNET_PQ_query_param_rsa_signature(const struct GNUNET_CRYPTO_RsaSignature *x)
 {
   struct GNUNET_PQ_QueryParam res =
-    { &qconv_rsa_signature, NULL, (x), 0, 1 };
+  { &qconv_rsa_signature, NULL, (x), 0, 1 };
+
   return res;
 }
 
@@ -395,31 +401,31 @@ GNUNET_PQ_query_param_rsa_signature (const struct GNUNET_CRYPTO_RsaSignature *x)
  * @return -1 on error, number of offsets used in @a scratch otherwise
  */
 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)
+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);
+  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);
+  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);
+  *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;
 }
@@ -433,10 +439,10 @@ qconv_abs_time (void *cls,
  * @return array entry for the query parameters to use
  */
 struct GNUNET_PQ_QueryParam
-GNUNET_PQ_query_param_absolute_time (const struct GNUNET_TIME_Absolute *x)
+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 };
+  { &qconv_abs_time, NULL, x, sizeof(*x), 1 };
 
   return res;
 }
@@ -451,7 +457,7 @@ 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)
 {
-  return GNUNET_PQ_query_param_auto_from_type (&x->abs_value_us__);
+  return GNUNET_PQ_query_param_auto_from_type(&x->abs_value_us__);
 }