GNUnet  0.11.x
gnunet-service-scalarproduct-ecc_bob.c
Go to the documentation of this file.
1 /*
2  This file is part of GNUnet.
3  Copyright (C) 2013-2017, 2021 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_seti_service.h"
36 #include "scalarproduct.h"
38 
39 #define LOG(kind, ...) GNUNET_log_from (kind, "scalarproduct-bob", __VA_ARGS__)
40 
41 
45 struct MpiElement
46 {
52  const struct GNUNET_HashCode *key;
53 
57  int64_t value;
58 };
59 
60 
66 {
71 
76 
81 
87 
93 
98 
103 
108 
113 
117  uint32_t total;
118 
124 
131 
137 
145 
150 
155 
159  struct GNUNET_PeerIdentity peer;
160 
165 
170 };
171 
172 
176 static const struct GNUNET_CONFIGURATION_Handle *cfg;
177 
182 
187 
188 
196 static int
197 free_element_cb (void *cls,
198  const struct GNUNET_HashCode *key,
199  void *value)
200 {
201  struct GNUNET_SCALARPRODUCT_Element *element = value;
202 
203  GNUNET_free (element);
204  return GNUNET_OK;
205 }
206 
207 
213 static void
215 {
216  if (GNUNET_YES == s->in_destroy)
217  return;
218  s->in_destroy = GNUNET_YES;
219  if (NULL != s->client)
220  {
221  struct GNUNET_SERVICE_Client *c = s->client;
222 
223  s->client = NULL;
225  }
226  if (NULL != s->intersected_elements)
227  {
230  NULL);
232  s->intersected_elements = NULL;
233  }
234  if (NULL != s->intersection_op)
235  {
237  s->intersection_op = NULL;
238  }
239  if (NULL != s->intersection_set)
240  {
242  s->intersection_set = NULL;
243  }
244  if (NULL != s->sorted_elements)
245  {
247  s->sorted_elements = NULL;
248  }
249  if (NULL != s->port)
250  {
252  s->port = NULL;
253  }
254  if (NULL != s->channel)
255  {
257  s->channel = NULL;
258  }
259  GNUNET_free (s);
260 }
261 
262 
270 static void
272 {
273  struct ClientResponseMessage *msg;
274  struct GNUNET_MQ_Envelope *e;
275 
276  if (NULL == session->client_mq)
277  return; /* no client left to be notified */
279  "Sending session-end notification with status %d to client for session %s\n",
280  session->status,
281  GNUNET_h2s (&session->session_id));
282  e = GNUNET_MQ_msg (msg,
284  msg->range = 0;
285  msg->product_length = htonl (0);
286  msg->status = htonl (session->status);
287  GNUNET_MQ_send (session->client_mq,
288  e);
289 }
290 
291 
303 static void
305  const struct GNUNET_CADET_Channel *channel)
306 {
307  struct BobServiceSession *s = cls;
308 
310  "Peer disconnected, terminating session %s with peer %s\n",
311  GNUNET_h2s (&s->session_id),
312  GNUNET_i2s (&s->peer));
313  s->channel = NULL;
314  if (GNUNET_SCALARPRODUCT_STATUS_ACTIVE == s->status)
315  {
318  }
320 }
321 
322 
327 static void
328 bob_cadet_done_cb (void *cls)
329 {
330  struct BobServiceSession *session = cls;
331 
334 }
335 
336 
342 static void
344 {
346  struct GNUNET_MQ_Envelope *e;
347 
349  "Sending response to Alice\n");
350  e = GNUNET_MQ_msg (msg,
352  msg->contained_element_count = htonl (2);
353  msg->prod_g_i_b_i = s->prod_g_i_b_i;
354  msg->prod_h_i_b_i = s->prod_h_i_b_i;
357  s);
359  e);
360 }
361 
362 
371 static int
372 copy_element_cb (void *cls,
373  const struct GNUNET_HashCode *key,
374  void *value)
375 {
376  struct BobServiceSession *s = cls;
378 
380  e->value);
381  s->sorted_elements[s->used_element_count].key = &e->key;
382  s->used_element_count++;
383  return GNUNET_OK;
384 }
385 
386 
395 static int
396 element_cmp (const void *a,
397  const void *b)
398 {
399  const struct MpiElement *ma = a;
400  const struct MpiElement *mb = b;
401 
402  return GNUNET_CRYPTO_hash_cmp (ma->key,
403  mb->key);
404 }
405 
406 
416 static int
418  const struct EccAliceCryptodataMessage *msg)
419 {
420  struct BobServiceSession *s = cls;
421  uint32_t contained_elements;
422  size_t msg_length;
423  uint16_t msize;
424  unsigned int max;
425 
426  msize = ntohs (msg->header.size);
427  if (msize <= sizeof(struct EccAliceCryptodataMessage))
428  {
429  GNUNET_break_op (0);
430  return GNUNET_SYSERR;
431  }
432  contained_elements = ntohl (msg->contained_element_count);
433  /* Our intersection may still be ongoing, but this is nevertheless
434  an upper bound on the required array size */
435  max = GNUNET_CONTAINER_multihashmap_size (s->intersected_elements);
436  msg_length = sizeof(struct EccAliceCryptodataMessage)
437  + contained_elements * sizeof(struct GNUNET_CRYPTO_EccPoint) * 2;
438  if ((msize != msg_length) ||
439  (0 == contained_elements) ||
440  (contained_elements > UINT16_MAX) ||
441  (max < contained_elements + s->cadet_received_element_count))
442  {
443  GNUNET_break_op (0);
444  return GNUNET_SYSERR;
445  }
446  return GNUNET_OK;
447 }
448 
449 
457 static void
459  const struct EccAliceCryptodataMessage *msg)
460 {
461  struct BobServiceSession *s = cls;
462  const struct GNUNET_CRYPTO_EccPoint *payload;
463  uint32_t contained_elements;
464  unsigned int max;
465  const struct GNUNET_CRYPTO_EccPoint *g_i;
466  const struct GNUNET_CRYPTO_EccPoint *h_i;
467  struct GNUNET_CRYPTO_EccPoint g_i_b_i;
468  struct GNUNET_CRYPTO_EccPoint h_i_b_i;
469 
470  contained_elements = ntohl (msg->contained_element_count);
472  /* sort our vector for the computation */
473  if (NULL == s->sorted_elements)
474  {
475  s->sorted_elements
478  struct MpiElement);
479  s->used_element_count = 0;
482  s);
483  qsort (s->sorted_elements,
485  sizeof(struct MpiElement),
486  &element_cmp);
487  }
488 
490  "Received %u crypto values from Alice\n",
491  (unsigned int) contained_elements);
492  payload = (const struct GNUNET_CRYPTO_EccPoint *) &msg[1];
493 
494  for (unsigned int i = 0; i < contained_elements; i++)
495  {
496  int64_t val = s->sorted_elements[i + s->cadet_received_element_count].value;
497  struct GNUNET_CRYPTO_EccScalar vali;
498 
499  GNUNET_assert (INT64_MIN != val);
500  GNUNET_CRYPTO_ecc_scalar_from_int (val > 0 ? val : -val,
501  &vali);
502  if (val < 0)
503  crypto_core_ed25519_scalar_negate (vali.v,
504  vali.v);
505  g_i = &payload[i * 2];
506  /* g_i_b_i = g_i^vali */
509  &vali,
510  &g_i_b_i));
511  h_i = &payload[i * 2 + 1];
512  /* h_i_b_i = h_i^vali */
515  &vali,
516  &h_i_b_i));
517  if (0 == i + s->cadet_received_element_count)
518  {
519  /* first iteration, nothing to add */
520  s->prod_g_i_b_i = g_i_b_i;
521  s->prod_h_i_b_i = h_i_b_i;
522  }
523  else
524  {
525  /* further iterations, cummulate resulting value */
528  &g_i_b_i,
529  &s->prod_g_i_b_i));
532  &h_i_b_i,
533  &s->prod_h_i_b_i));
534  }
535  }
536  s->cadet_received_element_count += contained_elements;
537  if ((s->cadet_received_element_count == max) &&
538  (NULL == s->intersection_op))
539  {
540  /* intersection has finished also on our side, and
541  we got the full set, so we can proceed with the
542  CADET response(s) */
544  }
546 }
547 
548 
558 static void
560  const struct GNUNET_SETI_Element *element,
561  uint64_t current_size,
563 {
564  struct BobServiceSession *s = cls;
565  struct GNUNET_SCALARPRODUCT_Element *se;
566 
567  switch (status)
568  {
570  /* this element has been removed from the set */
572  element->data);
573  GNUNET_assert (NULL != se);
575  "Removed element with key %s and value %lld\n",
576  GNUNET_h2s (&se->key),
577  (long long) GNUNET_ntohll (se->value));
581  element->data,
582  se));
583  GNUNET_free (se);
584  return;
586  s->intersection_op = NULL;
587  GNUNET_break (NULL == s->intersection_set);
590  "Finished intersection, %d items remain\n",
594  {
595  /* CADET transmission from Alice is also already done,
596  start with our own reply */
598  }
599  return;
601  /* unhandled status code */
603  "Set intersection failed!\n");
604  s->intersection_op = NULL;
605  if (NULL != s->intersection_set)
606  {
608  s->intersection_set = NULL;
609  }
612  return;
613 
614  default:
615  GNUNET_break (0);
616  return;
617  }
618 }
619 
620 
627 static void
629 {
630  struct GNUNET_HashCode set_sid;
631 
633  sizeof(struct GNUNET_HashCode),
634  &set_sid);
636  "Got session with key %s and %u elements, starting intersection.\n",
637  GNUNET_h2s (&s->session_id),
638  (unsigned int) s->total);
639 
640  s->intersection_op
641  = GNUNET_SETI_prepare (&s->peer,
642  &set_sid,
643  NULL,
644  (struct GNUNET_SETI_Option[]) { { 0 } },
646  s);
647  if (GNUNET_OK !=
648  GNUNET_SETI_commit (s->intersection_op,
649  s->intersection_set))
650  {
651  GNUNET_break (0);
654  return;
655  }
656  GNUNET_SETI_destroy (s->intersection_set);
657  s->intersection_set = NULL;
658 }
659 
660 
667 static void
669  const struct EccServiceRequestMessage *msg)
670 {
671  struct BobServiceSession *s = cls;
672 
673  s->session_id = msg->session_id; // ??
674  if (s->client_received_element_count < s->total)
675  {
677  "Alice ready, still waiting for Bob client data!\n");
678  return;
679  }
681  "Both ready, launching intersection!\n");
683 }
684 
685 
696 static void *
699  const struct GNUNET_PeerIdentity *initiator)
700 {
701  struct BobServiceSession *s = cls;
702 
704  "New incoming channel from peer %s.\n",
705  GNUNET_i2s (initiator));
706  GNUNET_CADET_close_port (s->port);
707  s->port = NULL;
708  s->peer = *initiator;
709  s->channel = channel;
710  s->cadet_mq = GNUNET_CADET_get_mq (s->channel);
711  return s;
712 }
713 
714 
722 static int
724  void *cls,
726 {
727  struct BobServiceSession *s = cls;
728  uint32_t contained_count;
729  uint16_t msize;
730 
731  msize = ntohs (msg->header.size);
732  contained_count = ntohl (msg->element_count_contained);
733  if ((msize != (sizeof(struct ComputationBobCryptodataMultipartMessage)
734  + contained_count * sizeof(struct
736  (0 == contained_count) ||
737  (UINT16_MAX < contained_count) ||
738  (s->total == s->client_received_element_count) ||
739  (s->total < s->client_received_element_count + contained_count))
740  {
741  GNUNET_break (0);
742  return GNUNET_SYSERR;
743  }
744  return GNUNET_OK;
745 }
746 
747 
755 static void
757  void *cls,
759 {
760  struct BobServiceSession *s = cls;
761  uint32_t contained_count;
762  const struct GNUNET_SCALARPRODUCT_Element *elements;
763  struct GNUNET_SETI_Element set_elem;
764  struct GNUNET_SCALARPRODUCT_Element *elem;
765 
766  contained_count = ntohl (msg->element_count_contained);
767  elements = (const struct GNUNET_SCALARPRODUCT_Element *) &msg[1];
768  for (uint32_t i = 0; i < contained_count; i++)
769  {
771  GNUNET_memcpy (elem,
772  &elements[i],
773  sizeof(struct GNUNET_SCALARPRODUCT_Element));
774  if (GNUNET_SYSERR ==
776  &elem->key,
777  elem,
779  {
780  GNUNET_break (0);
781  GNUNET_free (elem);
782  continue;
783  }
784  set_elem.data = &elem->key;
785  set_elem.size = sizeof(elem->key);
786  set_elem.element_type = 0;
788  &set_elem,
789  NULL, NULL);
790  }
791  s->client_received_element_count += contained_count;
794  {
795  /* more to come */
797  "Request still partial, waiting for more client data!\n");
798  return;
799  }
800  if (NULL == s->channel)
801  {
802  /* no Alice waiting for this request, wait for Alice */
804  "Client ready, still waiting for Alice!\n");
805  return;
806  }
808  "Both ready, launching intersection!\n");
809  start_intersection (s);
810 }
811 
812 
821 static int
823  const struct BobComputationMessage *msg)
824 {
825  struct BobServiceSession *s = cls;
826  uint32_t contained_count;
827  uint32_t total_count;
828  uint16_t msize;
829 
830  if (GNUNET_SCALARPRODUCT_STATUS_INIT != s->status)
831  {
832  GNUNET_break (0);
833  return GNUNET_SYSERR;
834  }
835  msize = ntohs (msg->header.size);
836  total_count = ntohl (msg->element_count_total);
837  contained_count = ntohl (msg->element_count_contained);
838  if ((0 == total_count) ||
839  (0 == contained_count) ||
840  (UINT16_MAX < contained_count) ||
841  (msize != (sizeof(struct BobComputationMessage)
842  + contained_count * sizeof(struct
844  {
845  GNUNET_break_op (0);
846  return GNUNET_SYSERR;
847  }
848  return GNUNET_OK;
849 }
850 
851 
860 static void
862  const struct BobComputationMessage *msg)
863 {
864  struct BobServiceSession *s = cls;
865  struct GNUNET_MQ_MessageHandler cadet_handlers[] = {
866  GNUNET_MQ_hd_fixed_size (alices_computation_request,
869  s),
870  GNUNET_MQ_hd_var_size (alices_cryptodata_message,
873  s),
875  };
876  uint32_t contained_count;
877  uint32_t total_count;
878  const struct GNUNET_SCALARPRODUCT_Element *elements;
879  struct GNUNET_SETI_Element set_elem;
880  struct GNUNET_SCALARPRODUCT_Element *elem;
881 
882  total_count = ntohl (msg->element_count_total);
883  contained_count = ntohl (msg->element_count_contained);
884 
886  s->total = total_count;
887  s->client_received_element_count = contained_count;
888  s->session_id = msg->session_key;
889  elements = (const struct GNUNET_SCALARPRODUCT_Element *) &msg[1];
892  GNUNET_YES);
894  for (uint32_t i = 0; i < contained_count; i++)
895  {
896  if (0 == GNUNET_ntohll (elements[i].value))
897  continue;
899  GNUNET_memcpy (elem,
900  &elements[i],
901  sizeof(struct GNUNET_SCALARPRODUCT_Element));
902  if (GNUNET_SYSERR ==
904  &elem->key,
905  elem,
907  {
908  GNUNET_break (0);
909  GNUNET_free (elem);
910  continue;
911  }
912  set_elem.data = &elem->key;
913  set_elem.size = sizeof(elem->key);
914  set_elem.element_type = 0;
916  &set_elem,
917  NULL, NULL);
918  s->used_element_count++;
919  }
922  "Received client request, opening port %s!\n",
923  GNUNET_h2s (&msg->session_key));
925  &msg->session_key,
927  s,
928  NULL,
930  cadet_handlers);
931  if (NULL == s->port)
932  {
933  GNUNET_break (0);
935  return;
936  }
937 }
938 
939 
945 static void
946 shutdown_task (void *cls)
947 {
949  "Shutting down, initiating cleanup.\n");
950  // FIXME: we have to cut our connections to CADET first!
951  if (NULL != my_cadet)
952  {
954  my_cadet = NULL;
955  }
956  if (NULL != edc)
957  {
959  edc = NULL;
960  }
961 }
962 
963 
974 static void *
975 client_connect_cb (void *cls,
976  struct GNUNET_SERVICE_Client *client,
977  struct GNUNET_MQ_Handle *mq)
978 {
979  struct BobServiceSession *s;
980 
981  s = GNUNET_new (struct BobServiceSession);
982  s->client = client;
983  s->client_mq = mq;
984  return s;
985 }
986 
987 
998 static void
1000  struct GNUNET_SERVICE_Client *client,
1001  void *app_cls)
1002 {
1003  struct BobServiceSession *s = app_cls;
1004 
1006  "Client disconnected from us.\n");
1007  s->client = NULL;
1009 }
1010 
1011 
1019 static void
1020 run (void *cls,
1021  const struct GNUNET_CONFIGURATION_Handle *c,
1023 {
1024  cfg = c;
1025  /* We don't really do DLOG, so we can setup with very minimal resources */
1026  edc = GNUNET_CRYPTO_ecc_dlog_prepare (4 /* max value */,
1027  2 /* RAM */);
1030  NULL);
1031  if (NULL == my_cadet)
1032  {
1034  _ ("Connect to CADET failed\n"));
1036  return;
1037  }
1038 }
1039 
1040 
1045  ("scalarproduct-bob",
1047  &run,
1050  NULL,
1051  GNUNET_MQ_hd_var_size (bob_client_message,
1053  struct BobComputationMessage,
1054  NULL),
1055  GNUNET_MQ_hd_var_size (bob_client_message_multipart,
1058  NULL),
1060 
1061 
1062 /* end of gnunet-service-scalarproduct-ecc_bob.c */
struct GNUNET_MQ_Handle * mq
Definition: 003.c:5
struct GNUNET_MessageHeader * msg
Definition: 005.c:2
static struct Experiment * e
struct GNUNET_HashCode key
The key used in the DHT.
uint16_t status
See PRISM_STATUS_*-constants.
static char * value
Value of the record to add/remove.
static struct GNUNET_SERVICE_Handle * service
Handle to our service instance.
static unsigned long long payload
How much data are we currently storing in the database?
scalarproduct service P2P messages
static void handle_bob_client_message_multipart(void *cls, const struct ComputationBobCryptodataMultipartMessage *msg)
We're receiving additional set data.
GNUNET_SERVICE_MAIN("scalarproduct-bob", GNUNET_SERVICE_OPTION_NONE, &run, &client_connect_cb, &client_disconnect_cb, NULL, GNUNET_MQ_hd_var_size(bob_client_message, GNUNET_MESSAGE_TYPE_SCALARPRODUCT_CLIENT_TO_BOB, struct BobComputationMessage, NULL), GNUNET_MQ_hd_var_size(bob_client_message_multipart, GNUNET_MESSAGE_TYPE_SCALARPRODUCT_CLIENT_MULTIPART_BOB, struct ComputationBobCryptodataMultipartMessage, NULL), GNUNET_MQ_handler_end())
Define "main" method using service macro.
static struct GNUNET_CRYPTO_EccDlogContext * edc
Context for DLOG operations on a curve.
static int check_alices_cryptodata_message(void *cls, const struct EccAliceCryptodataMessage *msg)
Check a multipart-chunk of a request from another service to calculate a scalarproduct with us.
static void start_intersection(struct BobServiceSession *s)
We've paired up a client session with an incoming CADET request.
static struct GNUNET_CADET_Handle * my_cadet
Handle to the CADET service.
static const struct GNUNET_CONFIGURATION_Handle * cfg
GNUnet configuration handle.
static int check_bob_client_message_multipart(void *cls, const struct ComputationBobCryptodataMultipartMessage *msg)
We're receiving additional set data.
static void prepare_client_end_notification(struct BobServiceSession *session)
Notify the client that the session has succeeded or failed.
static void transmit_bobs_cryptodata_message(struct BobServiceSession *s)
Bob generates the response message to be sent to Alice.
static void client_disconnect_cb(void *cls, struct GNUNET_SERVICE_Client *client, void *app_cls)
A client disconnected.
static void * cb_channel_incoming(void *cls, struct GNUNET_CADET_Channel *channel, const struct GNUNET_PeerIdentity *initiator)
Function called for inbound channels on Bob's end.
static void shutdown_task(void *cls)
Task run during shutdown.
static void bob_cadet_done_cb(void *cls)
MQ finished giving our last message to CADET, now notify the client that we are finished.
static void handle_alices_computation_request(void *cls, const struct EccServiceRequestMessage *msg)
Handle a request from Alice to calculate a scalarproduct with us (Bob).
static void destroy_service_session(struct BobServiceSession *s)
Destroy session state, we are done with it.
static void handle_bob_client_message(void *cls, const struct BobComputationMessage *msg)
Handler for Bob's a client request message.
static void run(void *cls, const struct GNUNET_CONFIGURATION_Handle *c, struct GNUNET_SERVICE_Handle *service)
Initialization of the program and message handlers.
static void handle_alices_cryptodata_message(void *cls, const struct EccAliceCryptodataMessage *msg)
Handle a multipart-chunk of a request from another service to calculate a scalarproduct with us.
static int check_bob_client_message(void *cls, const struct BobComputationMessage *msg)
Handler for Bob's a client request message.
static void cb_channel_destruction(void *cls, const struct GNUNET_CADET_Channel *channel)
Function called whenever a channel is destroyed.
static int element_cmp(const void *a, const void *b)
Compare two struct MpiValues by key for sorting.
static void * client_connect_cb(void *cls, struct GNUNET_SERVICE_Client *client, struct GNUNET_MQ_Handle *mq)
A client connected.
#define LOG(kind,...)
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.
static void cb_intersection_element_removed(void *cls, const struct GNUNET_SETI_Element *element, uint64_t current_size, enum GNUNET_SETI_Status status)
Callback for set operation results.
static int free_element_cb(void *cls, const struct GNUNET_HashCode *key, void *value)
Callback used to free the elements in the map.
#define GNUNET_log(kind,...)
uint64_t GNUNET_ntohll(uint64_t n)
Convert unsigned 64-bit integer to host byte order.
Definition: common_endian.c:53
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
@ GNUNET_OK
Definition: gnunet_common.h:95
@ GNUNET_YES
Definition: gnunet_common.h:97
@ GNUNET_SYSERR
Definition: gnunet_common.h:93
enum GNUNET_GenericReturnValue GNUNET_CRYPTO_ecc_pmul_mpi(const struct GNUNET_CRYPTO_EccPoint *p, const struct GNUNET_CRYPTO_EccScalar *val, struct GNUNET_CRYPTO_EccPoint *r)
Multiply the point p on the elliptic curve by val.
void GNUNET_CRYPTO_ecc_scalar_from_int(int64_t val, struct GNUNET_CRYPTO_EccScalar *r)
Create a scalar from int value.
struct GNUNET_CRYPTO_EccDlogContext * GNUNET_CRYPTO_ecc_dlog_prepare(unsigned int max, unsigned int mem)
Do pre-calculation for ECC discrete logarithm for small factors.
void GNUNET_CRYPTO_ecc_dlog_release(struct GNUNET_CRYPTO_EccDlogContext *dlc)
Release precalculated values.
enum GNUNET_GenericReturnValue GNUNET_CRYPTO_ecc_add(const struct GNUNET_CRYPTO_EccPoint *a, const struct GNUNET_CRYPTO_EccPoint *b, struct GNUNET_CRYPTO_EccPoint *r)
Add two points on the elliptic curve.
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:888
void GNUNET_CADET_channel_destroy(struct GNUNET_CADET_Channel *channel)
Destroy an existing channel.
Definition: cadet_api.c:837
void GNUNET_CADET_disconnect(struct GNUNET_CADET_Handle *handle)
Disconnect from the cadet service.
Definition: cadet_api.c:775
void GNUNET_CADET_close_port(struct GNUNET_CADET_Port *p)
Close a port opened with GNUNET_CADET_open_port().
Definition: cadet_api.c:808
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:1082
struct GNUNET_CADET_Handle * GNUNET_CADET_connect(const struct GNUNET_CONFIGURATION_Handle *cfg)
Connect to the MQ-based cadet service.
Definition: cadet_api.c:910
struct GNUNET_CADET_Port * GNUNET_CADET_open_port(struct GNUNET_CADET_Handle *h, const struct GNUNET_HashCode *port, GNUNET_CADET_ConnectEventHandler connects, void *connects_cls, GNUNET_CADET_WindowSizeEventHandler window_changes, GNUNET_CADET_DisconnectEventHandler disconnects, const struct GNUNET_MQ_MessageHandler *handlers)
Open a port to receive incoming MQ-based channels.
Definition: cadet_api.c:970
void GNUNET_CRYPTO_hash(const void *block, size_t size, struct GNUNET_HashCode *ret)
Compute hash of a given block.
Definition: crypto_hash.c:41
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:201
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.
struct GNUNET_CONTAINER_MultiHashMap * GNUNET_CONTAINER_multihashmap_create(unsigned int len, int do_not_copy_keys)
Create a multi hash map.
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.
unsigned int GNUNET_CONTAINER_multihashmap_size(const struct GNUNET_CONTAINER_MultiHashMap *map)
Get the number of key-value pairs in the map.
int GNUNET_CONTAINER_multihashmap_iterate(struct GNUNET_CONTAINER_MultiHashMap *map, GNUNET_CONTAINER_MulitHashMapIteratorCallback it, void *it_cls)
Iterate over all entries in the map.
void GNUNET_CONTAINER_multihashmap_destroy(struct GNUNET_CONTAINER_MultiHashMap *map)
Destroy a hash map.
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.
@ GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY
There must only be one value per key; storing a value should fail if a value under the same key alrea...
#define GNUNET_break_op(cond)
Use this for assertion violations caused by other peers (i.e.
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
#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.
const char * GNUNET_h2s(const struct GNUNET_HashCode *hc)
Convert a hash value to a string (for printing debug messages).
@ GNUNET_ERROR_TYPE_ERROR
@ GNUNET_ERROR_TYPE_DEBUG
#define GNUNET_new(type)
Allocate a struct or union of the given type.
#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.
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:355
#define GNUNET_MQ_handler_end()
End-marker for the handlers array.
#define GNUNET_MQ_msg(mvar, type)
Allocate a GNUNET_MQ_Envelope.
Definition: gnunet_mq_lib.h:67
#define GNUNET_MQ_hd_var_size(name, code, str, ctx)
void GNUNET_MQ_notify_sent(struct GNUNET_MQ_Envelope *ev, GNUNET_SCHEDULER_TaskCallback cb, void *cb_cls)
Call a callback once the envelope has been sent, that is, sending it can not be canceled anymore.
Definition: mq.c:787
#define GNUNET_MQ_hd_fixed_size(name, code, str, ctx)
#define GNUNET_MESSAGE_TYPE_SCALARPRODUCT_RESULT
Alice/Bob -> Client Result.
#define GNUNET_MESSAGE_TYPE_SCALARPRODUCT_ECC_SESSION_INITIALIZATION
Alice -> Bob ECC session initialization.
#define GNUNET_MESSAGE_TYPE_SCALARPRODUCT_CLIENT_TO_BOB
Client -> Bob.
#define GNUNET_MESSAGE_TYPE_SCALARPRODUCT_ECC_BOB_CRYPTODATA
Bob -> Alice ECC crypto data.
#define GNUNET_MESSAGE_TYPE_SCALARPRODUCT_CLIENT_MULTIPART_BOB
Client -> Bob multipart.
#define GNUNET_MESSAGE_TYPE_SCALARPRODUCT_ECC_ALICE_CRYPTODATA
Alice -> Bob ECC crypto data.
GNUNET_SCALARPRODUCT_ResponseStatus
Result status values for the computation.
@ GNUNET_SCALARPRODUCT_STATUS_INIT
Operation is still active (never returned, used internally).
@ GNUNET_SCALARPRODUCT_STATUS_SUCCESS
The computation was successful.
@ GNUNET_SCALARPRODUCT_STATUS_ACTIVE
Operation is still active (never returned, used internally).
@ GNUNET_SCALARPRODUCT_STATUS_FAILURE
We encountered some error.
void GNUNET_SCHEDULER_shutdown(void)
Request the shutdown of a scheduler.
Definition: scheduler.c:531
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,...
Definition: scheduler.c:1331
void GNUNET_SERVICE_client_drop(struct GNUNET_SERVICE_Client *c)
Ask the server to disconnect from the given client.
Definition: service.c:2325
void GNUNET_SERVICE_client_continue(struct GNUNET_SERVICE_Client *c)
Continue receiving further messages from the given client.
Definition: service.c:2244
@ GNUNET_SERVICE_OPTION_NONE
Use defaults.
GNUNET_SETI_Status
Status for the result callback.
void GNUNET_SETI_destroy(struct GNUNET_SETI_Handle *set)
Destroy the set handle, and free all associated resources.
Definition: seti_api.c:488
struct GNUNET_SETI_Handle * GNUNET_SETI_create(const struct GNUNET_CONFIGURATION_Handle *cfg)
Create an empty set, supporting the specified operation.
Definition: seti_api.c:399
int GNUNET_SETI_add_element(struct GNUNET_SETI_Handle *set, const struct GNUNET_SETI_Element *element, GNUNET_SCHEDULER_TaskCallback cb, void *cb_cls)
Add an element to the given set.
Definition: seti_api.c:447
int GNUNET_SETI_commit(struct GNUNET_SETI_OperationHandle *oh, struct GNUNET_SETI_Handle *set)
Commit a set to be used with a set operation.
Definition: seti_api.c:836
void GNUNET_SETI_operation_cancel(struct GNUNET_SETI_OperationHandle *oh)
Cancel the given set operation.
Definition: seti_api.c:335
struct GNUNET_SETI_OperationHandle * GNUNET_SETI_prepare(const struct GNUNET_PeerIdentity *other_peer, const struct GNUNET_HashCode *app_id, const struct GNUNET_MessageHeader *context_msg, const struct GNUNET_SETI_Option options[], GNUNET_SETI_ResultIterator result_cb, void *result_cls)
Prepare a set operation to be evaluated with another peer.
Definition: seti_api.c:526
@ GNUNET_SETI_STATUS_DONE
Success, all elements have been sent (and received).
@ GNUNET_SETI_STATUS_FAILURE
The other peer refused to do the operation with us, or something went wrong.
@ GNUNET_SETI_STATUS_DEL_LOCAL
Element should be delete from the result set of the local peer, i.e.
#define max(x, y)
#define _(String)
GNU gettext support macro.
Definition: platform.h:177
Scalar Product API Message Types.
Message type passed from client to service to initiate a request or responder role.
Definition: scalarproduct.h:89
A scalarproduct session which tracks an offer for a multiplication service by a local client.
struct GNUNET_HashCode session_id
(hopefully) unique transaction ID
struct MpiElement * sorted_elements
b(Bob)
struct GNUNET_CADET_Port * port
Our open port.
struct GNUNET_CADET_Channel * channel
The CADET channel.
uint32_t total
How many elements will be supplied in total from the client.
struct GNUNET_SETI_OperationHandle * intersection_op
Set of elements for which will conduction an intersection.
uint32_t cadet_received_element_count
Counts the number of values received from Alice by us.
struct GNUNET_CONTAINER_MultiHashMap * intersected_elements
All non-0-value'd elements transmitted to us.
struct GNUNET_MQ_Handle * cadet_mq
The message queue for this channel.
struct GNUNET_CRYPTO_EccPoint prod_h_i_b_i
Product of the h_i^{b_i}.
struct GNUNET_SERVICE_Client * client
The client this request is related to.
uint32_t used_element_count
How many elements actually are used for the scalar product.
struct GNUNET_CRYPTO_PaillierCiphertext s
Bob's "s".
struct GNUNET_SETI_Handle * intersection_set
Set of elements for which we will be conducting an intersection.
struct GNUNET_CRYPTO_EccPoint prod_g_i_b_i
Product of the g_i^{b_i}.
enum GNUNET_SCALARPRODUCT_ResponseStatus status
State of this session.
int in_destroy
Are we already in destroy_service_session()?
struct GNUNET_PeerIdentity peer
Originator's peer identity.
uint32_t client_received_element_count
Already transferred elements (received) for multipart messages from client.
struct GNUNET_MQ_Handle * client_mq
Client message queue.
Message type passed from service client to finalize a session as requester or responder.
multipart messages following struct ComputationMessage
Vector of ECC-encrypted values sent by Alice to Bob (after set intersection).
Message type passed from responding service Bob to responding service Alice to complete a request and...
Message type passed from requesting service Alice to responding service Bob to initiate a request and...
Opaque handle to a channel.
Definition: cadet.h:117
Opaque handle to the service.
Definition: cadet_api.c:39
Opaque handle to a port.
Definition: cadet_api.c:80
Internal representation of the hash map.
Internal structure used to cache pre-calculated values for DLOG calculation.
Point on a curve (always for Curve25519) encoded in a format suitable for network transmission (ECDH)...
A ECC scalar for use in point multiplications.
unsigned char v[256/8]
A 512-bit hashcode.
Handle to a message queue.
Definition: mq.c:86
Message handler for a specific message type.
uint16_t size
The length of the struct (in bytes, including the length field itself), in big-endian format.
The identity of the host (wraps the signing key of the peer).
An element key-value pair for scalarproduct.
struct GNUNET_HashCode key
Key used to identify matching pairs of values to multiply.
int64_t value
Value to multiply in scalar product, in NBO.
Handle to a client that is connected to a service.
Definition: service.c:251
Handle to a service.
Definition: service.c:117
Element stored in a set.
const void * data
Actual data of the element.
uint16_t element_type
Application-specific element type.
uint16_t size
Number of bytes in the buffer pointed to by data.
Opaque handle to a set.
Definition: seti_api.c:40
Handle to an operation.
Definition: seti_api.c:106
Option for set operations.
An encrypted element key-value pair.
const struct GNUNET_HashCode * key
Key used to identify matching pairs of values to multiply.
int64_t value
a_i value, not disclosed to Bob.