GNUnet  0.11.x
gnunet-service-scalarproduct_alice.c
Go to the documentation of this file.
1 /*
2  This file is part of GNUnet.
3  Copyright (C) 2013, 2014, 2017 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 <limits.h>
28 #include <gcrypt.h>
29 #include "gnunet_util_lib.h"
30 #include "gnunet_core_service.h"
31 #include "gnunet_cadet_service.h"
32 #include "gnunet_applications.h"
33 #include "gnunet_protocols.h"
35 #include "gnunet_set_service.h"
36 #include "scalarproduct.h"
38 
39 #define LOG(kind, ...) \
40  GNUNET_log_from (kind, "scalarproduct-alice", __VA_ARGS__)
41 
45 struct MpiElement
46 {
52  const struct GNUNET_HashCode *key;
53 
57  gcry_mpi_t value;
58 };
59 
60 
66 {
70  struct GNUNET_HashCode session_id;
71 
75  struct GNUNET_PeerIdentity peer;
76 
80  struct GNUNET_SERVICE_Client *client;
81 
85  struct GNUNET_MQ_Handle *client_mq;
86 
90  struct GNUNET_MQ_Handle *cadet_mq;
91 
96  struct GNUNET_CONTAINER_MultiHashMap *intersected_elements;
97 
102  struct GNUNET_SET_Handle *intersection_set;
103 
108  struct GNUNET_SET_OperationHandle *intersection_op;
109 
113  struct GNUNET_SET_ListenHandle *intersection_listen;
114 
118  struct GNUNET_CADET_Channel *channel;
119 
123  struct MpiElement *sorted_elements;
124 
129 
134 
139 
144 
148  gcry_mpi_t product;
149 
154  uint32_t total;
155 
161  uint32_t used_element_count;
162 
167  uint32_t client_received_element_count;
168 
174 
182 
187  int in_destroy;
188 };
189 
190 
194 static const struct GNUNET_CONFIGURATION_Handle *cfg;
195 
200 
205 
209 static gcry_mpi_t my_offset;
210 
215 
216 
225 static int
226 free_element_cb (void *cls, const struct GNUNET_HashCode *key, void *value)
227 {
229 
230  GNUNET_free (e);
231  return GNUNET_OK;
232 }
233 
234 
240 static void
242 {
243  if (GNUNET_YES == s->in_destroy)
244  return;
245  s->in_destroy = GNUNET_YES;
246  if (NULL != s->client)
247  {
248  struct GNUNET_SERVICE_Client *c = s->client;
249 
250  s->client = NULL;
252  }
253  if (NULL != s->channel)
254  {
256  s->channel = NULL;
257  }
258  if (NULL != s->intersected_elements)
259  {
262  s);
264  s->intersected_elements = NULL;
265  }
266  if (NULL != s->intersection_listen)
267  {
269  s->intersection_listen = NULL;
270  }
271  if (NULL != s->intersection_op)
272  {
274  s->intersection_op = NULL;
275  }
276  if (NULL != s->intersection_set)
277  {
279  s->intersection_set = NULL;
280  }
281  if (NULL != s->sorted_elements)
282  {
283  for (unsigned int i = 0; i < s->used_element_count; i++)
284  gcry_mpi_release (s->sorted_elements[i].value);
286  s->sorted_elements = NULL;
287  }
288  if (NULL != s->r)
289  {
290  GNUNET_free (s->r);
291  s->r = NULL;
292  }
293  if (NULL != s->r_prime)
294  {
295  GNUNET_free (s->r_prime);
296  s->r_prime = NULL;
297  }
298  if (NULL != s->product)
299  {
300  gcry_mpi_release (s->product);
301  s->product = NULL;
302  }
303  GNUNET_free (s);
304 }
305 
306 
313 static void
315 {
316  struct ClientResponseMessage *msg;
317  struct GNUNET_MQ_Envelope *e;
318 
319  if (NULL == session->client_mq)
320  return; /* no client left to be notified */
321  GNUNET_log (
323  "Sending session-end notification with status %d to client for session %s\n",
324  session->status,
325  GNUNET_h2s (&session->session_id));
327  msg->product_length = htonl (0);
328  msg->status = htonl (session->status);
329  GNUNET_MQ_send (session->client_mq, e);
330 }
331 
332 
339 static void
341 {
342  struct ClientResponseMessage *msg;
343  struct GNUNET_MQ_Envelope *e;
344  unsigned char *product_exported = NULL;
345  size_t product_length = 0;
346  int32_t range;
347  gcry_error_t rc;
348  int sign;
349  gcry_mpi_t value;
350 
351  if (NULL == s->product)
352  {
353  GNUNET_break (0);
355  return;
356  }
357  value = gcry_mpi_new (0);
358  sign = gcry_mpi_cmp_ui (s->product, 0);
359  if (0 > sign)
360  {
361  range = -1;
362  gcry_mpi_sub (value, value, s->product);
363  }
364  else if (0 < sign)
365  {
366  range = 1;
367  gcry_mpi_add (value, value, s->product);
368  }
369  else
370  {
371  /* result is exactly zero */
372  range = 0;
373  }
374  gcry_mpi_release (s->product);
375  s->product = NULL;
376 
377  if ((0 != range) && (0 != (rc = gcry_mpi_aprint (GCRYMPI_FMT_STD,
378  &product_exported,
379  &product_length,
380  value))))
381  {
382  LOG_GCRY (GNUNET_ERROR_TYPE_ERROR, "gcry_mpi_scan", rc);
384  return;
385  }
386  gcry_mpi_release (value);
387  e = GNUNET_MQ_msg_extra (msg,
388  product_length,
391  msg->range = htonl (range);
392  msg->product_length = htonl (product_length);
393  if (NULL != product_exported)
394  {
395  GNUNET_memcpy (&msg[1], product_exported, product_length);
396  GNUNET_free (product_exported);
397  }
398  GNUNET_MQ_send (s->client_mq, e);
400  "Sent result to client, session %s has ended!\n",
401  GNUNET_h2s (&s->session_id));
402 }
403 
404 
414 static void
415 cb_channel_destruction (void *cls, const struct GNUNET_CADET_Channel *channel)
416 {
417  struct AliceServiceSession *s = cls;
418 
420  "Peer disconnected, terminating session %s with peer %s\n",
421  GNUNET_h2s (&s->session_id),
422  GNUNET_i2s (&s->peer));
424  {
425  /* We didn't get an answer yet, fail with error */
428  }
429  s->channel = NULL;
430 }
431 
432 
440 static gcry_mpi_t
442  uint32_t length)
443 {
444  gcry_mpi_t elem;
445  gcry_mpi_t sum;
446  uint32_t i;
447 
448  GNUNET_assert (NULL != (sum = gcry_mpi_new (0)));
449  GNUNET_assert (NULL != (elem = gcry_mpi_new (0)));
450  for (i = 0; i < length; i++)
451  {
452  gcry_mpi_mul (elem, vector[i].value, vector[i].value);
453  gcry_mpi_add (sum, sum, elem);
454  }
455  gcry_mpi_release (elem);
456  return sum;
457 }
458 
459 
467 static gcry_mpi_t
468 compute_square_sum (const gcry_mpi_t *vector, uint32_t length)
469 {
470  gcry_mpi_t elem;
471  gcry_mpi_t sum;
472  uint32_t i;
473 
474  GNUNET_assert (NULL != (sum = gcry_mpi_new (0)));
475  GNUNET_assert (NULL != (elem = gcry_mpi_new (0)));
476  for (i = 0; i < length; i++)
477  {
478  gcry_mpi_mul (elem, vector[i], vector[i]);
479  gcry_mpi_add (sum, sum, elem);
480  }
481  gcry_mpi_release (elem);
482  return sum;
483 }
484 
485 
492 static gcry_mpi_t
494 {
495  uint32_t count;
496  gcry_mpi_t t;
497  gcry_mpi_t u;
498  gcry_mpi_t u_prime;
499  gcry_mpi_t p;
500  gcry_mpi_t p_prime;
501  gcry_mpi_t tmp;
502  gcry_mpi_t r[session->used_element_count];
503  gcry_mpi_t r_prime[session->used_element_count];
504  gcry_mpi_t s;
505  gcry_mpi_t s_prime;
506  unsigned int i;
507 
508  count = session->used_element_count;
509  // due to the introduced static offset S, we now also have to remove this
510  // from the E(a_pi)(+)E(-b_pi-r_pi) and E(a_qi)(+)E(-r_qi) twice each,
511  // the result is E((S + a_pi) + (S -b_pi-r_pi)) and E(S + a_qi + S - r_qi)
512  for (i = 0; i < count; i++)
513  {
514  r[i] = gcry_mpi_new (0);
516  &my_pubkey,
517  &session->r[i],
518  r[i]);
519  gcry_mpi_sub (r[i], r[i], my_offset);
520  gcry_mpi_sub (r[i], r[i], my_offset);
521  r_prime[i] = gcry_mpi_new (0);
523  &my_pubkey,
524  &session->r_prime[i],
525  r_prime[i]);
526  gcry_mpi_sub (r_prime[i], r_prime[i], my_offset);
527  gcry_mpi_sub (r_prime[i], r_prime[i], my_offset);
528  }
529 
530  // calculate t = sum(ai)
531  t = compute_square_sum_mpi_elements (session->sorted_elements, count);
532  // calculate U
533  u = gcry_mpi_new (0);
534  tmp = compute_square_sum (r, count);
535  gcry_mpi_sub (u, u, tmp);
536  gcry_mpi_release (tmp);
537 
538  // calculate U'
539  u_prime = gcry_mpi_new (0);
540  tmp = compute_square_sum (r_prime, count);
541  gcry_mpi_sub (u_prime, u_prime, tmp);
542 
543  GNUNET_assert (p = gcry_mpi_new (0));
544  GNUNET_assert (p_prime = gcry_mpi_new (0));
545  GNUNET_assert (s = gcry_mpi_new (0));
546  GNUNET_assert (s_prime = gcry_mpi_new (0));
547 
548  // compute P
551  &my_pubkey,
552  &session->s_prime,
553  s_prime);
554 
555  // compute P
556  gcry_mpi_add (p, s, t);
557  gcry_mpi_add (p, p, u);
558 
559  // compute P'
560  gcry_mpi_add (p_prime, s_prime, t);
561  gcry_mpi_add (p_prime, p_prime, u_prime);
562 
563  gcry_mpi_release (t);
564  gcry_mpi_release (u);
565  gcry_mpi_release (u_prime);
566  gcry_mpi_release (s);
567  gcry_mpi_release (s_prime);
568 
569  // compute product
570  gcry_mpi_sub (p, p, p_prime);
571  gcry_mpi_release (p_prime);
572  tmp = gcry_mpi_set_ui (tmp, 2);
573  gcry_mpi_div (p, NULL, p, tmp, 0);
574 
575  gcry_mpi_release (tmp);
576  for (i = 0; i < count; i++)
577  {
578  gcry_mpi_release (session->sorted_elements[i].value);
579  gcry_mpi_release (r[i]);
580  gcry_mpi_release (r_prime[i]);
581  }
582  GNUNET_free (session->sorted_elements);
583  session->sorted_elements = NULL;
584  GNUNET_free (session->r);
585  session->r = NULL;
586  GNUNET_free (session->r_prime);
587  session->r_prime = NULL;
588 
589  return p;
590 }
591 
592 
602 static int
604  void *cls,
605  const struct BobCryptodataMultipartMessage *msg)
606 {
607  struct AliceServiceSession *s = cls;
608  uint32_t contained;
609  size_t msg_size;
610  size_t required_size;
611 
612  msg_size = ntohs (msg->header.size);
613  contained = ntohl (msg->contained_element_count);
614  required_size =
615  sizeof(struct BobCryptodataMultipartMessage)
616  + 2 * contained * sizeof(struct GNUNET_CRYPTO_PaillierCiphertext);
617  if ((required_size != msg_size) ||
618  (s->cadet_received_element_count + contained > s->used_element_count))
619  {
620  GNUNET_break (0);
621  return GNUNET_SYSERR;
622  }
623  return GNUNET_OK;
624 }
625 
626 
634 static void
636  void *cls,
637  const struct BobCryptodataMultipartMessage *msg)
638 {
639  struct AliceServiceSession *s = cls;
641  size_t i;
642  uint32_t contained;
643 
644  contained = ntohl (msg->contained_element_count);
646  "Received %u additional crypto values from Bob\n",
647  (unsigned int) contained);
648 
649  payload = (const struct GNUNET_CRYPTO_PaillierCiphertext *) &msg[1];
650  /* Convert each k[][perm] to its MPI_value */
651  for (i = 0; i < contained; i++)
652  {
654  &payload[2 * i],
655  sizeof(struct GNUNET_CRYPTO_PaillierCiphertext));
657  &payload[2 * i],
658  sizeof(struct GNUNET_CRYPTO_PaillierCiphertext));
659  }
660  s->cadet_received_element_count += contained;
663  return; /* more to come */
664 
667 }
668 
669 
679 static int
681  const struct BobCryptodataMessage *msg)
682 {
683  struct AliceServiceSession *s = cls;
684  uint32_t contained;
685  uint16_t msg_size;
686  size_t required_size;
687 
688  msg_size = ntohs (msg->header.size);
689  contained = ntohl (msg->contained_element_count);
690  required_size =
691  sizeof(struct BobCryptodataMessage)
692  + 2 * contained * sizeof(struct GNUNET_CRYPTO_PaillierCiphertext)
693  + 2 * sizeof(struct GNUNET_CRYPTO_PaillierCiphertext);
694  if ((msg_size != required_size) || (contained > UINT16_MAX) ||
695  (s->used_element_count < contained))
696  {
697  GNUNET_break_op (0);
698  return GNUNET_SYSERR;
699  }
700  if (NULL == s->sorted_elements)
701  {
702  /* we're not ready yet, how can Bob be? */
703  GNUNET_break_op (0);
704  return GNUNET_SYSERR;
705  }
707  {
708  /* we're not ready yet, how can Bob be? */
709  GNUNET_break_op (0);
710  return GNUNET_SYSERR;
711  }
712  return GNUNET_OK;
713 }
714 
715 
723 static void
725  const struct BobCryptodataMessage *msg)
726 {
727  struct AliceServiceSession *s = cls;
729  uint32_t i;
730  uint32_t contained;
731 
732  contained = ntohl (msg->contained_element_count);
734  "Received %u crypto values from Bob\n",
735  (unsigned int) contained);
736  payload = (const struct GNUNET_CRYPTO_PaillierCiphertext *) &msg[1];
737  GNUNET_memcpy (&s->s,
738  &payload[0],
739  sizeof(struct GNUNET_CRYPTO_PaillierCiphertext));
740  GNUNET_memcpy (&s->s_prime,
741  &payload[1],
742  sizeof(struct GNUNET_CRYPTO_PaillierCiphertext));
743  payload = &payload[2];
744 
749  for (i = 0; i < contained; i++)
750  {
751  GNUNET_memcpy (&s->r[i],
752  &payload[2 * i],
753  sizeof(struct GNUNET_CRYPTO_PaillierCiphertext));
754  GNUNET_memcpy (&s->r_prime[i],
755  &payload[2 * i + 1],
756  sizeof(struct GNUNET_CRYPTO_PaillierCiphertext));
757  }
758  s->cadet_received_element_count = contained;
760 
762  {
763  /* More to come */
764  return;
765  }
768 }
769 
770 
779 static int
780 copy_element_cb (void *cls, const struct GNUNET_HashCode *key, void *value)
781 {
782  struct AliceServiceSession *s = cls;
784  gcry_mpi_t mval;
785  int64_t val;
786 
787  mval = gcry_mpi_new (0);
788  val = (int64_t) GNUNET_ntohll (e->value);
789  if (0 > val)
790  gcry_mpi_sub_ui (mval, mval, -val);
791  else
792  gcry_mpi_add_ui (mval, mval, val);
795  s->used_element_count++;
796  return GNUNET_OK;
797 }
798 
799 
807 static int
808 element_cmp (const void *a, const void *b)
809 {
810  const struct MpiElement *ma = a;
811  const struct MpiElement *mb = b;
812 
813  return GNUNET_CRYPTO_hash_cmp (ma->key, mb->key);
814 }
815 
816 
821 #define ELEMENT_CAPACITY \
822  ((GNUNET_CONSTANTS_MAX_CADET_MESSAGE_SIZE - 1 \
823  - sizeof(struct AliceCryptodataMessage)) \
824  / sizeof(struct GNUNET_CRYPTO_PaillierCiphertext))
825 
826 
833 static void
835 {
836  struct AliceCryptodataMessage *msg;
837  struct GNUNET_MQ_Envelope *e;
839  unsigned int i;
840  uint32_t todo_count;
841  gcry_mpi_t a;
842  uint32_t off;
843 
846  * sizeof(struct MpiElement));
847  s->used_element_count = 0;
850  s);
852  "Finished intersection, %d items remain\n",
853  s->used_element_count);
854  qsort (s->sorted_elements,
856  sizeof(struct MpiElement),
857  &element_cmp);
858  off = 0;
859  while (off < s->used_element_count)
860  {
861  todo_count = s->used_element_count - off;
862  if (todo_count > ELEMENT_CAPACITY)
863  todo_count = ELEMENT_CAPACITY;
865  "Sending %u/%u crypto values to Bob\n",
866  (unsigned int) todo_count,
867  (unsigned int) s->used_element_count);
868 
869  e =
870  GNUNET_MQ_msg_extra (msg,
871  todo_count
872  * sizeof(struct GNUNET_CRYPTO_PaillierCiphertext),
874  msg->contained_element_count = htonl (todo_count);
875  payload = (struct GNUNET_CRYPTO_PaillierCiphertext *) &msg[1];
876  a = gcry_mpi_new (0);
877  for (i = off; i < off + todo_count; i++)
878  {
879  gcry_mpi_add (a, s->sorted_elements[i].value, my_offset);
880  GNUNET_assert (
881  3 ==
882  GNUNET_CRYPTO_paillier_encrypt (&my_pubkey, a, 3, &payload[i - off]));
883  }
884  gcry_mpi_release (a);
885  off += todo_count;
886  GNUNET_MQ_send (s->cadet_mq, e);
887  }
888 }
889 
890 
901 static void
903  const struct GNUNET_SET_Element *element,
904  uint64_t current_size,
906 {
907  struct AliceServiceSession *s = cls;
908  struct GNUNET_SCALARPRODUCT_Element *se;
909 
910  switch (status)
911  {
913  /* this element has been removed from the set */
915  element->data);
916  GNUNET_assert (NULL != se);
918  "Intersection removed element with key %s and value %lld\n",
919  GNUNET_h2s (&se->key),
920  (long long) GNUNET_ntohll (se->value));
921  GNUNET_assert (
922  GNUNET_YES ==
924  element->data,
925  se));
926  GNUNET_free (se);
927  return;
928 
930  s->intersection_op = NULL;
931  if (NULL != s->intersection_set)
932  {
934  s->intersection_set = NULL;
935  }
937  return;
938 
940  /* unexpected for intersection */
941  GNUNET_break (0);
942  return;
943 
945  /* unhandled status code */
946  LOG (GNUNET_ERROR_TYPE_DEBUG, "Set intersection failed!\n");
947  if (NULL != s->intersection_listen)
948  {
950  s->intersection_listen = NULL;
951  }
952  s->intersection_op = NULL;
953  if (NULL != s->intersection_set)
954  {
956  s->intersection_set = NULL;
957  }
960  return;
961 
962  default:
963  GNUNET_break (0);
964  return;
965  }
966 }
967 
968 
984 static void
986  const struct GNUNET_PeerIdentity *other_peer,
987  const struct GNUNET_MessageHeader *context_msg,
988  struct GNUNET_SET_Request *request)
989 {
990  struct AliceServiceSession *s = cls;
991 
992  if (0 != GNUNET_memcmp (other_peer, &s->peer))
993  {
994  GNUNET_break_op (0);
995  return;
996  }
997  s->intersection_op = GNUNET_SET_accept (request,
999  (struct GNUNET_SET_Option[]){ { 0 } },
1001  s);
1002  if (NULL == s->intersection_op)
1003  {
1004  GNUNET_break (0);
1007  return;
1008  }
1010  {
1011  GNUNET_break (0);
1014  return;
1015  }
1016 }
1017 
1018 
1024 static void
1026 {
1027  struct GNUNET_MQ_MessageHandler cadet_handlers[] =
1028  { GNUNET_MQ_hd_var_size (bobs_cryptodata_message,
1030  struct BobCryptodataMessage,
1031  s),
1033  bobs_cryptodata_multipart,
1036  s),
1037  GNUNET_MQ_handler_end () };
1038  struct ServiceRequestMessage *msg;
1039  struct GNUNET_MQ_Envelope *e;
1040 
1042  "Creating new channel for session with key %s.\n",
1043  GNUNET_h2s (&s->session_id));
1044  s->channel = GNUNET_CADET_channel_create (my_cadet,
1045  s,
1046  &s->peer,
1047  &s->session_id,
1048  NULL,
1050  cadet_handlers);
1051  if (NULL == s->channel)
1052  {
1055  return;
1056  }
1060  &s->session_id,
1062  s);
1063  if (NULL == s->intersection_listen)
1064  {
1067  s->channel = NULL;
1069  return;
1070  }
1071 
1072  e = GNUNET_MQ_msg (msg,
1074  msg->session_id = s->session_id;
1075  msg->public_key = my_pubkey;
1076  GNUNET_MQ_send (s->cadet_mq, e);
1077 }
1078 
1079 
1088 static int
1090  void *cls,
1092 {
1093  struct AliceServiceSession *s = cls;
1094  uint32_t contained_count;
1095  uint16_t msize;
1096 
1097  msize = ntohs (msg->header.size);
1098  contained_count = ntohl (msg->element_count_contained);
1099  if ((msize !=
1101  + contained_count * sizeof(struct GNUNET_SCALARPRODUCT_Element))) ||
1102  (0 == contained_count) ||
1103  (s->total == s->client_received_element_count) ||
1104  (s->total < s->client_received_element_count + contained_count))
1105  {
1106  GNUNET_break_op (0);
1107  return GNUNET_SYSERR;
1108  }
1109  return GNUNET_OK;
1110 }
1111 
1112 
1120 static void
1122  void *cls,
1124 {
1125  struct AliceServiceSession *s = cls;
1126  uint32_t contained_count;
1127  const struct GNUNET_SCALARPRODUCT_Element *elements;
1128  struct GNUNET_SET_Element set_elem;
1129  struct GNUNET_SCALARPRODUCT_Element *elem;
1130 
1131  contained_count = ntohl (msg->element_count_contained);
1132  s->client_received_element_count += contained_count;
1133  elements = (const struct GNUNET_SCALARPRODUCT_Element *) &msg[1];
1134  for (uint32_t i = 0; i < contained_count; i++)
1135  {
1136  elem = GNUNET_new (struct GNUNET_SCALARPRODUCT_Element);
1137  GNUNET_memcpy (elem,
1138  &elements[i],
1139  sizeof(struct GNUNET_SCALARPRODUCT_Element));
1142  &elem->key,
1143  elem,
1145  {
1146  GNUNET_break (0);
1147  GNUNET_free (elem);
1148  continue;
1149  }
1150  set_elem.data = &elem->key;
1151  set_elem.size = sizeof(elem->key);
1152  set_elem.element_type = 0;
1153  GNUNET_SET_add_element (s->intersection_set, &set_elem, NULL, NULL);
1154  s->used_element_count++;
1155  }
1157  if (s->total != s->client_received_element_count)
1158  {
1159  /* more to come */
1160  return;
1161  }
1163 }
1164 
1165 
1174 static int
1176  const struct AliceComputationMessage *msg)
1177 {
1178  struct AliceServiceSession *s = cls;
1179  uint16_t msize;
1180  uint32_t total_count;
1181  uint32_t contained_count;
1182 
1183  if (NULL != s->intersected_elements)
1184  {
1185  /* only one concurrent session per client connection allowed,
1186  simplifies logic a lot... */
1187  GNUNET_break (0);
1188  return GNUNET_SYSERR;
1189  }
1190  msize = ntohs (msg->header.size);
1191  total_count = ntohl (msg->element_count_total);
1192  contained_count = ntohl (msg->element_count_contained);
1193  if ((0 == total_count) || (0 == contained_count) ||
1194  (msize !=
1195  (sizeof(struct AliceComputationMessage)
1196  + contained_count * sizeof(struct GNUNET_SCALARPRODUCT_Element))))
1197  {
1198  GNUNET_break_op (0);
1199  return GNUNET_SYSERR;
1200  }
1201  return GNUNET_OK;
1202 }
1203 
1204 
1212 static void
1214  const struct AliceComputationMessage *msg)
1215 {
1216  struct AliceServiceSession *s = cls;
1217  uint32_t contained_count;
1218  uint32_t total_count;
1219  const struct GNUNET_SCALARPRODUCT_Element *elements;
1220  struct GNUNET_SET_Element set_elem;
1221  struct GNUNET_SCALARPRODUCT_Element *elem;
1222 
1223  total_count = ntohl (msg->element_count_total);
1224  contained_count = ntohl (msg->element_count_contained);
1225  s->peer = msg->peer;
1227  s->total = total_count;
1228  s->client_received_element_count = contained_count;
1229  s->session_id = msg->session_key;
1230  elements = (const struct GNUNET_SCALARPRODUCT_Element *) &msg[1];
1233  s->intersection_set =
1235 
1236  for (uint32_t i = 0; i < contained_count; i++)
1237  {
1238  if (0 == GNUNET_ntohll (elements[i].value))
1239  continue;
1240  elem = GNUNET_new (struct GNUNET_SCALARPRODUCT_Element);
1241  GNUNET_memcpy (elem,
1242  &elements[i],
1243  sizeof(struct GNUNET_SCALARPRODUCT_Element));
1246  &elem->key,
1247  elem,
1249  {
1250  /* element with same key encountered twice! */
1251  GNUNET_break (0);
1252  GNUNET_free (elem);
1253  continue;
1254  }
1255  set_elem.data = &elem->key;
1256  set_elem.size = sizeof(elem->key);
1257  set_elem.element_type = 0;
1258  GNUNET_SET_add_element (s->intersection_set, &set_elem, NULL, NULL);
1259  s->used_element_count++;
1260  }
1262  if (s->total != s->client_received_element_count)
1263  {
1264  /* wait for multipart msg */
1265  return;
1266  }
1268 }
1269 
1270 
1276 static void
1277 shutdown_task (void *cls)
1278 {
1279  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Shutting down, initiating cleanup.\n");
1280  // FIXME: we have to cut our connections to CADET first!
1281  if (NULL != my_cadet)
1282  {
1283  GNUNET_CADET_disconnect (my_cadet);
1284  my_cadet = NULL;
1285  }
1286 }
1287 
1288 
1299 static void *
1301  struct GNUNET_SERVICE_Client *client,
1302  struct GNUNET_MQ_Handle *mq)
1303 {
1304  struct AliceServiceSession *s;
1305 
1306  s = GNUNET_new (struct AliceServiceSession);
1307  s->client = client;
1308  s->client_mq = mq;
1309  return s;
1310 }
1311 
1312 
1323 static void
1325  struct GNUNET_SERVICE_Client *client,
1326  void *app_cls)
1327 {
1328  struct AliceServiceSession *s = app_cls;
1329 
1331  "Client %p disconnected from us.\n",
1332  client);
1333  s->client = NULL;
1334  s->client_mq = NULL;
1336 }
1337 
1338 
1346 static void
1347 run (void *cls,
1348  const struct GNUNET_CONFIGURATION_Handle *c,
1350 {
1351  cfg = c;
1352  /*
1353  offset has to be sufficiently small to allow computation of:
1354  m1+m2 mod n == (S + a) + (S + b) mod n,
1355  if we have more complex operations, this factor needs to be lowered */
1356  my_offset = gcry_mpi_new (GNUNET_CRYPTO_PAILLIER_BITS / 3);
1357  gcry_mpi_set_bit (my_offset, GNUNET_CRYPTO_PAILLIER_BITS / 3);
1359  my_cadet = GNUNET_CADET_connect (cfg);
1361  if (NULL == my_cadet)
1362  {
1363  GNUNET_log (GNUNET_ERROR_TYPE_ERROR, _ ("Connect to CADET failed\n"));
1365  return;
1366  }
1367 }
1368 
1369 
1374  "scalarproduct-alice",
1376  &run,
1379  NULL,
1380  GNUNET_MQ_hd_var_size (alice_client_message,
1382  struct AliceComputationMessage,
1383  NULL),
1385  alice_client_message_multipart,
1388  NULL),
1390 
1391 
1392 /* end of gnunet-service-scalarproduct_alice.c */
A scalarproduct session which tracks a request form the client to our final response.
Message type passed from service client to finalize a session as requester or responder.
int in_destroy
Flag to prevent recursive calls to destroy_service_session() from doing harm.
void GNUNET_CADET_disconnect(struct GNUNET_CADET_Handle *handle)
Disconnect from the cadet service.
Definition: cadet_api.c:841
static struct GNUNET_CRYPTO_PaillierPrivateKey my_privkey
Service&#39;s own private key.
struct GNUNET_SET_ListenHandle * GNUNET_SET_listen(const struct GNUNET_CONFIGURATION_Handle *cfg, enum GNUNET_SET_OperationType op_type, const struct GNUNET_HashCode *app_id, GNUNET_SET_ListenCallback listen_cb, void *listen_cls)
Wait for set operation requests for the given application ID.
Definition: set_api.c:1017
static struct GNUNET_SERVICE_Handle * service
Handle to our service instance.
static gcry_mpi_t my_offset
Service&#39;s offset for values that could possibly be negative but are plaintext for encryption...
struct GNUNET_MessageHeader * msg
Definition: 005.c:2
struct GNUNET_CRYPTO_PaillierPublicKey public_key
Alice&#39;s public key.
static struct GNUNET_VPN_RedirectionRequest * request
Opaque redirection request handle.
Definition: gnunet-vpn.c:41
struct GNUNET_CADET_Channel * channel
channel-handle associated with our cadet handle
#define GNUNET_MESSAGE_TYPE_SCALARPRODUCT_CLIENT_MULTIPART_ALICE
Client -> Alice multipart.
struct GNUNET_MQ_Handle * cadet_mq
The message queue for CADET.
static void handle_bobs_cryptodata_multipart(void *cls, const struct BobCryptodataMultipartMessage *msg)
Handle a multipart chunk of a response we got from another service we wanted to calculate a scalarpro...
unsigned int GNUNET_CONTAINER_multihashmap_size(const struct GNUNET_CONTAINER_MultiHashMap *map)
Get the number of key-value pairs in the map.
static struct GNUNET_CRYPTO_PaillierPublicKey my_pubkey
Service&#39;s own public key.
int GNUNET_SET_add_element(struct GNUNET_SET_Handle *set, const struct GNUNET_SET_Element *element, GNUNET_SET_Continuation cont, void *cont_cls)
Add an element to the given set.
Definition: set_api.c:687
Handle for a set operation request from another peer.
Definition: set_api.c:115
Opaque handle to the service.
Definition: cadet_api.c:38
Handle to a service.
Definition: service.c:116
#define GNUNET_MESSAGE_TYPE_SCALARPRODUCT_SESSION_INITIALIZATION
Alice -> Bob session initialization.
const struct GNUNET_HashCode * key
Key used to identify matching pairs of values to multiply.
static void prepare_client_end_notification(struct AliceServiceSession *session)
Notify the client that the session has failed.
Operation is still active (never returned, used internally).
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_shutdown(GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run on shutdown, that is when a CTRL-C signal is received, or when GNUNET_SCHEDULER_shutdown() is being invoked.
Definition: scheduler.c:1300
static void shutdown_task(void *cls)
Task run during shutdown.
struct GNUNET_HashCode key
Key used to identify matching pairs of values to multiply.
struct GNUNET_CRYPTO_PaillierCiphertext s_prime
Bob&#39;s "s&#39;".
Element stored in a set.
static int check_bobs_cryptodata_message(void *cls, const struct BobCryptodataMessage *msg)
Check a response we got from another service we wanted to calculate a scalarproduct with...
struct GNUNET_SET_Handle * GNUNET_SET_create(const struct GNUNET_CONFIGURATION_Handle *cfg, enum GNUNET_SET_OperationType op)
Create an empty set, supporting the specified operation.
Definition: set_api.c:657
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
static void send_alices_cryptodata_message(struct AliceServiceSession *s)
Send the cryptographic data from Alice to Bob.
int32_t range
Workaround for libgcrypt: -1 if negative, 0 if zero, else 1.
#define LOG_GCRY(level, cmd, rc)
Log an error message at log-level &#39;level&#39; that indicates a failure of the command &#39;cmd&#39; with the mess...
Definition: scalarproduct.h:35
Message type passed from responding service Bob to responding service Alice to complete a request and...
struct GNUNET_MessageHeader header
GNUNET message header with type GNUNET_MESSAGE_TYPE_SCALARPRODUCT_CLIENT_TO_ALICE.
Definition: scalarproduct.h:51
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
static void handle_alice_client_message_multipart(void *cls, const struct ComputationBobCryptodataMultipartMessage *msg)
We&#39;re receiving additional set data.
#define GNUNET_MQ_msg(mvar, type)
Allocate a GNUNET_MQ_Envelope.
Definition: gnunet_mq_lib.h:67
static struct Experiment * e
static void client_disconnect_cb(void *cls, struct GNUNET_SERVICE_Client *client, void *app_cls)
A client disconnected.
Opaque handle to a channel.
Definition: cadet_api.c:80
const char * GNUNET_h2s(const struct GNUNET_HashCode *hc)
Convert a hash value to a string (for printing debug messages).
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
#define GNUNET_new(type)
Allocate a struct or union of the given type.
static void handle_bobs_cryptodata_message(void *cls, const struct BobCryptodataMessage *msg)
Handle a response we got from another service we wanted to calculate a scalarproduct with...
enum GNUNET_SCALARPRODUCT_ResponseStatus status
State of this session.
struct GNUNET_MessageHeader header
GNUNET message header with type GNUNET_MESSAGE_TYPE_SCALARPRODUCT_BOB_CRYPTODATA. ...
struct GNUNET_MessageHeader header
GNUNET message header.
static void run(void *cls, const struct GNUNET_CONFIGURATION_Handle *c, struct GNUNET_SERVICE_Handle *service)
Initialization of the program and message handlers.
gcry_mpi_t value
a_i value, not disclosed to Bob.
static struct GNUNET_SCHEDULER_Task * t
Main task.
uint16_t size
The length of the struct (in bytes, including the length field itself), in big-endian format...
void GNUNET_SCHEDULER_shutdown(void)
Request the shutdown of a scheduler.
Definition: scheduler.c:526
static gcry_mpi_t compute_square_sum_mpi_elements(const struct MpiElement *vector, uint32_t length)
Computes the square sum over a vector of a given length.
Success, all elements have been sent (and received).
Internal representation of the hash map.
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
uint32_t total
How many elements we were supplied with from the client (total count before intersection).
Message type passed from client to service to initiate a request or responder role.
Definition: scalarproduct.h:45
struct GNUNET_HashCode session_key
the transaction/session key used to identify a session
Definition: scalarproduct.h:71
const void * data
Actual data of the element.
struct GNUNET_CADET_Handle * GNUNET_CADET_connect(const struct GNUNET_CONFIGURATION_Handle *cfg)
Connect to the MQ-based cadet service.
Definition: cadet_api.c:976
struct GNUNET_CRYPTO_PaillierCiphertext * r_prime
Bob&#39;s permutation q of R.
struct GNUNET_SET_OperationHandle * intersection_op
Set of elements for which will conduction an intersection.
void GNUNET_CRYPTO_paillier_create(struct GNUNET_CRYPTO_PaillierPublicKey *public_key, struct GNUNET_CRYPTO_PaillierPrivateKey *private_key)
Create a freshly generated paillier public key.
void * GNUNET_CONTAINER_multihashmap_get(const struct GNUNET_CONTAINER_MultiHashMap *map, const struct GNUNET_HashCode *key)
Given a key find a value in the map matching the key.
#define _(String)
GNU gettext support macro.
Definition: platform.h:181
Handle to a client that is connected to a service.
Definition: service.c:250
static const struct GNUNET_CONFIGURATION_Handle * cfg
GNUnet configuration handle.
void GNUNET_SET_destroy(struct GNUNET_SET_Handle *set)
Destroy the set handle, and free all associated resources.
Definition: set_api.c:772
static int check_bobs_cryptodata_multipart(void *cls, const struct BobCryptodataMultipartMessage *msg)
Check a multipart chunk of a response we got from another service we wanted to calculate a scalarprod...
static int copy_element_cb(void *cls, const struct GNUNET_HashCode *key, void *value)
Iterator to copy over messages from the hash map into an array for sorting.
uint32_t status
Status information about the outcome of this session, An enum GNUNET_SCALARPRODUCT_ResponseStatus (in...
#define GNUNET_MQ_msg_extra(mvar, esize, type)
Allocate an envelope, with extra space allocated after the space needed by the message struct...
Definition: gnunet_mq_lib.h:52
static int element_cmp(const void *a, const void *b)
Compare two struct MpiValues by key for sorting.
static struct GNUNET_OS_Process * p
Helper process we started.
Definition: gnunet-qr.c:59
struct MpiElement * sorted_elements
a(Alice), sorted array by key of length used_element_count.
The other peer refused to to the operation with us, or something went wrong.
Success, all elements have been returned (but the other peer might still be receiving some from us...
struct GNUNET_PeerIdentity peer
the identity of a remote peer we want to communicate with
Definition: scalarproduct.h:76
Scalar Product API Message Types.
#define GNUNET_MQ_hd_var_size(name, code, str, ctx)
#define GNUNET_break_op(cond)
Use this for assertion violations caused by other peers (i.e.
Everything went ok, we are transmitting an element of the result (in set, or to be removed from set...
static void cb_intersection_element_removed(void *cls, const struct GNUNET_SET_Element *element, uint64_t current_size, enum GNUNET_SET_Status status)
Callback for set operation results.
void GNUNET_CONTAINER_multihashmap_destroy(struct GNUNET_CONTAINER_MultiHashMap *map)
Destroy a hash map.
static gcry_mpi_t compute_square_sum(const gcry_mpi_t *vector, uint32_t length)
Computes the square sum over a vector of a given length.
GNUNET_SET_Status
Status for the result callback.
static void destroy_service_session(struct AliceServiceSession *s)
Destroy session state, we are done with it.
uint32_t element_count_total
how many elements the vector in payload contains
Definition: scalarproduct.h:56
Message type passed from requesting service Alice to responding service Bob to initiate a request and...
uint16_t status
See PRISM_STATUS_*-constants.
#define GNUNET_new_array(n, type)
Allocate a size n array with structs or unions of the given type.
uint32_t cadet_received_element_count
Already transferred elements from Bob to us.
int GNUNET_CONTAINER_multihashmap_remove(struct GNUNET_CONTAINER_MultiHashMap *map, const struct GNUNET_HashCode *key, const void *value)
Remove the given key-value pair from the map.
#define GNUNET_MESSAGE_TYPE_SCALARPRODUCT_BOB_CRYPTODATA
Bob -> Alice SP crypto-data.
struct GNUNET_HashCode session_id
The transaction/session key used to identify a session.
void GNUNET_CRYPTO_paillier_decrypt(const struct GNUNET_CRYPTO_PaillierPrivateKey *private_key, const struct GNUNET_CRYPTO_PaillierPublicKey *public_key, const struct GNUNET_CRYPTO_PaillierCiphertext *ciphertext, gcry_mpi_t m)
Decrypt a paillier ciphertext with a private key.
GNUNET_SERVICE_MAIN("scalarproduct-alice", GNUNET_SERVICE_OPTION_NONE, &run, &client_connect_cb, &client_disconnect_cb, NULL, GNUNET_MQ_hd_var_size(alice_client_message, GNUNET_MESSAGE_TYPE_SCALARPRODUCT_CLIENT_TO_ALICE, struct AliceComputationMessage, NULL), GNUNET_MQ_hd_var_size(alice_client_message_multipart, GNUNET_MESSAGE_TYPE_SCALARPRODUCT_CLIENT_MULTIPART_ALICE, struct ComputationBobCryptodataMultipartMessage, NULL), GNUNET_MQ_handler_end())
Define "main" method using service macro.
A 512-bit hashcode.
static void handle_alice_client_message(void *cls, const struct AliceComputationMessage *msg)
Handler for Alice&#39;s client request message.
void GNUNET_SERVICE_client_drop(struct GNUNET_SERVICE_Client *c)
Ask the server to disconnect from the given client.
Definition: service.c:2324
Message handler for a specific message type.
static void transmit_client_response(struct AliceServiceSession *s)
Prepare the final (positive) response we will send to Alice&#39;s client.
Opaque handle to a set.
Definition: set_api.c:49
struct GNUNET_PeerIdentity peer
Alice or Bob&#39;s peerID.
static void cb_intersection_request_alice(void *cls, const struct GNUNET_PeerIdentity *other_peer, const struct GNUNET_MessageHeader *context_msg, struct GNUNET_SET_Request *request)
Called when another peer wants to do a set operation with the local peer.
struct GNUNET_HashCode session_id
(hopefully) unique transaction ID
There must only be one value per key; storing a value should fail if a value under the same key alrea...
Vector of Pallier-encrypted values sent by Alice to Bob (after set intersection). ...
#define GNUNET_MESSAGE_TYPE_SCALARPRODUCT_CLIENT_TO_ALICE
Client -> Alice.
#define GNUNET_SYSERR
Definition: gnunet_common.h:76
An encrypted element key-value pair.
scalarproduct service P2P messages
Multipart Message type passed between to supply additional elements for the peer. ...
void GNUNET_SET_listen_cancel(struct GNUNET_SET_ListenHandle *lh)
Cancel the given listen operation.
Definition: set_api.c:1051
uint32_t product_length
0 if no product attached
#define GNUNET_MESSAGE_TYPE_SCALARPRODUCT_BOB_CRYPTODATA_MULTIPART
Bob -> Alice SP crypto-data multipart.
Option for set operations.
int64_t value
Value to multiply in scalar product, in NBO.
int GNUNET_CONTAINER_multihashmap_put(struct GNUNET_CONTAINER_MultiHashMap *map, const struct GNUNET_HashCode *key, void *value, enum GNUNET_CONTAINER_MultiHashMapOption opt)
Store a key-value pair in the map.
static unsigned long long payload
How much data are we currently storing in the database?
uint32_t used_element_count
How many elements actually are used for the scalar product.
#define GNUNET_memcmp(a, b)
Compare memory in a and b, where both must be of the same pointer type.
struct GNUNET_CONTAINER_MultiHashMap * intersected_elements
all non-0-value&#39;d elements transmitted to us.
#define LOG(kind,...)
gcry_mpi_t product
The computed scalar.
Handle to an operation.
Definition: set_api.c:135
Handle to a message queue.
Definition: mq.c:85
#define GNUNET_MESSAGE_TYPE_SCALARPRODUCT_ALICE_CRYPTODATA
Alice -> Bob SP crypto-data (after intersection)
The identity of the host (wraps the signing key of the peer).
int GNUNET_SET_commit(struct GNUNET_SET_OperationHandle *oh, struct GNUNET_SET_Handle *set)
Commit a set to be used with a set operation.
Definition: set_api.c:1128
void GNUNET_CADET_receive_done(struct GNUNET_CADET_Channel *channel)
Send an ack on the channel to confirm the processing of a message.
Definition: cadet_api.c:954
static int check_alice_client_message_multipart(void *cls, const struct ComputationBobCryptodataMultipartMessage *msg)
We&#39;re receiving additional set data.
struct GNUNET_CADET_Channel * GNUNET_CADET_channel_create(struct GNUNET_CADET_Handle *h, void *channel_cls, const struct GNUNET_PeerIdentity *destination, const struct GNUNET_HashCode *port, GNUNET_CADET_WindowSizeEventHandler window_changes, GNUNET_CADET_DisconnectEventHandler disconnects, const struct GNUNET_MQ_MessageHandler *handlers)
Create a new channel towards a remote peer.
Definition: cadet_api.c:1068
struct GNUNET_MessageHeader header
GNUNET message header.
configuration data
Definition: configuration.c:85
static int free_element_cb(void *cls, const struct GNUNET_HashCode *key, void *value)
Iterator called to free elements.
static void * client_connect_cb(void *cls, struct GNUNET_SERVICE_Client *client, struct GNUNET_MQ_Handle *mq)
A client connected.
int GNUNET_CRYPTO_hash_cmp(const struct GNUNET_HashCode *h1, const struct GNUNET_HashCode *h2)
Compare function for HashCodes, producing a total ordering of all hashcodes.
Definition: crypto_hash.c:294
static int check_alice_client_message(void *cls, const struct AliceComputationMessage *msg)
Handler for Alice&#39;s client request message.
uint32_t contained_element_count
How many elements we supply within this message? In NBO.
uint16_t size
Number of bytes in the buffer pointed to by data.
struct GNUNET_MQ_Handle * mq
Definition: 003.c:5
#define GNUNET_log(kind,...)
uint32_t element_count_contained
contained elements the vector in payload contains
Definition: scalarproduct.h:61
uint32_t contained_element_count
How many elements we appended to this message? In NBO.
Opaque handle to a listen operation.
Definition: set_api.c:186
Client gets only elements that have been removed from the set.
struct GNUNET_CONTAINER_MultiHashMap * GNUNET_CONTAINER_multihashmap_create(unsigned int len, int do_not_copy_keys)
Create a multi hash map.
uint32_t element_count_contained
contained elements the vector in payload contains
void GNUNET_SET_operation_cancel(struct GNUNET_SET_OperationHandle *oh)
Cancel the given set operation.
Definition: set_api.c:516
multipart messages following struct ComputationMessage
Header for all communications.
#define GNUNET_YES
Definition: gnunet_common.h:77
struct GNUNET_SET_Handle * intersection_set
Set of elements for which will conduction an intersection.
void GNUNET_MQ_send(struct GNUNET_MQ_Handle *mq, struct GNUNET_MQ_Envelope *ev)
Send a message with the given message queue.
Definition: mq.c:353
struct GNUNET_SERVICE_Client * client
The client this request is related to.
static struct GNUNET_CADET_Handle * my_cadet
Handle to the CADET service.
Set intersection, only return elements that are in both sets.
uint32_t contained_element_count
How many elements this individual message delivers (in NBO).
GNUNET_SCALARPRODUCT_ResponseStatus
Result status values for the computation.
struct GNUNET_MQ_Handle * client_mq
The message queue for the client.
struct GNUNET_SET_ListenHandle * intersection_listen
Handle to Alice&#39;s Intersection operation listening for Bob.
#define ELEMENT_CAPACITY
Maximum number of elements we can put into a single cryptodata message.
struct GNUNET_CRYPTO_PaillierCiphertext * r
Bob&#39;s permutation p of R.
#define GNUNET_CRYPTO_PAILLIER_BITS
Size of paillier plain texts and public keys.
int GNUNET_CONTAINER_multihashmap_iterate(struct GNUNET_CONTAINER_MultiHashMap *map, GNUNET_CONTAINER_MulitHashMapIteratorCallback it, void *it_cls)
Iterate over all entries in the map.
struct GNUNET_CRYPTO_PaillierCiphertext s
Bob&#39;s "s".
uint32_t client_received_element_count
Already transferred elements from client to us.
void GNUNET_CADET_channel_destroy(struct GNUNET_CADET_Channel *channel)
Destroy an existing channel.
Definition: cadet_api.c:903
static gcry_mpi_t compute_scalar_product(struct AliceServiceSession *session)
Compute our scalar product, done by Alice.
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
void GNUNET_SERVICE_client_continue(struct GNUNET_SERVICE_Client *c)
Continue receiving further messages from the given client.
Definition: service.c:2243
#define GNUNET_MQ_handler_end()
End-marker for the handlers array.
#define GNUNET_malloc(size)
Wrapper around malloc.
An element key-value pair for scalarproduct.
uint64_t GNUNET_ntohll(uint64_t n)
Convert unsigned 64-bit integer to host byte order.
Definition: common_endian.c:48
#define GNUNET_MESSAGE_TYPE_SCALARPRODUCT_RESULT
Alice/Bob -> Client Result.
#define GNUNET_free(ptr)
Wrapper around free.
uint16_t element_type
Application-specific element type.
struct GNUNET_SET_OperationHandle * GNUNET_SET_accept(struct GNUNET_SET_Request *request, enum GNUNET_SET_ResultMode result_mode, struct GNUNET_SET_Option options[], GNUNET_SET_ResultIterator result_cb, void *result_cls)
Accept a request we got via GNUNET_SET_listen().
Definition: set_api.c:1085
static void client_request_complete_alice(struct AliceServiceSession *s)
Our client has finished sending us its multipart message.
static void cb_channel_destruction(void *cls, const struct GNUNET_CADET_Channel *channel)
Function called whenever a channel is destroyed.
struct GNUNET_MQ_Handle * GNUNET_CADET_get_mq(const struct GNUNET_CADET_Channel *channel)
Obtain the message queue for a connected peer.
Definition: cadet_api.c:1119
int GNUNET_CRYPTO_paillier_encrypt(const struct GNUNET_CRYPTO_PaillierPublicKey *public_key, const gcry_mpi_t m, int desired_ops, struct GNUNET_CRYPTO_PaillierCiphertext *ciphertext)
Encrypt a plaintext with a paillier public key.