2 This file is part of GNUnet
3 Copyright (C) 2014, 2015, 2016 GNUnet e.V.
5 GNUnet is free software; you can redistribute it and/or modify it under the
6 terms of the GNU General Public License as published by the Free Software
7 Foundation; either version 3, or (at your option) any later version.
9 GNUnet is distributed in the hope that it will be useful, but WITHOUT ANY
10 WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
11 A PARTICULAR PURPOSE. See the GNU General Public License for more details.
13 You should have received a copy of the GNU General Public License along with
14 GNUnet; see the file COPYING. If not, If not, see <http://www.gnu.org/licenses/>
17 * @file my/my_result_helper.c
18 * @brief functions to extract result values
19 * @author Christophe Genevey
23 #include "gnunet_util_lib.h"
24 #include "gnunet_my_lib.h"
28 * extract data from a Mysql database @a result at row @a row
32 * @param stmt the mysql statement that is being run
33 * @param column the column that is being processed
34 * @param[out] result mysql result
36 * #GNUNET_OK if all results could be extracted
37 * #GNUNET_SYSERR if a result was invalid
40 pre_extract_varsize_blob (void *cls,
41 struct GNUNET_MY_ResultSpec *rs,
46 results[0].buffer = NULL;
47 results[0].buffer_length = 0;
48 results[0].length = &rs->mysql_bind_output_length;
55 * extract data from a Mysql database @a result at row @a row
59 * @param stmt the mysql statement that is being run
60 * @param column the column that is being processed
63 * #GNUNET_OK if all results could be extracted
64 * #GNUNET_SYSERR if a result was invalid
67 post_extract_varsize_blob (void *cls,
68 struct GNUNET_MY_ResultSpec *rs,
76 size = (size_t) rs->mysql_bind_output_length;
78 if (rs->mysql_bind_output_length != size)
79 return GNUNET_SYSERR; /* 'unsigned long' does not fit in size_t!? */
81 buf = GNUNET_malloc (size);
83 results[0].buffer = buf;
84 results[0].buffer_length = size;
85 results[0].buffer_type = MYSQL_TYPE_BLOB;
88 mysql_stmt_fetch_column (stmt,
97 *(void **) rs->dst = buf;
98 *rs->result_size = size;
105 * extract data from a Mysql database @a result at row @a row
111 cleanup_varsize_blob (void *cls,
112 struct GNUNET_MY_ResultSpec *rs)
114 void **ptr = (void **)rs->dst;
125 * Variable-size result expected
127 * @param[out] dst where to store the result, allocated
128 * @param[out] ptr_size where to store the size of @a dst
129 * @return array entru for the result specification to use
131 struct GNUNET_MY_ResultSpec
132 GNUNET_MY_result_spec_variable_size (void **dst,
135 struct GNUNET_MY_ResultSpec res =
137 .pre_conv = &pre_extract_varsize_blob,
138 .post_conv = &post_extract_varsize_blob,
139 .cleaner = &cleanup_varsize_blob,
140 .dst = (void *)(dst),
141 .result_size = ptr_size,
150 * Extract data from a Mysql database @a result at row @a row
154 * @param stmt the mysql statement that is being run
155 * @param column the column that is being processed
156 * @param[out] results
158 * #GNUNET_OK if all results could be extracted
159 * #GNUNET_SYSERR if a result was invalid(non-existing field or NULL)
162 pre_extract_fixed_blob (void *cls,
163 struct GNUNET_MY_ResultSpec *rs,
168 results[0].buffer = rs->dst;
169 results[0].buffer_length = rs->dst_size;
170 results[0].length = &rs->mysql_bind_output_length;
171 results[0].buffer_type = MYSQL_TYPE_BLOB;
178 * Check size of extracted fixed size data from a Mysql database @a
179 * result at row @a row
183 * @param stmt the mysql statement that is being run
184 * @param column the column that is being processed
185 * @param[out] results
187 * #GNUNET_OK if all results could be extracted
188 * #GNUNET_SYSERR if a result was invalid(non-existing field or NULL)
191 post_extract_fixed_blob (void *cls,
192 struct GNUNET_MY_ResultSpec *rs,
197 if (rs->dst_size != rs->mysql_bind_output_length)
198 return GNUNET_SYSERR;
204 * Fixed-size result expected.
206 * @param name name of the field in the table
207 * @param[out] dst where to store the result
208 * @param ptr_size number of bytes in @a dst
209 * @return array entry for the result specification to use
211 struct GNUNET_MY_ResultSpec
212 GNUNET_MY_result_spec_fixed_size (void *ptr,
215 struct GNUNET_MY_ResultSpec res =
217 .pre_conv = &pre_extract_fixed_blob,
218 .post_conv = &post_extract_fixed_blob,
220 .dst = (void *)(ptr),
221 .dst_size = ptr_size,
230 * Extract data from a Mysql database @a result at row @a row
234 * @param stmt the mysql statement that is being run
235 * @param column the column that is being processed
236 * @param[out] results
238 * #GNUNET_OK if all results could be extracted
239 * #GNUNET_SYSERR if a result was invalid (non-existing field or NULL)
242 pre_extract_rsa_public_key (void *cls,
243 struct GNUNET_MY_ResultSpec *rs,
248 results[0].buffer = NULL;
249 results[0].buffer_length = 0;
250 results[0].length = &rs->mysql_bind_output_length;
251 results[0].buffer_type = MYSQL_TYPE_BLOB;
258 * Check size of extracted fixed size data from a Mysql database @a
259 * result at row @a row
263 * @param stmt the mysql statement that is being run
264 * @param column the column that is being processed
265 * @param[out] results
267 * #GNUNET_OK if all results could be extracted
268 * #GNUNET_SYSERR if a result was invalid (non-existing field or NULL)
271 post_extract_rsa_public_key (void *cls,
272 struct GNUNET_MY_ResultSpec *rs,
278 struct GNUNET_CRYPTO_RsaPublicKey **pk = rs->dst;
282 size = (size_t) rs->mysql_bind_output_length;
284 if (rs->mysql_bind_output_length != size)
285 return GNUNET_SYSERR; /* 'unsigned long' does not fit in size_t!? */
286 buf = GNUNET_malloc (size);
288 results[0].buffer = buf;
289 results[0].buffer_length = size;
290 results[0].buffer_type = MYSQL_TYPE_BLOB;
292 mysql_stmt_fetch_column (stmt,
298 return GNUNET_SYSERR;
301 *pk = GNUNET_CRYPTO_rsa_public_key_decode (buf,
306 GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
307 "Results contains bogus public key value (fail to decode)\n");
308 return GNUNET_SYSERR;
316 * Function called to clean up memory allocated
317 * by a #GNUNET_MY_ResultConverter.
320 * @param rs result data to clean up
323 clean_rsa_public_key (void *cls,
324 struct GNUNET_MY_ResultSpec *rs)
326 struct GNUNET_CRYPTO_RsaPublicKey **pk = rs->dst;
330 GNUNET_CRYPTO_rsa_public_key_free (*pk);
337 * RSA public key expected
339 * @param name name of the field in the table
340 * @param[out] rsa where to store the result
341 * @return array entry for the result specification to use
343 struct GNUNET_MY_ResultSpec
344 GNUNET_MY_result_spec_rsa_public_key (struct GNUNET_CRYPTO_RsaPublicKey **rsa)
346 struct GNUNET_MY_ResultSpec res = {
347 .pre_conv = &pre_extract_rsa_public_key,
348 .post_conv = &post_extract_rsa_public_key,
349 .cleaner = &clean_rsa_public_key,
360 * Extract data from a Mysql database @a result at row @a row.
364 * @param stmt the mysql statement that is being run
365 * @param column the column that is being processed
366 * @param[out] results
368 * #GNUNET_OK if all results could be extracted
369 * #GNUNET_SYSERR if a result was invalid (non-existing field or NULL)
372 pre_extract_rsa_signature (void *cls,
373 struct GNUNET_MY_ResultSpec *rs,
378 results[0].buffer = 0;
379 results[0].buffer_length = 0;
380 results[0].length = &rs->mysql_bind_output_length;
381 results[0].buffer_type = MYSQL_TYPE_BLOB;
388 * Extract data from a Mysql database @a result at row @a row.
392 * @param stmt the mysql statement that is being run
393 * @param column the column that is being processed
394 * @param[out] results
396 * #GNUNET_OK if all results could be extracted
397 * #GNUNET_SYSERR if a result was invalid (non-existing field or NULL)
400 post_extract_rsa_signature (void *cls,
401 struct GNUNET_MY_ResultSpec *rs,
406 struct GNUNET_CRYPTO_RsaSignature **sig = rs->dst;
410 size = (size_t) rs->mysql_bind_output_length;
412 if (rs->mysql_bind_output_length != size)
413 return GNUNET_SYSERR; /* 'unsigned long' does not fit in size_t!? */
414 buf = GNUNET_malloc (size);
416 results[0].buffer = buf;
417 results[0].buffer_length = size;
418 results[0].buffer_type = MYSQL_TYPE_BLOB;
420 mysql_stmt_fetch_column (stmt,
426 return GNUNET_SYSERR;
429 *sig = GNUNET_CRYPTO_rsa_signature_decode (buf,
434 GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
435 "Resuls contains bogus signature value (fails to decode)\n");
436 return GNUNET_SYSERR;
443 * Function called to clean up memory allocated
444 * by a #GNUNET_MY_ResultConverter.
447 * @param rd result data to clean up
450 clean_rsa_signature (void *cls,
451 struct GNUNET_MY_ResultSpec *rs)
453 struct GNUNET_CRYPTO_RsaSignature **sig = rs->dst;
457 GNUNET_CRYPTO_rsa_signature_free (*sig);
464 * RSA signature expected.
466 * @param[out] sig where to store the result;
467 * @return array entry for the result specification to use
469 struct GNUNET_MY_ResultSpec
470 GNUNET_MY_result_spec_rsa_signature (struct GNUNET_CRYPTO_RsaSignature **sig)
472 struct GNUNET_MY_ResultSpec res =
474 .pre_conv = &pre_extract_rsa_signature,
475 .post_conv = &post_extract_rsa_signature,
476 .cleaner = &clean_rsa_signature,
486 * Extract data from a Mysql database @a result at row @a row
490 * @param stmt the mysql statement that is being run
491 * @param column the column that is being processed
492 * @param[out] results
494 * #GNUNET_OK if all results could be extracted
495 * #GNUNET_SYSERR if a result was invalid (non existing field or NULL)
498 pre_extract_string (void * cls,
499 struct GNUNET_MY_ResultSpec *rs,
504 results[0].buffer = (char *)rs->dst;
505 results[0].buffer_length = rs->dst_size;
506 results[0].length = &rs->mysql_bind_output_length;
513 * Check size of extracted fixed size data from a Mysql database @a
517 * @param stmt the mysql statement that is being run
518 * @param column the column that is being processed
519 * @param[out] results
521 * #GNUNET_OK if all results could be extracted
522 * #GNUNET_SYSERR if a result was invalid (non existing field or NULL)
525 post_extract_string (void * cls,
526 struct GNUNET_MY_ResultSpec *rs,
531 if (rs->dst_size != rs->mysql_bind_output_length)
532 return GNUNET_SYSERR;
538 * 0- terminated string exprected.
540 * @param[out] dst where to store the result, allocated
541 * @return array entry for the result specification to use
543 struct GNUNET_MY_ResultSpec
544 GNUNET_MY_result_spec_string (char **dst)
546 struct GNUNET_MY_ResultSpec res = {
547 .pre_conv = &pre_extract_string,
548 .post_conv = &post_extract_string,
559 * Absolute time expected
561 * @param name name of the field in the table
562 * @param[out] at where to store the result
563 * @return array entry for the result specification to use
565 struct GNUNET_MY_ResultSpec
566 GNUNET_MY_result_spec_absolute_time (struct GNUNET_TIME_Absolute *at)
568 return GNUNET_MY_result_spec_uint64 (&at->abs_value_us);
573 * Absolute time in network byte order expected
575 * @param[out] at where to store the result
576 * @return array entry for the result specification to use
578 struct GNUNET_MY_ResultSpec
579 GNUNET_MY_result_spec_absolute_time_nbo (struct GNUNET_TIME_AbsoluteNBO *at)
581 struct GNUNET_MY_ResultSpec res =
582 GNUNET_MY_result_spec_auto_from_type (&at->abs_value_us__);
588 * Extract data from a Postgres database @a result at row @a row.
592 * @param stmt the mysql statement that is being run
593 * @param column the column that is being processed
594 * @param[out] results
596 * #GNUNET_YES if all results could be extracted
597 * #GNUNET_SYSERR if a result was invalid (non-existing field or NULL)
600 pre_extract_uint16 (void *cls,
601 struct GNUNET_MY_ResultSpec *rs,
606 results[0].buffer = (char *)rs->dst;
607 results[0].buffer_length = rs->dst_size;
608 results[0].length = &rs->mysql_bind_output_length;
609 results[0].buffer_type = MYSQL_TYPE_SHORT;
616 * Check size of extracted fixed size data from a Mysql datbase.
620 * @param stmt the mysql statement that is being run
621 * @param column the column that is being processed
622 * @param[out] results
624 * #GNUNET_YES if all results could be extracted
625 * #GNUNET_SYSERR if a result was invalid (non-existing field or NULL)
628 post_extract_uint16 (void *cls,
629 struct GNUNET_MY_ResultSpec *rs,
634 if (rs->dst_size != rs->mysql_bind_output_length)
635 return GNUNET_SYSERR;
643 * @param[out] u16 where to store the result
644 * @return array entry for the result specification to use
646 struct GNUNET_MY_ResultSpec
647 GNUNET_MY_result_spec_uint16 (uint16_t *u16)
649 struct GNUNET_MY_ResultSpec res = {
650 .pre_conv = &pre_extract_uint16,
651 .post_conv = &post_extract_uint16,
654 .dst_size = sizeof (*u16),
662 * Extrac data from a MYSQL database @a result at row @a row
667 * @param stmt the mysql statement that is being run
668 * @param column the column that is being processed
669 * @param[out] results
671 * #GNUNET_OK if all results could be extracted
672 * #GNUNET_SYSERR if a result was invalid (non-existing field or NULL)
675 pre_extract_uint32 (void *cls,
676 struct GNUNET_MY_ResultSpec *rs,
681 results[0].buffer = (int *)rs->dst;
682 results[0].buffer_length = rs->dst_size;
683 results[0].length = &rs->mysql_bind_output_length;
684 results[0].buffer_type = MYSQL_TYPE_LONG;
691 * Extrac data from a MYSQL database @a result at row @a row
696 * @param stmt the mysql statement that is being run
697 * @param column the column that is being processed
698 * @param[out] results
700 * #GNUNET_OK if all results could be extracted
701 * #GNUNET_SYSERR if a result was invalid (non-existing field or NULL)
704 post_extract_uint32 (void *cls,
705 struct GNUNET_MY_ResultSpec *rs,
710 if (rs->dst_size != rs->mysql_bind_output_length)
711 return GNUNET_SYSERR;
719 * @param[out] u32 where to store the result
720 * @return array entry for the result specification to use
722 struct GNUNET_MY_ResultSpec
723 GNUNET_MY_result_spec_uint32 (uint32_t *u32)
725 struct GNUNET_MY_ResultSpec res = {
726 .pre_conv = &pre_extract_uint32,
727 .post_conv = &post_extract_uint32,
730 .dst_size = sizeof (*u32),
738 * Extract data from a MYSQL database @a result at row @a row
742 * @param stmt the mysql statement that is being run
743 * @param column the column that is being processed
744 * @param[out] results
746 * #GNUNET_OK if all results could be extracted
747 * #GNUNET_SYSERR if a result was invalid (non-existing field or NULL)
750 pre_extract_uint64 (void *cls,
751 struct GNUNET_MY_ResultSpec *rs,
756 results[0].buffer = rs->dst;
757 results[0].buffer_length = rs->dst_size;
758 results[0].length = &rs->mysql_bind_output_length;
759 results[0].buffer_type = MYSQL_TYPE_LONGLONG;
766 * Check size of extracted fixe size data from a Mysql database
770 * @param stmt the mysql statement that is being run
771 * @param column the column that is being processed
772 * @param[out] results
774 * #GNUNET_OK if all results could be extracted
775 * #GNUNET_SYSERR if a result was invalid (non-existing field or NULL)
778 post_extract_uint64 (void *cls,
779 struct GNUNET_MY_ResultSpec *rs,
784 if (rs->dst_size != rs->mysql_bind_output_length)
785 return GNUNET_SYSERR;
793 * @param[out] u64 where to store the result
794 * @return array entry for the result specification to use
796 struct GNUNET_MY_ResultSpec
797 GNUNET_MY_result_spec_uint64 (uint64_t *u64)
799 struct GNUNET_MY_ResultSpec res = {
800 .pre_conv = &pre_extract_uint64,
801 .post_conv = &post_extract_uint64,
804 .dst_size = sizeof (*u64),
811 /* end of pq_result_helper.c */