GNUnet  0.20.0
pq_result_helper.c
Go to the documentation of this file.
1 /*
2  This file is part of GNUnet
3  Copyright (C) 2014, 2015, 2016, 2020 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  */
26 #include "platform.h"
27 #include "gnunet_time_lib.h"
28 #include "gnunet_common.h"
29 #include "gnunet_util_lib.h"
30 #include "gnunet_pq_lib.h"
31 #include "pq.h"
32 
33 
36  bool *is_null)
37 {
38  struct GNUNET_PQ_ResultSpec rsr;
39 
40  rsr = rs;
41  rsr.is_nullable = true;
42  rsr.is_null = is_null;
43  return rsr;
44 }
45 
46 
54 static void
56  void *rd)
57 {
58  void **dst = rd;
59 
60  (void) cls;
61  if (NULL != *dst)
62  {
63  GNUNET_free (*dst);
64  *dst = NULL;
65  }
66 }
67 
68 
82 static enum GNUNET_GenericReturnValue
84  PGresult *result,
85  int row,
86  const char *fname,
87  size_t *dst_size,
88  void *dst)
89 {
90  size_t len;
91  const char *res;
92  void *idst;
93  int fnum;
94 
95  (void) cls;
96  *dst_size = 0;
97  *((void **) dst) = NULL;
98 
99  fnum = PQfnumber (result,
100  fname);
101  if (fnum < 0)
102  {
103  GNUNET_break (0);
104  return GNUNET_SYSERR;
105  }
106  if (PQgetisnull (result,
107  row,
108  fnum))
109  return GNUNET_NO;
110  /* if a field is null, continue but
111  * remember that we now return a different result */
112  len = PQgetlength (result,
113  row,
114  fnum);
115  res = PQgetvalue (result,
116  row,
117  fnum);
118  GNUNET_assert (NULL != res);
119  *dst_size = len;
120  idst = GNUNET_malloc (len);
121  *((void **) dst) = idst;
122  GNUNET_memcpy (idst,
123  res,
124  len);
125  return GNUNET_OK;
126 }
127 
128 
131  void **dst,
132  size_t *sptr)
133 {
134  struct GNUNET_PQ_ResultSpec res = {
135  .conv = &extract_varsize_blob,
136  .cleaner = &clean_varsize_blob,
137  .dst = (void *) (dst),
138  .fname = name,
139  .result_size = sptr
140  };
141 
142  return res;
143 }
144 
145 
159 static enum GNUNET_GenericReturnValue
160 extract_fixed_blob (void *cls,
161  PGresult *result,
162  int row,
163  const char *fname,
164  size_t *dst_size,
165  void *dst)
166 {
167  size_t len;
168  const char *res;
169  int fnum;
170 
171  (void) cls;
172  fnum = PQfnumber (result,
173  fname);
174  if (fnum < 0)
175  {
176  GNUNET_break (0);
178  "Result does not have field %s\n",
179  fname);
180  return GNUNET_SYSERR;
181  }
182  if (PQgetisnull (result,
183  row,
184  fnum))
185  return GNUNET_NO;
186  /* if a field is null, continue but
187  * remember that we now return a different result */
188  len = PQgetlength (result,
189  row,
190  fnum);
191  if (*dst_size != len)
192  {
194  "Expected %u bytes for field `%s', got %u\n",
195  (unsigned int) *dst_size,
196  fname,
197  (unsigned int) len);
198  GNUNET_break (0);
199  return GNUNET_SYSERR;
200  }
201  res = PQgetvalue (result,
202  row,
203  fnum);
204  GNUNET_assert (NULL != res);
206  res,
207  len);
208  return GNUNET_OK;
209 }
210 
211 
214  void *dst,
215  size_t dst_size)
216 {
217  struct GNUNET_PQ_ResultSpec res = {
218  .conv = &extract_fixed_blob,
219  .dst = (dst),
220  .dst_size = dst_size,
221  .fname = name
222  };
223 
224  return res;
225 }
226 
227 
241 static enum GNUNET_GenericReturnValue
243  PGresult *result,
244  int row,
245  const char *fname,
246  size_t *dst_size,
247  void *dst)
248 {
249  struct GNUNET_CRYPTO_RsaPublicKey **pk = dst;
250  size_t len;
251  const char *res;
252  int fnum;
253 
254  (void) cls;
255  *pk = NULL;
256  fnum = PQfnumber (result,
257  fname);
258  if (fnum < 0)
259  {
260  GNUNET_break (0);
261  return GNUNET_SYSERR;
262  }
263  if (PQgetisnull (result,
264  row,
265  fnum))
266  return GNUNET_NO;
267 
268  /* if a field is null, continue but
269  * remember that we now return a different result */
270  len = PQgetlength (result,
271  row,
272  fnum);
273  res = PQgetvalue (result,
274  row,
275  fnum);
277  len);
278  if (NULL == *pk)
279  {
280  GNUNET_break (0);
281  return GNUNET_SYSERR;
282  }
283  return GNUNET_OK;
284 }
285 
286 
294 static void
296  void *rd)
297 {
298  struct GNUNET_CRYPTO_RsaPublicKey **pk = rd;
299 
300  (void) cls;
301  if (NULL != *pk)
302  {
304  *pk = NULL;
305  }
306 }
307 
308 
311  struct GNUNET_CRYPTO_RsaPublicKey **rsa)
312 {
313  struct GNUNET_PQ_ResultSpec res = {
314  .conv = &extract_rsa_public_key,
315  .cleaner = &clean_rsa_public_key,
316  .dst = (void *) rsa,
317  .fname = name
318  };
319 
320  return res;
321 }
322 
323 
337 static enum GNUNET_GenericReturnValue
339  PGresult *result,
340  int row,
341  const char *fname,
342  size_t *dst_size,
343  void *dst)
344 {
345  struct GNUNET_CRYPTO_RsaSignature **sig = dst;
346  size_t len;
347  const void *res;
348  int fnum;
349 
350  (void) cls;
351  *sig = NULL;
352  fnum = PQfnumber (result,
353  fname);
354  if (fnum < 0)
355  {
356  GNUNET_break (0);
357  return GNUNET_SYSERR;
358  }
359  if (PQgetisnull (result,
360  row,
361  fnum))
362  return GNUNET_NO;
363  /* if a field is null, continue but
364  * remember that we now return a different result */
365  len = PQgetlength (result,
366  row,
367  fnum);
368  res = PQgetvalue (result,
369  row,
370  fnum);
372  len);
373  if (NULL == *sig)
374  {
375  GNUNET_break (0);
376  return GNUNET_SYSERR;
377  }
378  return GNUNET_OK;
379 }
380 
381 
389 static void
391  void *rd)
392 {
393  struct GNUNET_CRYPTO_RsaSignature **sig = rd;
394 
395  (void) cls;
396  if (NULL != *sig)
397  {
399  *sig = NULL;
400  }
401 }
402 
403 
406  struct GNUNET_CRYPTO_RsaSignature **sig)
407 {
408  struct GNUNET_PQ_ResultSpec res = {
409  .conv = &extract_rsa_signature,
410  .cleaner = &clean_rsa_signature,
411  .dst = (void *) sig,
412  .fname = name
413  };
414 
415  return res;
416 }
417 
418 
432 static enum GNUNET_GenericReturnValue
433 extract_string (void *cls,
434  PGresult *result,
435  int row,
436  const char *fname,
437  size_t *dst_size,
438  void *dst)
439 {
440  char **str = dst;
441  size_t len;
442  const char *res;
443  int fnum;
444 
445  (void) cls;
446  *str = NULL;
447  fnum = PQfnumber (result,
448  fname);
449  if (fnum < 0)
450  {
451  GNUNET_break (0);
452  return GNUNET_SYSERR;
453  }
454  if (PQgetisnull (result,
455  row,
456  fnum))
457  return GNUNET_NO;
458  /* if a field is null, continue but
459  * remember that we now return a different result */
460  len = PQgetlength (result,
461  row,
462  fnum);
463  res = PQgetvalue (result,
464  row,
465  fnum);
466  *str = GNUNET_strndup (res,
467  len);
468  if (NULL == *str)
469  {
470  GNUNET_break (0);
471  return GNUNET_SYSERR;
472  }
473  return GNUNET_OK;
474 }
475 
476 
484 static void
486  void *rd)
487 {
488  char **str = rd;
489 
490  (void) cls;
491  if (NULL != *str)
492  {
493  GNUNET_free (*str);
494  *str = NULL;
495  }
496 }
497 
498 
501  char **dst)
502 {
503  struct GNUNET_PQ_ResultSpec res = {
504  .conv = &extract_string,
505  .cleaner = &clean_string,
506  .dst = (void *) dst,
507  .fname = (name)
508  };
509 
510  return res;
511 }
512 
513 
527 static enum GNUNET_GenericReturnValue
528 extract_bool (void *cls,
529  PGresult *result,
530  int row,
531  const char *fname,
532  size_t *dst_size,
533  void *dst)
534 {
535  bool *b = dst;
536  const uint8_t *res;
537  int fnum;
538  size_t len;
539 
540  (void) cls;
541  fnum = PQfnumber (result,
542  fname);
543  if (fnum < 0)
544  {
545  GNUNET_break (0);
546  return GNUNET_SYSERR;
547  }
548  if (PQgetisnull (result,
549  row,
550  fnum))
551  return GNUNET_NO;
552  /* if a field is null, continue but
553  * remember that we now return a different result */
554  len = PQgetlength (result,
555  row,
556  fnum);
557  if (sizeof (uint8_t) != len)
558  {
559  GNUNET_break (0);
560  return GNUNET_SYSERR;
561  }
562  res = (const uint8_t *) PQgetvalue (result,
563  row,
564  fnum);
565  *b = (0 != *res);
566  return GNUNET_OK;
567 }
568 
569 
571 GNUNET_PQ_result_spec_bool (const char *name,
572  bool *dst)
573 {
574  struct GNUNET_PQ_ResultSpec res = {
575  .conv = &extract_bool,
576  .dst = (void *) dst,
577  .fname = name
578  };
579 
580  return res;
581 }
582 
583 
597 static enum GNUNET_GenericReturnValue
598 extract_rel_time (void *cls,
599  PGresult *result,
600  int row,
601  const char *fname,
602  size_t *dst_size,
603  void *dst)
604 {
605  struct GNUNET_TIME_Relative *udst = dst;
606  const int64_t *res;
607  int fnum;
608 
609  (void) cls;
610  fnum = PQfnumber (result,
611  fname);
612  if (fnum < 0)
613  {
614  GNUNET_break (0);
615  return GNUNET_SYSERR;
616  }
617  if (PQgetisnull (result,
618  row,
619  fnum))
620  return GNUNET_NO;
621  GNUNET_assert (NULL != dst);
622  if (sizeof(struct GNUNET_TIME_Relative) != *dst_size)
623  {
624  GNUNET_break (0);
625  return GNUNET_SYSERR;
626  }
627  if (sizeof(int64_t) !=
628  PQgetlength (result,
629  row,
630  fnum))
631  {
632  GNUNET_break (0);
633  return GNUNET_SYSERR;
634  }
635  res = (int64_t *) PQgetvalue (result,
636  row,
637  fnum);
638  if (INT64_MAX == GNUNET_ntohll ((uint64_t) *res))
640  else
641  udst->rel_value_us = GNUNET_ntohll ((uint64_t) *res);
642  return GNUNET_OK;
643 }
644 
645 
648  struct GNUNET_TIME_Relative *rt)
649 {
650  struct GNUNET_PQ_ResultSpec res = {
651  .conv = &extract_rel_time,
652  .dst = (void *) rt,
653  .dst_size = sizeof(*rt),
654  .fname = name
655  };
656 
657  return res;
658 }
659 
660 
674 static enum GNUNET_GenericReturnValue
675 extract_abs_time (void *cls,
676  PGresult *result,
677  int row,
678  const char *fname,
679  size_t *dst_size,
680  void *dst)
681 {
682  struct GNUNET_TIME_Absolute *udst = dst;
683  const int64_t *res;
684  int fnum;
685 
686  (void) cls;
687  fnum = PQfnumber (result,
688  fname);
689  if (fnum < 0)
690  {
691  GNUNET_break (0);
692  return GNUNET_SYSERR;
693  }
694  if (PQgetisnull (result,
695  row,
696  fnum))
697  return GNUNET_NO;
698  GNUNET_assert (NULL != dst);
699  if (sizeof(struct GNUNET_TIME_Absolute) != *dst_size)
700  {
701  GNUNET_break (0);
702  return GNUNET_SYSERR;
703  }
704  if (sizeof(int64_t) !=
705  PQgetlength (result,
706  row,
707  fnum))
708  {
709  GNUNET_break (0);
710  return GNUNET_SYSERR;
711  }
712  res = (int64_t *) PQgetvalue (result,
713  row,
714  fnum);
715  if (INT64_MAX == GNUNET_ntohll ((uint64_t) *res))
717  else
718  udst->abs_value_us = GNUNET_ntohll ((uint64_t) *res);
719  return GNUNET_OK;
720 }
721 
722 
725  struct GNUNET_TIME_Absolute *at)
726 {
727  struct GNUNET_PQ_ResultSpec res = {
728  .conv = &extract_abs_time,
729  .dst = (void *) at,
730  .dst_size = sizeof(*at),
731  .fname = name
732  };
733 
734  return res;
735 }
736 
737 
740  struct GNUNET_TIME_AbsoluteNBO *at)
741 {
742  struct GNUNET_PQ_ResultSpec res =
744  &at->abs_value_us__);
745 
746  return res;
747 }
748 
749 
763 static enum GNUNET_GenericReturnValue
764 extract_timestamp (void *cls,
765  PGresult *result,
766  int row,
767  const char *fname,
768  size_t *dst_size,
769  void *dst)
770 {
771  struct GNUNET_TIME_Timestamp *udst = dst;
772  struct GNUNET_TIME_Absolute abs;
773  const int64_t *res;
774  int fnum;
775 
776  (void) cls;
777  fnum = PQfnumber (result,
778  fname);
779  if (fnum < 0)
780  {
781  GNUNET_break (0);
782  return GNUNET_SYSERR;
783  }
784  if (PQgetisnull (result,
785  row,
786  fnum))
787  return GNUNET_NO;
788  GNUNET_assert (NULL != dst);
789  if (sizeof(struct GNUNET_TIME_Absolute) != *dst_size)
790  {
791  GNUNET_break (0);
792  return GNUNET_SYSERR;
793  }
794  if (sizeof(int64_t) !=
795  PQgetlength (result,
796  row,
797  fnum))
798  {
799  GNUNET_break (0);
800  return GNUNET_SYSERR;
801  }
802  res = (int64_t *) PQgetvalue (result,
803  row,
804  fnum);
805  if (INT64_MAX == GNUNET_ntohll ((uint64_t) *res))
806  {
808  }
809  else
810  {
811  abs.abs_value_us = GNUNET_ntohll ((uint64_t) *res);
812  if (0 != abs.abs_value_us % GNUNET_TIME_UNIT_SECONDS.rel_value_us)
813  {
814  /* timestamps must be multiple of seconds! */
815  GNUNET_break (0);
816  return GNUNET_SYSERR;
817  }
818  }
819  udst->abs_time = abs;
820  return GNUNET_OK;
821 }
822 
823 
826  struct GNUNET_TIME_Timestamp *at)
827 {
828  struct GNUNET_PQ_ResultSpec res = {
829  .conv = &extract_timestamp,
830  .dst = (void *) at,
831  .dst_size = sizeof(*at),
832  .fname = name
833  };
834 
835  return res;
836 }
837 
838 
852 static enum GNUNET_GenericReturnValue
854  PGresult *result,
855  int row,
856  const char *fname,
857  size_t *dst_size,
858  void *dst)
859 {
860  struct GNUNET_TIME_TimestampNBO *udst = dst;
861  struct GNUNET_TIME_Timestamp t;
863 
864  r = extract_timestamp (NULL,
865  result,
866  row,
867  fname,
868  dst_size,
869  &t);
870  if (GNUNET_OK != r)
871  return r;
872  *udst = GNUNET_TIME_timestamp_hton (t);
873  return r;
874 }
875 
876 
879  struct GNUNET_TIME_TimestampNBO *at)
880 {
881  struct GNUNET_PQ_ResultSpec res = {
882  .conv = &extract_timestamp_nbo,
883  .dst = (void *) at,
884  .dst_size = sizeof(*at),
885  .fname = name
886  };
887 
888  return res;
889 }
890 
891 
905 static enum GNUNET_GenericReturnValue
906 extract_uint16 (void *cls,
907  PGresult *result,
908  int row,
909  const char *fname,
910  size_t *dst_size,
911  void *dst)
912 {
913  uint16_t *udst = dst;
914  const uint16_t *res;
915  int fnum;
916 
917  (void) cls;
918  fnum = PQfnumber (result,
919  fname);
920  if (fnum < 0)
921  {
922  GNUNET_break (0);
923  return GNUNET_SYSERR;
924  }
925  if (PQgetisnull (result,
926  row,
927  fnum))
928  return GNUNET_NO;
929  GNUNET_assert (NULL != dst);
930  if (sizeof(uint16_t) != *dst_size)
931  {
932  GNUNET_break (0);
933  return GNUNET_SYSERR;
934  }
935  if (sizeof(uint16_t) !=
936  PQgetlength (result,
937  row,
938  fnum))
939  {
940  GNUNET_break (0);
941  return GNUNET_SYSERR;
942  }
943  res = (uint16_t *) PQgetvalue (result,
944  row,
945  fnum);
946  *udst = ntohs (*res);
947  return GNUNET_OK;
948 }
949 
950 
953  uint16_t *u16)
954 {
955  struct GNUNET_PQ_ResultSpec res = {
956  .conv = &extract_uint16,
957  .dst = (void *) u16,
958  .dst_size = sizeof(*u16),
959  .fname = name
960  };
961 
962  return res;
963 }
964 
965 
979 static enum GNUNET_GenericReturnValue
980 extract_uint32 (void *cls,
981  PGresult *result,
982  int row,
983  const char *fname,
984  size_t *dst_size,
985  void *dst)
986 {
987  uint32_t *udst = dst;
988  const uint32_t *res;
989  int fnum;
990 
991  (void) cls;
992  fnum = PQfnumber (result,
993  fname);
994  if (fnum < 0)
995  {
996  GNUNET_break (0);
997  return GNUNET_SYSERR;
998  }
999  if (PQgetisnull (result,
1000  row,
1001  fnum))
1002  return GNUNET_NO;
1003  GNUNET_assert (NULL != dst);
1004  if (sizeof(uint32_t) != *dst_size)
1005  {
1006  GNUNET_break (0);
1007  return GNUNET_SYSERR;
1008  }
1009  if (sizeof(uint32_t) !=
1010  PQgetlength (result,
1011  row,
1012  fnum))
1013  {
1014  GNUNET_break (0);
1015  return GNUNET_SYSERR;
1016  }
1017  res = (uint32_t *) PQgetvalue (result,
1018  row,
1019  fnum);
1020  *udst = ntohl (*res);
1021  return GNUNET_OK;
1022 }
1023 
1024 
1025 struct GNUNET_PQ_ResultSpec
1026 GNUNET_PQ_result_spec_uint32 (const char *name,
1027  uint32_t *u32)
1028 {
1029  struct GNUNET_PQ_ResultSpec res = {
1030  .conv = &extract_uint32,
1031  .dst = (void *) u32,
1032  .dst_size = sizeof(*u32),
1033  .fname = name
1034  };
1035 
1036  return res;
1037 }
1038 
1039 
1053 static enum GNUNET_GenericReturnValue
1054 extract_uint64 (void *cls,
1055  PGresult *result,
1056  int row,
1057  const char *fname,
1058  size_t *dst_size,
1059  void *dst)
1060 {
1061  uint64_t *udst = dst;
1062  const uint64_t *res;
1063  int fnum;
1064 
1065  (void) cls;
1066  fnum = PQfnumber (result,
1067  fname);
1068  if (fnum < 0)
1069  {
1071  "Field %s missing in result\n",
1072  fname);
1073  GNUNET_break (0);
1074  return GNUNET_SYSERR;
1075  }
1076  if (PQgetisnull (result,
1077  row,
1078  fnum))
1079  return GNUNET_NO;
1080 
1081  GNUNET_assert (NULL != dst);
1082  if (sizeof(uint64_t) != *dst_size)
1083  {
1084  GNUNET_break (0);
1085  return GNUNET_SYSERR;
1086  }
1087  if (sizeof(uint64_t) !=
1088  PQgetlength (result,
1089  row,
1090  fnum))
1091  {
1092  GNUNET_break (0);
1094  "Got length %u for field `%s'\n",
1095  PQgetlength (result,
1096  row,
1097  fnum),
1098  fname);
1099  return GNUNET_SYSERR;
1100  }
1101  res = (uint64_t *) PQgetvalue (result,
1102  row,
1103  fnum);
1104  *udst = GNUNET_ntohll (*res);
1105  return GNUNET_OK;
1106 }
1107 
1108 
1109 struct GNUNET_PQ_ResultSpec
1110 GNUNET_PQ_result_spec_uint64 (const char *name,
1111  uint64_t *u64)
1112 {
1113  struct GNUNET_PQ_ResultSpec res = {
1114  .conv = &extract_uint64,
1115  .dst = (void *) u64,
1116  .dst_size = sizeof(*u64),
1117  .fname = name
1118  };
1119 
1120  return res;
1121 }
1122 
1123 
1129 {
1130  /* Oid of the expected type, must match the oid in the header of the PQResult struct */
1131  Oid oid;
1132 
1133  /* Target type */
1134  enum array_types typ;
1135 
1136  /* If not 0, defines the expected size of each entry */
1137  size_t same_size;
1138 
1139  /* Out-pointer to write the number of elements in the array */
1140  size_t *num;
1141 
1142  /* Out-pointer. If @a typ is array_of_byte and @a same_size is 0,
1143  * allocate and put the array of @a num sizes here. NULL otherwise */
1144  size_t **sizes;
1145 };
1146 
1147 
1163 static enum GNUNET_GenericReturnValue
1165  void *cls,
1166  PGresult *result,
1167  int row,
1168  const char *fname,
1169  size_t *dst_size,
1170  void *dst)
1171 {
1172  const struct array_result_cls *info = cls;
1173  int data_sz;
1174  char *data;
1175  void *out = NULL;
1176  struct pq_array_header header;
1177  int col_num;
1178 
1179  GNUNET_assert (NULL != dst);
1180  *((void **) dst) = NULL;
1181 
1182  #define FAIL_IF(cond) \
1183  do { \
1184  if ((cond)) \
1185  { \
1186  GNUNET_break (! (cond)); \
1187  goto FAIL; \
1188  } \
1189  } while (0)
1190 
1191  col_num = PQfnumber (result, fname);
1192  FAIL_IF (0 > col_num);
1193 
1194  data_sz = PQgetlength (result, row, col_num);
1195  FAIL_IF (0 > data_sz);
1196  FAIL_IF (sizeof(header) > (size_t) data_sz);
1197 
1198  data = PQgetvalue (result, row, col_num);
1199  FAIL_IF (NULL == data);
1200 
1201  {
1202  struct pq_array_header *h =
1203  (struct pq_array_header *) data;
1204 
1205  header.ndim = ntohl (h->ndim);
1206  header.has_null = ntohl (h->has_null);
1207  header.oid = ntohl (h->oid);
1208  header.dim = ntohl (h->dim);
1209  header.lbound = ntohl (h->lbound);
1210 
1211  FAIL_IF (1 != header.ndim);
1212  FAIL_IF (INT_MAX <= header.dim);
1213  FAIL_IF (0 != header.has_null);
1214  FAIL_IF (1 != header.lbound);
1215  FAIL_IF (info->oid != header.oid);
1216  }
1217 
1218  if (NULL != info->num)
1219  *info->num = header.dim;
1220 
1221  {
1222  char *in = data + sizeof(header);
1223 
1224  switch (info->typ)
1225  {
1226  case array_of_bool:
1227  if (NULL != dst_size)
1228  *dst_size = sizeof(bool) * (header.dim);
1229  out = GNUNET_new_array (header.dim, bool);
1230  *((void **) dst) = out;
1231  for (uint32_t i = 0; i < header.dim; i++)
1232  {
1233  size_t sz = ntohl (*(uint32_t *) in);
1234  FAIL_IF (sz != sizeof(bool));
1235  in += sizeof(uint32_t);
1236  *(bool *) out = *(bool *) in;
1237  in += sz;
1238  out += sz;
1239  }
1240  break;
1241 
1242  case array_of_uint16:
1243  if (NULL != dst_size)
1244  *dst_size = sizeof(uint16_t) * (header.dim);
1245  out = GNUNET_new_array (header.dim, uint16_t);
1246  *((void **) dst) = out;
1247  for (uint32_t i = 0; i < header.dim; i++)
1248  {
1249  size_t sz = ntohl (*(uint32_t *) in);
1250  FAIL_IF (sz != sizeof(uint16_t));
1251  in += sizeof(uint32_t);
1252  *(uint16_t *) out = ntohs (*(uint16_t *) in);
1253  in += sz;
1254  out += sz;
1255  }
1256  break;
1257 
1258  case array_of_uint32:
1259  if (NULL != dst_size)
1260  *dst_size = sizeof(uint32_t) * (header.dim);
1261  out = GNUNET_new_array (header.dim, uint32_t);
1262  *((void **) dst) = out;
1263  for (uint32_t i = 0; i < header.dim; i++)
1264  {
1265  size_t sz = ntohl (*(uint32_t *) in);
1266  FAIL_IF (sz != sizeof(uint32_t));
1267  in += sizeof(uint32_t);
1268  *(uint32_t *) out = ntohl (*(uint32_t *) in);
1269  in += sz;
1270  out += sz;
1271  }
1272  break;
1273 
1274  case array_of_uint64:
1275  if (NULL != dst_size)
1276  *dst_size = sizeof(uint64_t) * (header.dim);
1277  out = GNUNET_new_array (header.dim, uint64_t);
1278  *((void **) dst) = out;
1279  for (uint32_t i = 0; i < header.dim; i++)
1280  {
1281  size_t sz = ntohl (*(uint32_t *) in);
1282  FAIL_IF (sz != sizeof(uint64_t));
1283  in += sizeof(uint32_t);
1284  *(uint64_t *) out = GNUNET_ntohll (*(uint64_t *) in);
1285  in += sz;
1286  out += sz;
1287  }
1288  break;
1289 
1290  case array_of_abs_time:
1291  if (NULL != dst_size)
1292  *dst_size = sizeof(struct GNUNET_TIME_Absolute) * (header.dim);
1293  out = GNUNET_new_array (header.dim, struct GNUNET_TIME_Absolute);
1294  *((void **) dst) = out;
1295  for (uint32_t i = 0; i < header.dim; i++)
1296  {
1297  size_t sz = ntohl (*(uint32_t *) in);
1298  FAIL_IF (sz != sizeof(uint64_t));
1299  in += sizeof(uint32_t);
1300  ((struct GNUNET_TIME_Absolute *) out)->abs_value_us =
1301  GNUNET_ntohll (*(uint64_t *) in);
1302  in += sz;
1303  out += sz;
1304  }
1305  break;
1306 
1307  case array_of_rel_time:
1308  if (NULL != dst_size)
1309  *dst_size = sizeof(struct GNUNET_TIME_Relative) * (header.dim);
1310  out = GNUNET_new_array (header.dim, struct GNUNET_TIME_Relative);
1311  *((void **) dst) = out;
1312  for (uint32_t i = 0; i < header.dim; i++)
1313  {
1314  size_t sz = ntohl (*(uint32_t *) in);
1315  FAIL_IF (sz != sizeof(uint64_t));
1316  in += sizeof(uint32_t);
1317  ((struct GNUNET_TIME_Relative *) out)->rel_value_us =
1318  GNUNET_ntohll (*(uint64_t *) in);
1319  in += sz;
1320  out += sz;
1321  }
1322  break;
1323 
1324  case array_of_timestamp:
1325  if (NULL != dst_size)
1326  *dst_size = sizeof(struct GNUNET_TIME_Timestamp) * (header.dim);
1327  out = GNUNET_new_array (header.dim, struct GNUNET_TIME_Timestamp);
1328  *((void **) dst) = out;
1329  for (uint32_t i = 0; i < header.dim; i++)
1330  {
1331  size_t sz = ntohl (*(uint32_t *) in);
1332  FAIL_IF (sz != sizeof(uint64_t));
1333  in += sizeof(uint32_t);
1334  ((struct GNUNET_TIME_Timestamp *) out)->abs_time.abs_value_us =
1335  GNUNET_ntohll (*(uint64_t *) in);
1336  in += sz;
1337  out += sz;
1338  }
1339  break;
1340 
1341  case array_of_byte:
1342  if (0 == info->same_size)
1343  *info->sizes = GNUNET_new_array (header.dim, size_t);
1344  /* fallthrough */
1345  case array_of_string:
1346  {
1347  size_t total = 0;
1348  bool is_string = (array_of_string == info->typ);
1349 
1350  /* first, calculate total size required for allocation */
1351  {
1352  char *ptr = data + sizeof(header);
1353  for (uint32_t i = 0; i < header.dim; i++)
1354  {
1355  uint32_t sz;
1356 
1357  sz = ntohl (*(uint32_t *) ptr);
1358  sz += is_string ? 1 : 0;
1359  total += sz;
1360  ptr += sizeof(uint32_t);
1361  ptr += sz;
1362 
1363  if ((! is_string) &&
1364  (0 == info->same_size))
1365  (*info->sizes)[i] = sz;
1366 
1367  FAIL_IF ((0 != info->same_size) &&
1368  (sz != info->same_size));
1369  FAIL_IF (total < sz);
1370  }
1371  }
1372 
1373  if (NULL != dst_size)
1374  *dst_size = total;
1375 
1376  FAIL_IF (0 == total);
1377  out = GNUNET_malloc (total);
1378 
1379  *((void **) dst) = out;
1380 
1381  /* copy data */
1382  for (uint32_t i = 0; i < header.dim; i++)
1383  {
1384  size_t sz = ntohl (*(uint32_t *) in);
1385  in += sizeof(uint32_t);
1386  GNUNET_memcpy (out, in, sz);
1387 
1388  in += sz;
1389  out += sz;
1390  out += (array_of_string == info->typ) ? 1 : 0;
1391  }
1392  break;
1393  }
1394  default:
1395  FAIL_IF (1 != 0);
1396  }
1397  }
1398 
1399  return GNUNET_OK;
1400 
1401 FAIL:
1402  GNUNET_free (*(void **) dst);
1403  return GNUNET_SYSERR;
1404  #undef FAIL_IF
1405 }
1406 
1407 
1411 static void
1412 array_cleanup (void *cls,
1413  void *rd)
1414 {
1415 
1416  struct array_result_cls *info = cls;
1417  void **dst = rd;
1418 
1419  if ((array_of_byte == info->typ) &&
1420  (0 == info->same_size) &&
1421  (NULL != info->sizes))
1422  GNUNET_free (*(info->sizes));
1423 
1424  GNUNET_free (cls);
1425  GNUNET_free (*dst);
1426  *dst = NULL;
1427 }
1428 
1429 
1430 struct GNUNET_PQ_ResultSpec
1432  struct GNUNET_PQ_Context *db,
1433  const char *name,
1434  size_t *num,
1435  bool **dst)
1436 {
1437  struct array_result_cls *info =
1438  GNUNET_new (struct array_result_cls);
1439 
1440  info->num = num;
1441  info->typ = array_of_bool;
1444  "bool",
1445  &info->oid));
1446 
1447  struct GNUNET_PQ_ResultSpec res = {
1448  .conv = extract_array_generic,
1449  .cleaner = array_cleanup,
1450  .dst = (void *) dst,
1451  .fname = name,
1452  .cls = info
1453  };
1454  return res;
1455 }
1456 
1457 
1458 struct GNUNET_PQ_ResultSpec
1460  struct GNUNET_PQ_Context *db,
1461  const char *name,
1462  size_t *num,
1463  uint16_t **dst)
1464 {
1465  struct array_result_cls *info =
1466  GNUNET_new (struct array_result_cls);
1467 
1468  info->num = num;
1469  info->typ = array_of_uint16;
1472  "int2",
1473  &info->oid));
1474 
1475  struct GNUNET_PQ_ResultSpec res = {
1476  .conv = extract_array_generic,
1477  .cleaner = array_cleanup,
1478  .dst = (void *) dst,
1479  .fname = name,
1480  .cls = info
1481  };
1482  return res;
1483 }
1484 
1485 
1486 struct GNUNET_PQ_ResultSpec
1488  struct GNUNET_PQ_Context *db,
1489  const char *name,
1490  size_t *num,
1491  uint32_t **dst)
1492 {
1493  struct array_result_cls *info =
1494  GNUNET_new (struct array_result_cls);
1495 
1496  info->num = num;
1497  info->typ = array_of_uint32;
1500  "int4",
1501  &info->oid));
1502 
1503  struct GNUNET_PQ_ResultSpec res = {
1504  .conv = extract_array_generic,
1505  .cleaner = array_cleanup,
1506  .dst = (void *) dst,
1507  .fname = name,
1508  .cls = info
1509  };
1510  return res;
1511 }
1512 
1513 
1514 struct GNUNET_PQ_ResultSpec
1516  struct GNUNET_PQ_Context *db,
1517  const char *name,
1518  size_t *num,
1519  uint64_t **dst)
1520 {
1521  struct array_result_cls *info =
1522  GNUNET_new (struct array_result_cls);
1523 
1524  info->num = num;
1525  info->typ = array_of_uint64;
1528  "int8",
1529  &info->oid));
1530 
1531  struct GNUNET_PQ_ResultSpec res = {
1532  .conv = extract_array_generic,
1533  .cleaner = array_cleanup,
1534  .dst = (void *) dst,
1535  .fname = name,
1536  .cls = info
1537  };
1538  return res;
1539 }
1540 
1541 
1542 struct GNUNET_PQ_ResultSpec
1544  struct GNUNET_PQ_Context *db,
1545  const char *name,
1546  size_t *num,
1547  struct GNUNET_TIME_Absolute **dst)
1548 {
1549  struct array_result_cls *info =
1550  GNUNET_new (struct array_result_cls);
1551 
1552  info->num = num;
1553  info->typ = array_of_abs_time;
1556  "int8",
1557  &info->oid));
1558 
1559  struct GNUNET_PQ_ResultSpec res = {
1560  .conv = extract_array_generic,
1561  .cleaner = array_cleanup,
1562  .dst = (void *) dst,
1563  .fname = name,
1564  .cls = info
1565  };
1566  return res;
1567 }
1568 
1569 
1570 struct GNUNET_PQ_ResultSpec
1572  struct GNUNET_PQ_Context *db,
1573  const char *name,
1574  size_t *num,
1575  struct GNUNET_TIME_Relative **dst)
1576 {
1577  struct array_result_cls *info =
1578  GNUNET_new (struct array_result_cls);
1579 
1580  info->num = num;
1581  info->typ = array_of_rel_time;
1584  "int8",
1585  &info->oid));
1586 
1587  struct GNUNET_PQ_ResultSpec res = {
1588  .conv = extract_array_generic,
1589  .cleaner = array_cleanup,
1590  .dst = (void *) dst,
1591  .fname = name,
1592  .cls = info
1593  };
1594  return res;
1595 }
1596 
1597 
1598 struct GNUNET_PQ_ResultSpec
1600  struct GNUNET_PQ_Context *db,
1601  const char *name,
1602  size_t *num,
1603  struct GNUNET_TIME_Timestamp **dst)
1604 {
1605  struct array_result_cls *info =
1606  GNUNET_new (struct array_result_cls);
1607 
1608  info->num = num;
1609  info->typ = array_of_timestamp;
1612  "int8",
1613  &info->oid));
1614 
1615  struct GNUNET_PQ_ResultSpec res = {
1616  .conv = extract_array_generic,
1617  .cleaner = array_cleanup,
1618  .dst = (void *) dst,
1619  .fname = name,
1620  .cls = info
1621  };
1622  return res;
1623 }
1624 
1625 
1626 struct GNUNET_PQ_ResultSpec
1628  struct GNUNET_PQ_Context *db,
1629  const char *name,
1630  size_t *num,
1631  size_t **sizes,
1632  void **dst)
1633 {
1634  struct array_result_cls *info =
1635  GNUNET_new (struct array_result_cls);
1636 
1637  info->num = num;
1638  info->sizes = sizes;
1639  info->typ = array_of_byte;
1642  "bytea",
1643  &info->oid));
1644 
1645  struct GNUNET_PQ_ResultSpec res = {
1646  .conv = extract_array_generic,
1647  .cleaner = array_cleanup,
1648  .dst = (void *) dst,
1649  .fname = name,
1650  .cls = info
1651  };
1652  return res;
1653 }
1654 
1655 
1656 struct GNUNET_PQ_ResultSpec
1658  struct GNUNET_PQ_Context *db,
1659  const char *name,
1660  size_t size,
1661  size_t *num,
1662  void **dst)
1663 {
1664  struct array_result_cls *info =
1665  GNUNET_new (struct array_result_cls);
1666 
1667  info->num = num;
1668  info->same_size = size;
1669  info->typ = array_of_byte;
1672  "bytea",
1673  &info->oid));
1674 
1675  struct GNUNET_PQ_ResultSpec res = {
1676  .conv = extract_array_generic,
1677  .cleaner = array_cleanup,
1678  .dst = (void *) dst,
1679  .fname = name,
1680  .cls = info
1681  };
1682  return res;
1683 }
1684 
1685 
1686 struct GNUNET_PQ_ResultSpec
1688  struct GNUNET_PQ_Context *db,
1689  const char *name,
1690  size_t *num,
1691  char **dst)
1692 {
1693  struct array_result_cls *info =
1694  GNUNET_new (struct array_result_cls);
1695 
1696  info->num = num;
1697  info->typ = array_of_string;
1700  "text",
1701  &info->oid));
1702 
1703  struct GNUNET_PQ_ResultSpec res = {
1704  .conv = extract_array_generic,
1705  .cleaner = array_cleanup,
1706  .dst = (void *) dst,
1707  .fname = name,
1708  .cls = info
1709  };
1710  return res;
1711 }
1712 
1713 
1714 /* end of pq_result_helper.c */
#define INT_MAX
static struct GNUNET_ARM_Handle * h
Connection with ARM.
Definition: gnunet-arm.c:99
static int res
uint32_t data
The data value.
uint16_t len
length of data (which is always a uint32_t, but presumably this can be used to specify that fewer byt...
struct GNUNET_IDENTITY_PrivateKey pk
Private key from command line option, or NULL.
static struct GNUNET_GNSRECORD_Data rd[50]
The record data under a single label.
static int result
Global testing status.
#define info
static struct GNUNET_FS_DirectoryBuilder * db
Definition: gnunet-search.c:97
static struct GNUNET_SCHEDULER_Task * t
Main task.
commonly used definitions; globals in this file are exempt from the rule that the module name ("commo...
@ FAIL
helper functions for Postgres DB interactions
#define GNUNET_PQ_result_spec_auto_from_type(name, dst)
We expect a fixed-size result, with size determined by the type of * dst
enum GNUNET_GenericReturnValue GNUNET_PQ_get_oid_by_name(struct GNUNET_PQ_Context *db, const char *name, Oid *oid)
Returns the oid for a given datatype by name.
Definition: pq_connect.c:326
Functions related to time.
struct GNUNET_CRYPTO_RsaSignature * GNUNET_CRYPTO_rsa_signature_decode(const void *buf, size_t buf_size)
Decode the signature from the data-format back to the "normal", internal format.
Definition: crypto_rsa.c:1039
#define GNUNET_log(kind,...)
void GNUNET_CRYPTO_rsa_signature_free(struct GNUNET_CRYPTO_RsaSignature *sig)
Free memory occupied by signature.
Definition: crypto_rsa.c:991
uint64_t GNUNET_ntohll(uint64_t n)
Convert unsigned 64-bit integer to host byte order.
Definition: common_endian.c:54
void GNUNET_CRYPTO_rsa_public_key_free(struct GNUNET_CRYPTO_RsaPublicKey *key)
Free memory occupied by the public key.
Definition: crypto_rsa.c:268
struct GNUNET_CRYPTO_RsaPublicKey * GNUNET_CRYPTO_rsa_public_key_decode(const char *buf, size_t len)
Decode the public key from the data-format back to the "normal", internal format.
Definition: crypto_rsa.c:423
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
GNUNET_GenericReturnValue
Named constants for return values.
@ GNUNET_OK
@ GNUNET_NO
@ GNUNET_SYSERR
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur.
@ GNUNET_ERROR_TYPE_ERROR
#define GNUNET_strndup(a, length)
Wrapper around GNUNET_xstrndup_.
#define GNUNET_new(type)
Allocate a struct or union of the given type.
#define GNUNET_malloc(size)
Wrapper around malloc.
#define GNUNET_new_array(n, type)
Allocate a size n array with structs or unions of the given type.
#define GNUNET_free(ptr)
Wrapper around free.
#define GNUNET_TIME_UNIT_FOREVER_REL
Constant used to specify "forever".
#define GNUNET_TIME_UNIT_SECONDS
One second.
struct GNUNET_TIME_TimestampNBO GNUNET_TIME_timestamp_hton(struct GNUNET_TIME_Timestamp t)
Convert timestamp to network byte order.
Definition: time.c:91
#define GNUNET_TIME_UNIT_FOREVER_ABS
Constant used to specify "forever".
static unsigned int size
Size of the "table".
Definition: peer.c:68
const char * name
shared internal data structures of libgnunetpq
array_types
Internal types that are supported as array types.
Definition: pq.h:132
@ array_of_byte
Definition: pq.h:137
@ array_of_uint32
Definition: pq.h:135
@ array_of_string
Definition: pq.h:138
@ array_of_rel_time
Definition: pq.h:140
@ array_of_uint16
Definition: pq.h:134
@ array_of_uint64
Definition: pq.h:136
@ array_of_abs_time
Definition: pq.h:139
@ array_of_timestamp
Definition: pq.h:141
@ array_of_bool
Definition: pq.h:133
struct GNUNET_PQ_ResultSpec GNUNET_PQ_result_spec_array_bool(struct GNUNET_PQ_Context *db, const char *name, size_t *num, bool **dst)
array of bool expected.
static enum GNUNET_GenericReturnValue extract_string(void *cls, PGresult *result, int row, const char *fname, size_t *dst_size, void *dst)
Extract data from a Postgres database result at row row.
static enum GNUNET_GenericReturnValue extract_varsize_blob(void *cls, PGresult *result, int row, const char *fname, size_t *dst_size, void *dst)
Extract data from a Postgres database result at row row.
static enum GNUNET_GenericReturnValue extract_fixed_blob(void *cls, PGresult *result, int row, const char *fname, size_t *dst_size, void *dst)
Extract data from a Postgres database result at row row.
struct GNUNET_PQ_ResultSpec GNUNET_PQ_result_spec_uint32(const char *name, uint32_t *u32)
uint32_t expected.
struct GNUNET_PQ_ResultSpec GNUNET_PQ_result_spec_array_variable_size(struct GNUNET_PQ_Context *db, const char *name, size_t *num, size_t **sizes, void **dst)
Array of variable-size result expected.
struct GNUNET_PQ_ResultSpec GNUNET_PQ_result_spec_timestamp_nbo(const char *name, struct GNUNET_TIME_TimestampNBO *at)
Timestamp expected.
static enum GNUNET_GenericReturnValue extract_uint16(void *cls, PGresult *result, int row, const char *fname, size_t *dst_size, void *dst)
Extract data from a Postgres database result at row row.
struct GNUNET_PQ_ResultSpec GNUNET_PQ_result_spec_array_fixed_size(struct GNUNET_PQ_Context *db, const char *name, size_t size, size_t *num, void **dst)
Array of fixed-size result expected.
static enum GNUNET_GenericReturnValue extract_timestamp_nbo(void *cls, PGresult *result, int row, const char *fname, size_t *dst_size, void *dst)
Extract data from a Postgres database result at row row.
struct GNUNET_PQ_ResultSpec GNUNET_PQ_result_spec_array_timestamp(struct GNUNET_PQ_Context *db, const char *name, size_t *num, struct GNUNET_TIME_Timestamp **dst)
array of relative time expected.
static enum GNUNET_GenericReturnValue extract_abs_time(void *cls, PGresult *result, int row, const char *fname, size_t *dst_size, void *dst)
Extract data from a Postgres database result at row row.
static void clean_rsa_public_key(void *cls, void *rd)
Function called to clean up memory allocated by a GNUNET_PQ_ResultConverter.
static void clean_varsize_blob(void *cls, void *rd)
Function called to clean up memory allocated by a GNUNET_PQ_ResultConverter.
struct GNUNET_PQ_ResultSpec GNUNET_PQ_result_spec_fixed_size(const char *name, void *dst, size_t dst_size)
Fixed-size result expected.
static enum GNUNET_GenericReturnValue extract_bool(void *cls, PGresult *result, int row, const char *fname, size_t *dst_size, void *dst)
Extract data from a Postgres database result at row row.
struct GNUNET_PQ_ResultSpec GNUNET_PQ_result_spec_bool(const char *name, bool *dst)
boolean expected.
struct GNUNET_PQ_ResultSpec GNUNET_PQ_result_spec_absolute_time_nbo(const char *name, struct GNUNET_TIME_AbsoluteNBO *at)
Absolute time expected.
static enum GNUNET_GenericReturnValue extract_uint32(void *cls, PGresult *result, int row, const char *fname, size_t *dst_size, void *dst)
Extract data from a Postgres database result at row row.
struct GNUNET_PQ_ResultSpec GNUNET_PQ_result_spec_uint64(const char *name, uint64_t *u64)
uint64_t expected.
struct GNUNET_PQ_ResultSpec GNUNET_PQ_result_spec_string(const char *name, char **dst)
0-terminated string expected.
#define FAIL_IF(cond)
struct GNUNET_PQ_ResultSpec GNUNET_PQ_result_spec_allow_null(struct GNUNET_PQ_ResultSpec rs, bool *is_null)
Allow NULL value to be found in the database for the given value.
struct GNUNET_PQ_ResultSpec GNUNET_PQ_result_spec_array_uint16(struct GNUNET_PQ_Context *db, const char *name, size_t *num, uint16_t **dst)
array of uint16_t expected.
struct GNUNET_PQ_ResultSpec GNUNET_PQ_result_spec_absolute_time(const char *name, struct GNUNET_TIME_Absolute *at)
Absolute time expected.
static void clean_string(void *cls, void *rd)
Function called to clean up memory allocated by a GNUNET_PQ_ResultConverter.
struct GNUNET_PQ_ResultSpec GNUNET_PQ_result_spec_uint16(const char *name, uint16_t *u16)
uint16_t expected.
struct GNUNET_PQ_ResultSpec GNUNET_PQ_result_spec_array_string(struct GNUNET_PQ_Context *db, const char *name, size_t *num, char **dst)
Array of 0-terminated strings expected.
static enum GNUNET_GenericReturnValue extract_uint64(void *cls, PGresult *result, int row, const char *fname, size_t *dst_size, void *dst)
Extract data from a Postgres database result at row row.
static enum GNUNET_GenericReturnValue extract_rel_time(void *cls, PGresult *result, int row, const char *fname, size_t *dst_size, void *dst)
Extract data from a Postgres database result at row row.
struct GNUNET_PQ_ResultSpec GNUNET_PQ_result_spec_relative_time(const char *name, struct GNUNET_TIME_Relative *rt)
Relative time expected.
static enum GNUNET_GenericReturnValue extract_rsa_public_key(void *cls, PGresult *result, int row, const char *fname, size_t *dst_size, void *dst)
Extract data from a Postgres database result at row row.
struct GNUNET_PQ_ResultSpec GNUNET_PQ_result_spec_timestamp(const char *name, struct GNUNET_TIME_Timestamp *at)
Timestamp expected.
struct GNUNET_PQ_ResultSpec GNUNET_PQ_result_spec_variable_size(const char *name, void **dst, size_t *sptr)
Variable-size result expected.
static enum GNUNET_GenericReturnValue extract_array_generic(void *cls, PGresult *result, int row, const char *fname, size_t *dst_size, void *dst)
Extract data from a Postgres database result as array of a specific type from row row.
struct GNUNET_PQ_ResultSpec GNUNET_PQ_result_spec_rsa_public_key(const char *name, struct GNUNET_CRYPTO_RsaPublicKey **rsa)
RSA public key expected.
struct GNUNET_PQ_ResultSpec GNUNET_PQ_result_spec_array_uint64(struct GNUNET_PQ_Context *db, const char *name, size_t *num, uint64_t **dst)
array of uint64_t expected.
struct GNUNET_PQ_ResultSpec GNUNET_PQ_result_spec_array_abs_time(struct GNUNET_PQ_Context *db, const char *name, size_t *num, struct GNUNET_TIME_Absolute **dst)
array of absolute time expected.
struct GNUNET_PQ_ResultSpec GNUNET_PQ_result_spec_array_rel_time(struct GNUNET_PQ_Context *db, const char *name, size_t *num, struct GNUNET_TIME_Relative **dst)
array of relative time expected.
static enum GNUNET_GenericReturnValue extract_rsa_signature(void *cls, PGresult *result, int row, const char *fname, size_t *dst_size, void *dst)
Extract data from a Postgres database result at row row.
struct GNUNET_PQ_ResultSpec GNUNET_PQ_result_spec_rsa_signature(const char *name, struct GNUNET_CRYPTO_RsaSignature **sig)
RSA signature expected.
struct GNUNET_PQ_ResultSpec GNUNET_PQ_result_spec_array_uint32(struct GNUNET_PQ_Context *db, const char *name, size_t *num, uint32_t **dst)
array of uint32_t expected.
static enum GNUNET_GenericReturnValue extract_timestamp(void *cls, PGresult *result, int row, const char *fname, size_t *dst_size, void *dst)
Extract data from a Postgres database result at row row.
static void array_cleanup(void *cls, void *rd)
Cleanup of the data and closure of an array spec.
static void clean_rsa_signature(void *cls, void *rd)
Function called to clean up memory allocated by a GNUNET_PQ_ResultConverter.
The public information of an RSA key pair.
Definition: crypto_rsa.c:53
an RSA signature
Definition: crypto_rsa.c:65
Handle to Postgres database.
Definition: pq.h:36
Description of a DB result cell.
const char * fname
Field name of the desired result.
bool * is_null
Points to a location where we should store "true" if the result found is NULL, and otherwise "false".
void * dst
Destination for the data.
bool is_nullable
True if NULL is allowed for a value in the database.
void * cls
Closure for conv and cleaner.
size_t dst_size
Allowed size for the data, 0 for variable-size (in this case, the type of dst is a void ** and we nee...
Time for absolute time used by GNUnet, in microseconds and in network byte order.
Time for absolute times used by GNUnet, in microseconds.
uint64_t abs_value_us
The actual value.
Time for relative time used by GNUnet, in microseconds.
uint64_t rel_value_us
The actual value.
Time for timestamps used by GNUnet, in seconds and in network byte order.
Rounded time for timestamps used by GNUnet, in seconds.
struct GNUNET_TIME_Absolute abs_time
The actual value.
Closure for the array result specifications.
enum array_types typ
the header for a postgresql array in binary format.
Definition: pq.h:151
uint32_t lbound
Definition: pq.h:156
uint32_t has_null
Definition: pq.h:153
uint32_t oid
Definition: pq.h:154
uint32_t ndim
Definition: pq.h:152
uint32_t dim
Definition: pq.h:155