GNUnet  0.10.x
Data Structures | Macros | Functions | Variables
gnunet-service-scalarproduct-ecc_bob.c File Reference

scalarproduct service implementation More...

#include "platform.h"
#include <limits.h>
#include <gcrypt.h>
#include "gnunet_util_lib.h"
#include "gnunet_core_service.h"
#include "gnunet_cadet_service.h"
#include "gnunet_applications.h"
#include "gnunet_protocols.h"
#include "gnunet_scalarproduct_service.h"
#include "gnunet_set_service.h"
#include "scalarproduct.h"
#include "gnunet-service-scalarproduct-ecc.h"
Include dependency graph for gnunet-service-scalarproduct-ecc_bob.c:

Go to the source code of this file.

Data Structures

struct  MpiElement
 An encrypted element key-value pair. More...
 
struct  BobServiceSession
 A scalarproduct session which tracks an offer for a multiplication service by a local client. More...
 

Macros

#define LOG(kind, ...)   GNUNET_log_from (kind, "scalarproduct-bob", __VA_ARGS__)
 

Functions

static int free_element_cb (void *cls, const struct GNUNET_HashCode *key, void *value)
 Callback used to free the elements in the map. More...
 
static void destroy_service_session (struct BobServiceSession *s)
 Destroy session state, we are done with it. More...
 
static void prepare_client_end_notification (struct BobServiceSession *session)
 Notify the client that the session has succeeded or failed. More...
 
static void cb_channel_destruction (void *cls, const struct GNUNET_CADET_Channel *channel)
 Function called whenever a channel is destroyed. More...
 
static void bob_cadet_done_cb (void *cls)
 MQ finished giving our last message to CADET, now notify the client that we are finished. More...
 
static void transmit_bobs_cryptodata_message (struct BobServiceSession *s)
 Bob generates the response message to be sent to Alice. More...
 
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. More...
 
static int element_cmp (const void *a, const void *b)
 Compare two struct MpiValues by key for sorting. More...
 
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. More...
 
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. More...
 
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. More...
 
static void start_intersection (struct BobServiceSession *s)
 We've paired up a client session with an incoming CADET request. More...
 
static void handle_alices_computation_request (void *cls, const struct EccServiceRequestMessage *msg)
 Handle a request from Alice to calculate a scalarproduct with us (Bob). More...
 
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. More...
 
static int check_bob_client_message_multipart (void *cls, const struct ComputationBobCryptodataMultipartMessage *msg)
 We're receiving additional set data. More...
 
static void handle_bob_client_message_multipart (void *cls, const struct ComputationBobCryptodataMultipartMessage *msg)
 We're receiving additional set data. More...
 
static int check_bob_client_message (void *cls, const struct BobComputationMessage *msg)
 Handler for Bob's a client request message. More...
 
static void handle_bob_client_message (void *cls, const struct BobComputationMessage *msg)
 Handler for Bob's a client request message. More...
 
static void shutdown_task (void *cls)
 Task run during shutdown. More...
 
static void * client_connect_cb (void *cls, struct GNUNET_SERVICE_Client *client, struct GNUNET_MQ_Handle *mq)
 A client connected. More...
 
static void client_disconnect_cb (void *cls, struct GNUNET_SERVICE_Client *client, void *app_cls)
 A client disconnected. More...
 
static void run (void *cls, const struct GNUNET_CONFIGURATION_Handle *c, struct GNUNET_SERVICE_Handle *service)
 Initialization of the program and message handlers. More...
 
 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. More...
 

Variables

static const struct GNUNET_CONFIGURATION_Handlecfg
 GNUnet configuration handle. More...
 
static struct GNUNET_CADET_Handlemy_cadet
 Handle to the CADET service. More...
 
static struct GNUNET_CRYPTO_EccDlogContextedc
 Context for DLOG operations on a curve. More...
 

Detailed Description

scalarproduct service implementation

Author
Christian M. Fuchs
Christian Grothoff

Definition in file gnunet-service-scalarproduct-ecc_bob.c.

Macro Definition Documentation

◆ LOG

#define LOG (   kind,
  ... 
)    GNUNET_log_from (kind, "scalarproduct-bob", __VA_ARGS__)

Function Documentation

◆ free_element_cb()

static int free_element_cb ( void *  cls,
const struct GNUNET_HashCode key,
void *  value 
)
static

Callback used to free the elements in the map.

Parameters
clsNULL
keykey of the element
valuethe value to free

Definition at line 199 of file gnunet-service-scalarproduct-ecc_bob.c.

References GNUNET_free, GNUNET_OK, and MpiElement::value.

Referenced by destroy_service_session().

202 {
203  struct GNUNET_SCALARPRODUCT_Element *element = value;
204 
205  GNUNET_free (element);
206  return GNUNET_OK;
207 }
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:78
static char * value
Value of the record to add/remove.
An element key-value pair for scalarproduct.
#define GNUNET_free(ptr)
Wrapper around free.
Here is the caller graph for this function:

◆ destroy_service_session()

static void destroy_service_session ( struct BobServiceSession s)
static

Destroy session state, we are done with it.

Parameters
sessionthe session to free elements from

Definition at line 216 of file gnunet-service-scalarproduct-ecc_bob.c.

References BobServiceSession::channel, BobServiceSession::client, free_element_cb(), GNUNET_CADET_channel_destroy(), GNUNET_CADET_close_port(), GNUNET_CONTAINER_multihashmap_destroy(), GNUNET_CONTAINER_multihashmap_iterate(), GNUNET_free, GNUNET_SERVICE_client_drop(), GNUNET_SET_destroy(), GNUNET_SET_operation_cancel(), GNUNET_YES, BobServiceSession::in_destroy, BobServiceSession::intersected_elements, BobServiceSession::intersection_op, BobServiceSession::intersection_set, BobServiceSession::port, BobServiceSession::prod_g_i_b_i, BobServiceSession::prod_h_i_b_i, BobServiceSession::sorted_elements, BobServiceSession::used_element_count, and MpiElement::value.

Referenced by cb_channel_destruction(), and client_disconnect_cb().

217 {
218  unsigned int i;
219 
220  if (GNUNET_YES == s->in_destroy)
221  return;
222  s->in_destroy = GNUNET_YES;
223  if (NULL != s->client)
224  {
225  struct GNUNET_SERVICE_Client *c = s->client;
226 
227  s->client = NULL;
229  }
230  if (NULL != s->intersected_elements)
231  {
234  NULL);
236  s->intersected_elements = NULL;
237  }
238  if (NULL != s->intersection_op)
239  {
241  s->intersection_op = NULL;
242  }
243  if (NULL != s->intersection_set)
244  {
246  s->intersection_set = NULL;
247  }
248  if (NULL != s->sorted_elements)
249  {
250  for (i=0;i<s->used_element_count;i++)
251  gcry_mpi_release (s->sorted_elements[i].value);
253  s->sorted_elements = NULL;
254  }
255  if (NULL != s->prod_g_i_b_i)
256  {
257  gcry_mpi_point_release (s->prod_g_i_b_i);
258  s->prod_g_i_b_i = NULL;
259  }
260  if (NULL != s->prod_h_i_b_i)
261  {
262  gcry_mpi_point_release (s->prod_h_i_b_i);
263  s->prod_h_i_b_i = NULL;
264  }
265  if (NULL != s->port)
266  {
268  s->port = NULL;
269  }
270  if (NULL != s->channel)
271  {
273  s->channel = NULL;
274  }
275  GNUNET_free (s);
276 }
int in_destroy
Are we already in destroy_service_session()?
static int free_element_cb(void *cls, const struct GNUNET_HashCode *key, void *value)
Callback used to free the elements in the map.
gcry_mpi_point_t prod_g_i_b_i
Product of the g_i^{b_i}.
uint32_t used_element_count
How many elements actually are used for the scalar product.
struct GNUNET_CADET_Port * port
Our open port.
struct GNUNET_SET_OperationHandle * intersection_op
Set of elements for which will conduction an intersection.
struct MpiElement * sorted_elements
b(Bob)
gcry_mpi_t value
a_i value, not disclosed to Bob.
Handle to a client that is connected to a service.
Definition: service.c:249
void GNUNET_SET_destroy(struct GNUNET_SET_Handle *set)
Destroy the set handle, and free all associated resources.
Definition: set_api.c:771
void GNUNET_CONTAINER_multihashmap_destroy(struct GNUNET_CONTAINER_MultiHashMap *map)
Destroy a hash map.
struct GNUNET_CADET_Channel * channel
The CADET channel.
struct GNUNET_SERVICE_Client * client
The client this request is related to.
void GNUNET_SERVICE_client_drop(struct GNUNET_SERVICE_Client *c)
Ask the server to disconnect from the given client.
Definition: service.c:2618
struct GNUNET_SET_Handle * intersection_set
Set of elements for which we will be conducting an intersection.
struct GNUNET_CONTAINER_MultiHashMap * intersected_elements
All non-0-value&#39;d elements transmitted to us.
void GNUNET_SET_operation_cancel(struct GNUNET_SET_OperationHandle *oh)
Cancel the given set operation.
Definition: set_api.c:515
void GNUNET_CADET_close_port(struct GNUNET_CADET_Port *p)
Close a port opened with GNUNET_CADET_open_port().
Definition: cadet_api.c:882
#define GNUNET_YES
Definition: gnunet_common.h:80
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_CADET_channel_destroy(struct GNUNET_CADET_Channel *channel)
Destroy an existing channel.
Definition: cadet_api.c:911
gcry_mpi_point_t prod_h_i_b_i
Product of the h_i^{b_i}.
#define GNUNET_free(ptr)
Wrapper around free.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ prepare_client_end_notification()

static void prepare_client_end_notification ( struct BobServiceSession session)
static

Notify the client that the session has succeeded or failed.

This message gets sent to Bob's client if the operation completed or Alice disconnected.

Parameters
sessionthe associated client session to fail or succeed

Definition at line 287 of file gnunet-service-scalarproduct-ecc_bob.c.

References BobServiceSession::client_mq, e, GNUNET_ERROR_TYPE_DEBUG, GNUNET_h2s(), GNUNET_log, GNUNET_MESSAGE_TYPE_SCALARPRODUCT_RESULT, GNUNET_MQ_msg, GNUNET_MQ_send(), msg, ClientResponseMessage::product_length, ClientResponseMessage::range, BobServiceSession::session_id, BobServiceSession::status, and ClientResponseMessage::status.

Referenced by bob_cadet_done_cb(), cb_channel_destruction(), and cb_intersection_element_removed().

288 {
289  struct ClientResponseMessage *msg;
290  struct GNUNET_MQ_Envelope *e;
291 
292  if (NULL == session->client_mq)
293  return; /* no client left to be notified */
295  "Sending session-end notification with status %d to client for session %s\n",
296  session->status,
297  GNUNET_h2s (&session->session_id));
298  e = GNUNET_MQ_msg (msg,
300  msg->range = 0;
301  msg->product_length = htonl (0);
302  msg->status = htonl (session->status);
303  GNUNET_MQ_send (session->client_mq,
304  e);
305 }
Message type passed from service client to finalize a session as requester or responder.
struct GNUNET_MessageHeader * msg
Definition: 005.c:2
enum GNUNET_SCALARPRODUCT_ResponseStatus status
State of this session.
struct GNUNET_MQ_Handle * client_mq
Client message queue.
int32_t range
Workaround for libgcrypt: -1 if negative, 0 if zero, else 1.
#define GNUNET_MQ_msg(mvar, type)
Allocate a GNUNET_MQ_Envelope.
Definition: gnunet_mq_lib.h:67
static struct Experiment * e
const char * GNUNET_h2s(const struct GNUNET_HashCode *hc)
Convert a hash value to a string (for printing debug messages).
uint32_t status
Status information about the outcome of this session, An enum GNUNET_SCALARPRODUCT_ResponseStatus (in...
struct GNUNET_HashCode session_id
(hopefully) unique transaction ID
uint32_t product_length
0 if no product attached
#define GNUNET_log(kind,...)
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
#define GNUNET_MESSAGE_TYPE_SCALARPRODUCT_RESULT
Alice/Bob -> Client Result.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ cb_channel_destruction()

static void cb_channel_destruction ( void *  cls,
const struct GNUNET_CADET_Channel channel 
)
static

Function called whenever a channel is destroyed.

Should clean up any associated state.

It must NOT call GNUNET_CADET_channel_destroy() on the channel.

Parameters
clsthe struct BobServiceSession
channelconnection to the other end (henceforth invalid)
channel_ctxplace where local state associated with the channel is stored

Definition at line 320 of file gnunet-service-scalarproduct-ecc_bob.c.

References BobServiceSession::channel, destroy_service_session(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_h2s(), GNUNET_i2s(), GNUNET_log, GNUNET_SCALARPRODUCT_STATUS_ACTIVE, GNUNET_SCALARPRODUCT_STATUS_FAILURE, BobServiceSession::peer, prepare_client_end_notification(), BobServiceSession::s, BobServiceSession::session_id, and BobServiceSession::status.

Referenced by handle_bob_client_message().

322 {
323  struct BobServiceSession *s = cls;
324 
326  "Peer disconnected, terminating session %s with peer %s\n",
327  GNUNET_h2s (&s->session_id),
328  GNUNET_i2s (&s->peer));
329  s->channel = NULL;
331  {
334  }
336 }
Operation is still active (never returned, used internally).
enum GNUNET_SCALARPRODUCT_ResponseStatus status
State of this session.
const char * GNUNET_h2s(const struct GNUNET_HashCode *hc)
Convert a hash value to a string (for printing debug messages).
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 GNUNET_CADET_Channel * channel
The CADET channel.
struct GNUNET_CRYPTO_PaillierCiphertext s
Bob&#39;s "s".
static void prepare_client_end_notification(struct BobServiceSession *session)
Notify the client that the session has succeeded or failed.
static void destroy_service_session(struct BobServiceSession *s)
Destroy session state, we are done with it.
#define GNUNET_log(kind,...)
struct GNUNET_PeerIdentity peer
Originator&#39;s peer identity.
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
Here is the call graph for this function:
Here is the caller graph for this function:

◆ bob_cadet_done_cb()

static void bob_cadet_done_cb ( void *  cls)
static

MQ finished giving our last message to CADET, now notify the client that we are finished.

Definition at line 344 of file gnunet-service-scalarproduct-ecc_bob.c.

References GNUNET_SCALARPRODUCT_STATUS_SUCCESS, prepare_client_end_notification(), and BobServiceSession::status.

Referenced by transmit_bobs_cryptodata_message().

345 {
346  struct BobServiceSession *session = cls;
347 
350 }
enum GNUNET_SCALARPRODUCT_ResponseStatus status
State of this session.
A scalarproduct session which tracks an offer for a multiplication service by a local client...
static void prepare_client_end_notification(struct BobServiceSession *session)
Notify the client that the session has succeeded or failed.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ transmit_bobs_cryptodata_message()

static void transmit_bobs_cryptodata_message ( struct BobServiceSession s)
static

Bob generates the response message to be sent to Alice.

Parameters
sthe associated requesting session with Alice

Definition at line 359 of file gnunet-service-scalarproduct-ecc_bob.c.

References bob_cadet_done_cb(), BobServiceSession::cadet_mq, EccBobCryptodataMessage::contained_element_count, e, GNUNET_CRYPTO_ecc_point_to_bin(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_MESSAGE_TYPE_SCALARPRODUCT_ECC_BOB_CRYPTODATA, GNUNET_MQ_msg, GNUNET_MQ_notify_sent(), GNUNET_MQ_send(), msg, EccBobCryptodataMessage::prod_g_i_b_i, BobServiceSession::prod_g_i_b_i, EccBobCryptodataMessage::prod_h_i_b_i, and BobServiceSession::prod_h_i_b_i.

Referenced by cb_intersection_element_removed(), and handle_alices_cryptodata_message().

360 {
362  struct GNUNET_MQ_Envelope *e;
363 
365  "Sending response to Alice\n");
366  e = GNUNET_MQ_msg (msg,
368  msg->contained_element_count = htonl (2);
369  if (NULL != s->prod_g_i_b_i)
371  s->prod_g_i_b_i,
372  &msg->prod_g_i_b_i);
373  if (NULL != s->prod_h_i_b_i)
375  s->prod_h_i_b_i,
376  &msg->prod_h_i_b_i);
379  s);
381  e);
382 }
struct GNUNET_CRYPTO_EccPoint prod_g_i_b_i
The product of the g_i^{b_i} values.
struct GNUNET_MessageHeader * msg
Definition: 005.c:2
gcry_mpi_point_t prod_g_i_b_i
Product of the g_i^{b_i}.
static struct GNUNET_CRYPTO_EccDlogContext * edc
Context for DLOG operations on a curve.
#define GNUNET_MQ_msg(mvar, type)
Allocate a GNUNET_MQ_Envelope.
Definition: gnunet_mq_lib.h:67
static struct Experiment * e
void GNUNET_CRYPTO_ecc_point_to_bin(struct GNUNET_CRYPTO_EccDlogContext *edc, gcry_mpi_point_t point, struct GNUNET_CRYPTO_EccPoint *bin)
Convert point value to binary representation.
static void bob_cadet_done_cb(void *cls)
MQ finished giving our last message to CADET, now notify the client that we are finished.
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:774
struct GNUNET_CRYPTO_EccPoint prod_h_i_b_i
The product of the h_i^{b_i} values.
uint32_t contained_element_count
How many elements this individual message delivers (in NBO), always TWO.
Message type passed from responding service Bob to responding service Alice to complete a request and...
#define GNUNET_MESSAGE_TYPE_SCALARPRODUCT_ECC_BOB_CRYPTODATA
Bob -> Alice ECC crypto data.
#define GNUNET_log(kind,...)
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_MQ_Handle * cadet_mq
The message queue for this channel.
gcry_mpi_point_t prod_h_i_b_i
Product of the h_i^{b_i}.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ copy_element_cb()

static int copy_element_cb ( void *  cls,
const struct GNUNET_HashCode key,
void *  value 
)
static

Iterator to copy over messages from the hash map into an array for sorting.

Parameters
clsthe struct BobServiceSession *
keythe key (unused)
valuethe struct GNUNET_SCALARPRODUCT_Element * TODO: code duplication with Alice!

Definition at line 395 of file gnunet-service-scalarproduct-ecc_bob.c.

References e, GNUNET_ntohll(), GNUNET_OK, MpiElement::key, GNUNET_SCALARPRODUCT_Element::key, BobServiceSession::s, BobServiceSession::sorted_elements, BobServiceSession::used_element_count, MpiElement::value, and GNUNET_SCALARPRODUCT_Element::value.

Referenced by handle_alices_cryptodata_message().

398 {
399  struct BobServiceSession *s = cls;
401  gcry_mpi_t mval;
402  int64_t val;
403 
404  mval = gcry_mpi_new (0);
405  val = (int64_t) GNUNET_ntohll (e->value);
406  if (0 > val)
407  gcry_mpi_sub_ui (mval, mval, -val);
408  else
409  gcry_mpi_add_ui (mval, mval, val);
412  s->used_element_count++;
413  return GNUNET_OK;
414 }
uint32_t used_element_count
How many elements actually are used for the scalar product.
const struct GNUNET_HashCode * key
Key used to identify matching pairs of values to multiply.
struct GNUNET_HashCode key
Key used to identify matching pairs of values to multiply.
static struct Experiment * e
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:78
struct MpiElement * sorted_elements
b(Bob)
gcry_mpi_t value
a_i value, not disclosed to Bob.
A scalarproduct session which tracks an offer for a multiplication service by a local client...
static char * value
Value of the record to add/remove.
struct GNUNET_CRYPTO_PaillierCiphertext s
Bob&#39;s "s".
int64_t value
Value to multiply in scalar product, in NBO.
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
Here is the call graph for this function:
Here is the caller graph for this function:

◆ element_cmp()

static int element_cmp ( const void *  a,
const void *  b 
)
static

Compare two struct MpiValues by key for sorting.

Parameters
apointer to first struct MpiValue *
bpointer to first struct MpiValue *
Returns
-1 for a < b, 0 for a=b, 1 for a > b. TODO: code duplication with Alice!

Definition at line 426 of file gnunet-service-scalarproduct-ecc_bob.c.

References GNUNET_CRYPTO_hash_cmp(), and MpiElement::key.

Referenced by handle_alices_cryptodata_message().

428 {
429  const struct MpiElement *ma = a;
430  const struct MpiElement *mb = b;
431 
432  return GNUNET_CRYPTO_hash_cmp (ma->key,
433  mb->key);
434 }
const struct GNUNET_HashCode * key
Key used to identify matching pairs of values to multiply.
An encrypted element key-value pair.
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:278
Here is the call graph for this function:
Here is the caller graph for this function:

◆ check_alices_cryptodata_message()

static int check_alices_cryptodata_message ( void *  cls,
const struct EccAliceCryptodataMessage msg 
)
static

Check a multipart-chunk of a request from another service to calculate a scalarproduct with us.

Parameters
clsclosure (set from GNUNET_CADET_connect)
msgthe actual message
Returns
GNUNET_OK to keep the connection open, GNUNET_SYSERR to close it (signal serious error)

Definition at line 447 of file gnunet-service-scalarproduct-ecc_bob.c.

References EccAliceCryptodataMessage::contained_element_count, GNUNET_break_op, GNUNET_CONTAINER_multihashmap_size(), GNUNET_OK, GNUNET_SYSERR, EccAliceCryptodataMessage::header, BobServiceSession::intersected_elements, BobServiceSession::s, and GNUNET_MessageHeader::size.

449 {
450  struct BobServiceSession *s = cls;
451  uint32_t contained_elements;
452  size_t msg_length;
453  uint16_t msize;
454  unsigned int max;
455 
456  msize = ntohs (msg->header.size);
457  if (msize <= sizeof (struct EccAliceCryptodataMessage))
458  {
459  GNUNET_break_op (0);
460  return GNUNET_SYSERR;
461  }
462  contained_elements = ntohl (msg->contained_element_count);
463  /* Our intersection may still be ongoing, but this is nevertheless
464  an upper bound on the required array size */
466  msg_length = sizeof (struct EccAliceCryptodataMessage)
467  + contained_elements * sizeof (struct GNUNET_CRYPTO_EccPoint) * 2;
468  if ( (msize != msg_length) ||
469  (0 == contained_elements) ||
470  (contained_elements > UINT16_MAX) ||
471  (max < contained_elements + s->cadet_received_element_count) )
472  {
473  GNUNET_break_op (0);
474  return GNUNET_SYSERR;
475  }
476  return GNUNET_OK;
477 }
uint32_t contained_element_count
How many elements we appended to this message? In NBO.
Vector of ECC-encrypted values sent by Alice to Bob (after set intersection).
Point on a curve (always for Curve25519) encoded in a format suitable for network transmission (ECDH)...
unsigned int GNUNET_CONTAINER_multihashmap_size(const struct GNUNET_CONTAINER_MultiHashMap *map)
Get the number of key-value pairs in the map.
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:78
uint16_t size
The length of the struct (in bytes, including the length field itself), in big-endian format...
A scalarproduct session which tracks an offer for a multiplication service by a local client...
#define GNUNET_break_op(cond)
Use this for assertion violations caused by other peers (i.e.
struct GNUNET_CRYPTO_PaillierCiphertext s
Bob&#39;s "s".
struct GNUNET_MessageHeader header
Type is GNUNET_MESSAGE_TYPE_SCALARPRODUCT_ECC_ALICE_CRYPTODATA.
#define GNUNET_SYSERR
Definition: gnunet_common.h:79
struct GNUNET_CONTAINER_MultiHashMap * intersected_elements
All non-0-value&#39;d elements transmitted to us.
Here is the call graph for this function:

◆ handle_alices_cryptodata_message()

static void handle_alices_cryptodata_message ( void *  cls,
const struct EccAliceCryptodataMessage msg 
)
static

Handle a multipart-chunk of a request from another service to calculate a scalarproduct with us.

Parameters
clsclosure (set from GNUNET_CADET_connect)
msgthe actual message

Definition at line 488 of file gnunet-service-scalarproduct-ecc_bob.c.

References BobServiceSession::cadet_received_element_count, BobServiceSession::channel, EccAliceCryptodataMessage::contained_element_count, copy_element_cb(), element_cmp(), GNUNET_CADET_receive_done(), GNUNET_CONTAINER_multihashmap_iterate(), GNUNET_CONTAINER_multihashmap_size(), GNUNET_CRYPTO_ecc_add(), GNUNET_CRYPTO_ecc_bin_to_point(), GNUNET_CRYPTO_ecc_pmul_mpi(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_new_array, BobServiceSession::intersected_elements, BobServiceSession::intersection_op, payload, BobServiceSession::prod_g_i_b_i, BobServiceSession::prod_h_i_b_i, BobServiceSession::s, BobServiceSession::sorted_elements, transmit_bobs_cryptodata_message(), BobServiceSession::used_element_count, and MpiElement::value.

490 {
491  struct BobServiceSession *s = cls;
492  const struct GNUNET_CRYPTO_EccPoint *payload;
493  uint32_t contained_elements;
494  unsigned int max;
495  unsigned int i;
496  const struct MpiElement *b_i;
497  gcry_mpi_point_t tmp;
498  gcry_mpi_point_t g_i;
499  gcry_mpi_point_t h_i;
500  gcry_mpi_point_t g_i_b_i;
501  gcry_mpi_point_t h_i_b_i;
502 
503  contained_elements = ntohl (msg->contained_element_count);
505  /* sort our vector for the computation */
506  if (NULL == s->sorted_elements)
507  {
508  s->sorted_elements
510  struct MpiElement);
511  s->used_element_count = 0;
514  s);
515  qsort (s->sorted_elements,
517  sizeof (struct MpiElement),
518  &element_cmp);
519  }
520 
522  "Received %u crypto values from Alice\n",
523  (unsigned int) contained_elements);
524  payload = (const struct GNUNET_CRYPTO_EccPoint *) &msg[1];
525 
526  for (i=0;i<contained_elements;i++)
527  {
530  &payload[i * 2]);
531  g_i_b_i = GNUNET_CRYPTO_ecc_pmul_mpi (edc,
532  g_i,
533  b_i->value);
534  gcry_mpi_point_release (g_i);
536  &payload[i * 2 + 1]);
537  h_i_b_i = GNUNET_CRYPTO_ecc_pmul_mpi (edc,
538  h_i,
539  b_i->value);
540  gcry_mpi_point_release (h_i);
541  if (0 == i + s->cadet_received_element_count)
542  {
543  /* first iteration, nothing to add */
544  s->prod_g_i_b_i = g_i_b_i;
545  s->prod_h_i_b_i = h_i_b_i;
546  }
547  else
548  {
549  /* further iterations, cummulate resulting value */
550  tmp = GNUNET_CRYPTO_ecc_add (edc,
551  s->prod_g_i_b_i,
552  g_i_b_i);
553  gcry_mpi_point_release (s->prod_g_i_b_i);
554  gcry_mpi_point_release (g_i_b_i);
555  s->prod_g_i_b_i = tmp;
556  tmp = GNUNET_CRYPTO_ecc_add (edc,
557  s->prod_h_i_b_i,
558  h_i_b_i);
559  gcry_mpi_point_release (s->prod_h_i_b_i);
560  gcry_mpi_point_release (h_i_b_i);
561  s->prod_h_i_b_i = tmp;
562  }
563  }
564  s->cadet_received_element_count += contained_elements;
565  if ( (s->cadet_received_element_count == max) &&
566  (NULL == s->intersection_op) )
567  {
568  /* intersection has finished also on our side, and
569  we got the full set, so we can proceed with the
570  CADET response(s) */
572  }
574 }
uint32_t contained_element_count
How many elements we appended to this message? In NBO.
Point on a curve (always for Curve25519) encoded in a format suitable for network transmission (ECDH)...
gcry_mpi_point_t GNUNET_CRYPTO_ecc_bin_to_point(struct GNUNET_CRYPTO_EccDlogContext *edc, const struct GNUNET_CRYPTO_EccPoint *bin)
Convert binary representation of a point to computational representation.
gcry_mpi_point_t prod_g_i_b_i
Product of the g_i^{b_i}.
unsigned int GNUNET_CONTAINER_multihashmap_size(const struct GNUNET_CONTAINER_MultiHashMap *map)
Get the number of key-value pairs in the map.
uint32_t used_element_count
How many elements actually are used for the scalar product.
static struct GNUNET_CRYPTO_EccDlogContext * edc
Context for DLOG operations on a curve.
struct GNUNET_SET_OperationHandle * intersection_op
Set of elements for which will conduction an intersection.
struct MpiElement * sorted_elements
b(Bob)
gcry_mpi_t value
a_i value, not disclosed to Bob.
A scalarproduct session which tracks an offer for a multiplication service by a local client...
struct GNUNET_CADET_Channel * channel
The CADET channel.
gcry_mpi_point_t GNUNET_CRYPTO_ecc_add(struct GNUNET_CRYPTO_EccDlogContext *edc, gcry_mpi_point_t a, gcry_mpi_point_t b)
Add two points on the elliptic curve.
#define GNUNET_new_array(n, type)
Allocate a size n array with structs or unions of the given type.
struct GNUNET_CRYPTO_PaillierCiphertext s
Bob&#39;s "s".
An encrypted element key-value pair.
static unsigned long long payload
How much data are we currently storing in the database?
uint32_t cadet_received_element_count
Counts the number of values received from Alice by us.
static int element_cmp(const void *a, const void *b)
Compare two struct MpiValues by key for sorting.
struct GNUNET_CONTAINER_MultiHashMap * intersected_elements
All non-0-value&#39;d elements transmitted to us.
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:973
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.
#define GNUNET_log(kind,...)
static void transmit_bobs_cryptodata_message(struct BobServiceSession *s)
Bob generates the response message to be sent to Alice.
int GNUNET_CONTAINER_multihashmap_iterate(struct GNUNET_CONTAINER_MultiHashMap *map, GNUNET_CONTAINER_MulitHashMapIteratorCallback it, void *it_cls)
Iterate over all entries in the map.
gcry_mpi_point_t GNUNET_CRYPTO_ecc_pmul_mpi(struct GNUNET_CRYPTO_EccDlogContext *edc, gcry_mpi_point_t p, gcry_mpi_t val)
Multiply the point p on the elliptic curve by val.
gcry_mpi_point_t prod_h_i_b_i
Product of the h_i^{b_i}.
Here is the call graph for this function:

◆ cb_intersection_element_removed()

static void cb_intersection_element_removed ( void *  cls,
const struct GNUNET_SET_Element element,
uint64_t  current_size,
enum GNUNET_SET_Status  status 
)
static

Callback for set operation results.

Called for each element that needs to be removed from the result set.

Parameters
clsclosure with the struct BobServiceSession
elementa result element, only valid if status is GNUNET_SET_STATUS_OK
current_sizecurrent set size
statuswhat has happened with the set intersection?

Definition at line 587 of file gnunet-service-scalarproduct-ecc_bob.c.

References BobServiceSession::channel, BobServiceSession::client_received_element_count, GNUNET_SET_Element::data, GNUNET_assert, GNUNET_break, GNUNET_CADET_receive_done(), GNUNET_CONTAINER_multihashmap_get(), GNUNET_CONTAINER_multihashmap_remove(), GNUNET_CONTAINER_multihashmap_size(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_h2s(), GNUNET_ntohll(), GNUNET_SCALARPRODUCT_STATUS_FAILURE, GNUNET_SET_destroy(), GNUNET_SET_STATUS_DONE, GNUNET_SET_STATUS_FAILURE, GNUNET_SET_STATUS_HALF_DONE, GNUNET_SET_STATUS_OK, GNUNET_YES, BobServiceSession::intersected_elements, BobServiceSession::intersection_op, BobServiceSession::intersection_set, GNUNET_SCALARPRODUCT_Element::key, LOG, prepare_client_end_notification(), BobServiceSession::s, BobServiceSession::status, transmit_bobs_cryptodata_message(), and GNUNET_SCALARPRODUCT_Element::value.

591 {
592  struct BobServiceSession *s = cls;
593  struct GNUNET_SCALARPRODUCT_Element *se;
594 
595  switch (status)
596  {
598  /* this element has been removed from the set */
600  element->data);
601  GNUNET_assert (NULL != se);
603  "Removed element with key %s and value %lld\n",
604  GNUNET_h2s (&se->key),
605  (long long) GNUNET_ntohll (se->value));
608  element->data,
609  se));
610  GNUNET_free (se);
611  return;
613  s->intersection_op = NULL;
614  GNUNET_break (NULL == s->intersection_set);
617  "Finished intersection, %d items remain\n",
621  {
622  /* CADET transmission from Alice is also already done,
623  start with our own reply */
625  }
626  return;
628  /* unexpected for intersection */
629  GNUNET_break (0);
630  return;
632  /* unhandled status code */
634  "Set intersection failed!\n");
635  s->intersection_op = NULL;
636  if (NULL != s->intersection_set)
637  {
639  s->intersection_set = NULL;
640  }
643  return;
644  default:
645  GNUNET_break (0);
646  return;
647  }
648 }
uint32_t client_received_element_count
Already transferred elements (received) for multipart messages from client.
unsigned int GNUNET_CONTAINER_multihashmap_size(const struct GNUNET_CONTAINER_MultiHashMap *map)
Get the number of key-value pairs in the map.
struct GNUNET_HashCode key
Key used to identify matching pairs of values to multiply.
enum GNUNET_SCALARPRODUCT_ResponseStatus status
State of this session.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
struct GNUNET_SET_OperationHandle * intersection_op
Set of elements for which will conduction an intersection.
const char * GNUNET_h2s(const struct GNUNET_HashCode *hc)
Convert a hash value to a string (for printing debug messages).
A scalarproduct session which tracks an offer for a multiplication service by a local client...
Success, all elements have been sent (and received).
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
const void * data
Actual data of the element.
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.
void GNUNET_SET_destroy(struct GNUNET_SET_Handle *set)
Destroy the set handle, and free all associated resources.
Definition: set_api.c:771
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...
Everything went ok, we are transmitting an element of the result (in set, or to be removed from set...
struct GNUNET_CADET_Channel * channel
The CADET channel.
uint16_t status
See PRISM_STATUS_*-constants.
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_CRYPTO_PaillierCiphertext s
Bob&#39;s "s".
static void prepare_client_end_notification(struct BobServiceSession *session)
Notify the client that the session has succeeded or failed.
int64_t value
Value to multiply in scalar product, in NBO.
struct GNUNET_SET_Handle * intersection_set
Set of elements for which we will be conducting an intersection.
struct GNUNET_CONTAINER_MultiHashMap * intersected_elements
All non-0-value&#39;d elements transmitted to us.
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:973
static void transmit_bobs_cryptodata_message(struct BobServiceSession *s)
Bob generates the response message to be sent to Alice.
#define GNUNET_YES
Definition: gnunet_common.h:80
#define LOG(kind,...)
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_free(ptr)
Wrapper around free.
Here is the call graph for this function:

◆ start_intersection()

static void start_intersection ( struct BobServiceSession s)
static

We've paired up a client session with an incoming CADET request.

Initiate set intersection work.

Parameters
sclient session to start intersection for

Definition at line 658 of file gnunet-service-scalarproduct-ecc_bob.c.

References GNUNET_CRYPTO_hash(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_h2s(), GNUNET_log, GNUNET_SET_prepare(), GNUNET_SET_RESULT_REMOVED, BobServiceSession::intersection_op, BobServiceSession::peer, BobServiceSession::session_id, and BobServiceSession::total.

Referenced by handle_alices_computation_request(), and handle_bob_client_message_multipart().

659 {
660  struct GNUNET_HashCode set_sid;
661 
663  sizeof (struct GNUNET_HashCode),
664  &set_sid);
666  "Got session with key %s and %u elements, starting intersection.\n",
667  GNUNET_h2s (&s->session_id),
668  (unsigned int) s->total);
669 
670  s->intersection_op
671  = GNUNET_SET_prepare (&s->peer,
672  &set_sid,
673  NULL,
675  (struct GNUNET_SET_Option[]) {{ 0 }},
677  s);
678  if (GNUNET_OK !=
680  s->intersection_set))
681  {
682  GNUNET_break (0);
685  return;
686  }
688  s->intersection_set = NULL;
689 }
enum GNUNET_SCALARPRODUCT_ResponseStatus status
State of this session.
struct GNUNET_SET_OperationHandle * intersection_op
Set of elements for which will conduction an intersection.
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:78
const char * GNUNET_h2s(const struct GNUNET_HashCode *hc)
Convert a hash value to a string (for printing debug messages).
struct GNUNET_SET_OperationHandle * GNUNET_SET_prepare(const struct GNUNET_PeerIdentity *other_peer, const struct GNUNET_HashCode *app_id, const struct GNUNET_MessageHeader *context_msg, enum GNUNET_SET_ResultMode result_mode, struct GNUNET_SET_Option options[], GNUNET_SET_ResultIterator result_cb, void *result_cls)
Prepare a set operation to be evaluated with another peer.
Definition: set_api.c:812
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
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_SET_destroy(struct GNUNET_SET_Handle *set)
Destroy the set handle, and free all associated resources.
Definition: set_api.c:771
struct GNUNET_HashCode session_id
(hopefully) unique transaction ID
void GNUNET_CRYPTO_hash(const void *block, size_t size, struct GNUNET_HashCode *ret)
Compute hash of a given block.
Definition: crypto_hash.c:44
A 512-bit hashcode.
uint32_t total
How many elements will be supplied in total from the client.
static void prepare_client_end_notification(struct BobServiceSession *session)
Notify the client that the session has succeeded or failed.
Option for set operations.
struct GNUNET_SET_Handle * intersection_set
Set of elements for which we will be conducting an intersection.
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:1124
#define GNUNET_log(kind,...)
Client gets only elements that have been removed from the set.
struct GNUNET_PeerIdentity peer
Originator&#39;s peer identity.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ handle_alices_computation_request()

static void handle_alices_computation_request ( void *  cls,
const struct EccServiceRequestMessage msg 
)
static

Handle a request from Alice to calculate a scalarproduct with us (Bob).

Parameters
clsclosure (set from GNUNET_CADET_connect)
msgthe actual message

Definition at line 699 of file gnunet-service-scalarproduct-ecc_bob.c.

References BobServiceSession::client_received_element_count, GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, BobServiceSession::s, EccServiceRequestMessage::session_id, BobServiceSession::session_id, start_intersection(), and BobServiceSession::total.

701 {
702  struct BobServiceSession *s = cls;
703 
704  s->session_id = msg->session_id; // ??
706  {
708  "Alice ready, still waiting for Bob client data!\n");
709  return;
710  }
712  "Both ready, launching intersection!\n");
713  start_intersection (s);
714 }
struct GNUNET_HashCode session_id
The transaction/session key used to identify a session.
uint32_t client_received_element_count
Already transferred elements (received) for multipart messages from client.
static void start_intersection(struct BobServiceSession *s)
We&#39;ve paired up a client session with an incoming CADET request.
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 GNUNET_CRYPTO_PaillierCiphertext s
Bob&#39;s "s".
uint32_t total
How many elements will be supplied in total from the client.
#define GNUNET_log(kind,...)
Here is the call graph for this function:

◆ cb_channel_incoming()

static void* cb_channel_incoming ( void *  cls,
struct GNUNET_CADET_Channel channel,
const struct GNUNET_PeerIdentity initiator 
)
static

Function called for inbound channels on Bob's end.

Does some preliminary initialization, more happens after we get Alice's first message.

Parameters
clsour struct BobServiceSession
channelnew handle to the channel
initiatorpeer that started the channel
Returns
session associated with the channel

Definition at line 728 of file gnunet-service-scalarproduct-ecc_bob.c.

References BobServiceSession::cadet_mq, BobServiceSession::channel, GNUNET_CADET_close_port(), GNUNET_CADET_get_mq(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s(), GNUNET_log, BobServiceSession::peer, BobServiceSession::port, and BobServiceSession::s.

Referenced by handle_bob_client_message().

731 {
732  struct BobServiceSession *s = cls;
733 
735  "New incoming channel from peer %s.\n",
736  GNUNET_i2s (initiator));
738  s->port = NULL;
739  s->peer = *initiator;
740  s->channel = channel;
742  return s;
743 }
struct GNUNET_CADET_Port * port
Our open port.
A scalarproduct session which tracks an offer for a multiplication service by a local client...
struct GNUNET_CADET_Channel * channel
The CADET channel.
struct GNUNET_CRYPTO_PaillierCiphertext s
Bob&#39;s "s".
#define GNUNET_log(kind,...)
void GNUNET_CADET_close_port(struct GNUNET_CADET_Port *p)
Close a port opened with GNUNET_CADET_open_port().
Definition: cadet_api.c:882
struct GNUNET_PeerIdentity peer
Originator&#39;s peer identity.
struct GNUNET_MQ_Handle * cadet_mq
The message queue for this channel.
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
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:1142
Here is the call graph for this function:
Here is the caller graph for this function:

◆ check_bob_client_message_multipart()

static int check_bob_client_message_multipart ( void *  cls,
const struct ComputationBobCryptodataMultipartMessage msg 
)
static

We're receiving additional set data.

Check it is well-formed.

Parameters
clsidentification of the client
msgthe actual message
Returns
GNUNET_OK if msg is well-formed

Definition at line 754 of file gnunet-service-scalarproduct-ecc_bob.c.

References BobServiceSession::client_received_element_count, ComputationBobCryptodataMultipartMessage::element_count_contained, GNUNET_break, GNUNET_OK, GNUNET_SYSERR, ComputationBobCryptodataMultipartMessage::header, BobServiceSession::s, GNUNET_MessageHeader::size, and BobServiceSession::total.

756 {
757  struct BobServiceSession *s = cls;
758  uint32_t contained_count;
759  uint16_t msize;
760 
761  msize = ntohs (msg->header.size);
762  contained_count = ntohl (msg->element_count_contained);
763  if ( (msize != (sizeof (struct ComputationBobCryptodataMultipartMessage) +
764  contained_count * sizeof (struct GNUNET_SCALARPRODUCT_Element))) ||
765  (0 == contained_count) ||
766  (UINT16_MAX < contained_count) ||
768  (s->total < s->client_received_element_count + contained_count) )
769  {
770  GNUNET_break (0);
771  return GNUNET_SYSERR;
772  }
773  return GNUNET_OK;
774 }
uint32_t client_received_element_count
Already transferred elements (received) for multipart messages from client.
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:78
uint16_t size
The length of the struct (in bytes, including the length field itself), in big-endian format...
A scalarproduct session which tracks an offer for a multiplication service by a local client...
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
struct GNUNET_CRYPTO_PaillierCiphertext s
Bob&#39;s "s".
uint32_t total
How many elements will be supplied in total from the client.
#define GNUNET_SYSERR
Definition: gnunet_common.h:79
struct GNUNET_MessageHeader header
GNUNET message header.
uint32_t element_count_contained
contained elements the vector in payload contains
multipart messages following struct ComputationMessage
An element key-value pair for scalarproduct.

◆ handle_bob_client_message_multipart()

static void handle_bob_client_message_multipart ( void *  cls,
const struct ComputationBobCryptodataMultipartMessage msg 
)
static

We're receiving additional set data.

Add it to our set and if we are done, initiate the transaction.

Parameters
clsidentification of the client
msgthe actual message

Definition at line 785 of file gnunet-service-scalarproduct-ecc_bob.c.

References BobServiceSession::channel, BobServiceSession::client, BobServiceSession::client_received_element_count, GNUNET_SET_Element::data, ComputationBobCryptodataMultipartMessage::element_count_contained, GNUNET_SET_Element::element_type, GNUNET_break, GNUNET_CONTAINER_multihashmap_put(), GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_log, GNUNET_memcpy, GNUNET_new, GNUNET_SERVICE_client_continue(), GNUNET_SET_add_element(), GNUNET_SYSERR, BobServiceSession::intersected_elements, BobServiceSession::intersection_set, GNUNET_SCALARPRODUCT_Element::key, BobServiceSession::s, GNUNET_SET_Element::size, start_intersection(), and BobServiceSession::total.

787 {
788  struct BobServiceSession *s = cls;
789  uint32_t contained_count;
790  const struct GNUNET_SCALARPRODUCT_Element *elements;
791  struct GNUNET_SET_Element set_elem;
792  struct GNUNET_SCALARPRODUCT_Element *elem;
793 
794  contained_count = ntohl (msg->element_count_contained);
795  elements = (const struct GNUNET_SCALARPRODUCT_Element *) &msg[1];
796  for (uint32_t i = 0; i < contained_count; i++)
797  {
799  GNUNET_memcpy (elem,
800  &elements[i],
801  sizeof (struct GNUNET_SCALARPRODUCT_Element));
802  if (GNUNET_SYSERR ==
804  &elem->key,
805  elem,
807  {
808  GNUNET_break (0);
809  GNUNET_free (elem);
810  continue;
811  }
812  set_elem.data = &elem->key;
813  set_elem.size = sizeof (elem->key);
814  set_elem.element_type = 0;
816  &set_elem,
817  NULL, NULL);
818  }
819  s->client_received_element_count += contained_count;
822  {
823  /* more to come */
825  "Request still partial, waiting for more client data!\n");
826  return;
827  }
828  if (NULL == s->channel)
829  {
830  /* no Alice waiting for this request, wait for Alice */
832  "Client ready, still waiting for Alice!\n");
833  return;
834  }
836  "Both ready, launching intersection!\n");
837  start_intersection (s);
838 }
uint32_t client_received_element_count
Already transferred elements (received) for multipart messages from client.
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:686
struct GNUNET_HashCode key
Key used to identify matching pairs of values to multiply.
Element stored in a set.
static void start_intersection(struct BobServiceSession *s)
We&#39;ve paired up a client session with an incoming CADET request.
#define GNUNET_new(type)
Allocate a struct or union of the given type.
A scalarproduct session which tracks an offer for a multiplication service by a local client...
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
#define GNUNET_memcpy(dst, src, n)
struct GNUNET_CADET_Channel * channel
The CADET channel.
struct GNUNET_SERVICE_Client * client
The client this request is related to.
struct GNUNET_CRYPTO_PaillierCiphertext s
Bob&#39;s "s".
uint32_t total
How many elements will be supplied in total from the client.
There must only be one value per key; storing a value should fail if a value under the same key alrea...
#define GNUNET_SYSERR
Definition: gnunet_common.h:79
struct GNUNET_SET_Handle * intersection_set
Set of elements for which we will be conducting an intersection.
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.
struct GNUNET_CONTAINER_MultiHashMap * intersected_elements
All non-0-value&#39;d elements transmitted to us.
#define GNUNET_log(kind,...)
uint32_t element_count_contained
contained elements the vector in payload contains
void GNUNET_SERVICE_client_continue(struct GNUNET_SERVICE_Client *c)
Continue receiving further messages from the given client.
Definition: service.c:2533
An element key-value pair for scalarproduct.
#define GNUNET_free(ptr)
Wrapper around free.
Here is the call graph for this function:

◆ check_bob_client_message()

static int check_bob_client_message ( void *  cls,
const struct BobComputationMessage msg 
)
static

Handler for Bob's a client request message.

Check msg is well-formed.

Parameters
clsidentification of the client
msgthe actual message
Returns
GNUNET_OK if msg is well-formed

Definition at line 850 of file gnunet-service-scalarproduct-ecc_bob.c.

References BobComputationMessage::element_count_contained, BobComputationMessage::element_count_total, GNUNET_break, GNUNET_break_op, GNUNET_OK, GNUNET_SCALARPRODUCT_STATUS_INIT, GNUNET_SYSERR, BobComputationMessage::header, BobServiceSession::s, GNUNET_MessageHeader::size, and BobServiceSession::status.

852 {
853  struct BobServiceSession *s = cls;
854  uint32_t contained_count;
855  uint32_t total_count;
856  uint16_t msize;
857 
859  {
860  GNUNET_break (0);
861  return GNUNET_SYSERR;
862  }
863  msize = ntohs (msg->header.size);
864  total_count = ntohl (msg->element_count_total);
865  contained_count = ntohl (msg->element_count_contained);
866  if ( (0 == total_count) ||
867  (0 == contained_count) ||
868  (UINT16_MAX < contained_count) ||
869  (msize != (sizeof (struct BobComputationMessage) +
870  contained_count * sizeof (struct GNUNET_SCALARPRODUCT_Element))) )
871  {
872  GNUNET_break_op (0);
873  return GNUNET_SYSERR;
874  }
875  return GNUNET_OK;
876 }
uint32_t element_count_total
how many elements the vector in payload contains
Definition: scalarproduct.h:96
struct GNUNET_MessageHeader header
GNUNET message header with type GNUNET_MESSAGE_TYPE_SCALARPRODUCT_CLIENT_TO_BOB.
Definition: scalarproduct.h:91
enum GNUNET_SCALARPRODUCT_ResponseStatus status
State of this session.
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:78
uint16_t size
The length of the struct (in bytes, including the length field itself), in big-endian format...
A scalarproduct session which tracks an offer for a multiplication service by a local client...
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
#define GNUNET_break_op(cond)
Use this for assertion violations caused by other peers (i.e.
Operation is still active (never returned, used internally).
struct GNUNET_CRYPTO_PaillierCiphertext s
Bob&#39;s "s".
#define GNUNET_SYSERR
Definition: gnunet_common.h:79
uint32_t element_count_contained
contained elements the vector in payload contains
Message type passed from client to service to initiate a request or responder role.
Definition: scalarproduct.h:85
An element key-value pair for scalarproduct.

◆ handle_bob_client_message()

static void handle_bob_client_message ( void *  cls,
const struct BobComputationMessage msg 
)
static

Handler for Bob's a client request message.

Bob is in the response role, keep the values + session and waiting for a matching session or process a waiting request from Alice.

Parameters
clsidentification of the client
msgthe actual message

Definition at line 888 of file gnunet-service-scalarproduct-ecc_bob.c.

References cb_channel_destruction(), cb_channel_incoming(), BobServiceSession::client, BobServiceSession::client_received_element_count, GNUNET_SET_Element::data, BobComputationMessage::element_count_contained, BobComputationMessage::element_count_total, GNUNET_SET_Element::element_type, GNUNET_break, GNUNET_CADET_open_port(), GNUNET_CONTAINER_multihashmap_create(), GNUNET_CONTAINER_multihashmap_put(), GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_h2s(), GNUNET_log, GNUNET_memcpy, GNUNET_MESSAGE_TYPE_SCALARPRODUCT_ECC_ALICE_CRYPTODATA, GNUNET_MESSAGE_TYPE_SCALARPRODUCT_ECC_SESSION_INITIALIZATION, GNUNET_MQ_handler_end, GNUNET_MQ_hd_fixed_size, GNUNET_MQ_hd_var_size, GNUNET_new, GNUNET_ntohll(), GNUNET_SCALARPRODUCT_STATUS_ACTIVE, GNUNET_SERVICE_client_continue(), GNUNET_SERVICE_client_drop(), GNUNET_SET_add_element(), GNUNET_SET_create(), GNUNET_SET_OPERATION_INTERSECTION, GNUNET_SYSERR, GNUNET_YES, BobServiceSession::intersected_elements, BobServiceSession::intersection_set, GNUNET_SCALARPRODUCT_Element::key, BobServiceSession::port, BobServiceSession::s, BobServiceSession::session_id, BobComputationMessage::session_key, GNUNET_SET_Element::size, BobServiceSession::status, BobServiceSession::total, BobServiceSession::used_element_count, and MpiElement::value.

890 {
891  struct BobServiceSession *s = cls;
892  struct GNUNET_MQ_MessageHandler cadet_handlers[] = {
893  GNUNET_MQ_hd_fixed_size (alices_computation_request,
896  s),
897  GNUNET_MQ_hd_var_size (alices_cryptodata_message,
900  s),
902  };
903  uint32_t contained_count;
904  uint32_t total_count;
905  const struct GNUNET_SCALARPRODUCT_Element *elements;
906  struct GNUNET_SET_Element set_elem;
907  struct GNUNET_SCALARPRODUCT_Element *elem;
908 
909  total_count = ntohl (msg->element_count_total);
910  contained_count = ntohl (msg->element_count_contained);
911 
913  s->total = total_count;
914  s->client_received_element_count = contained_count;
915  s->session_id = msg->session_key;
916  elements = (const struct GNUNET_SCALARPRODUCT_Element *) &msg[1];
919  GNUNET_YES);
923  for (uint32_t i = 0; i < contained_count; i++)
924  {
925  if (0 == GNUNET_ntohll (elements[i].value))
926  continue;
928  GNUNET_memcpy (elem,
929  &elements[i],
930  sizeof (struct GNUNET_SCALARPRODUCT_Element));
931  if (GNUNET_SYSERR ==
933  &elem->key,
934  elem,
936  {
937  GNUNET_break (0);
938  GNUNET_free (elem);
939  continue;
940  }
941  set_elem.data = &elem->key;
942  set_elem.size = sizeof (elem->key);
943  set_elem.element_type = 0;
945  &set_elem,
946  NULL, NULL);
947  s->used_element_count++;
948  }
951  "Received client request, opening port %s!\n",
952  GNUNET_h2s (&msg->session_key));
954  &msg->session_key,
956  s,
957  NULL,
959  cadet_handlers);
960  if (NULL == s->port)
961  {
962  GNUNET_break (0);
964  return;
965  }
966 }
Vector of ECC-encrypted values sent by Alice to Bob (after set intersection).
uint32_t client_received_element_count
Already transferred elements (received) for multipart messages from client.
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:686
uint32_t used_element_count
How many elements actually are used for the scalar product.
uint32_t element_count_total
how many elements the vector in payload contains
Definition: scalarproduct.h:96
Operation is still active (never returned, used internally).
struct GNUNET_HashCode key
Key used to identify matching pairs of values to multiply.
enum GNUNET_SCALARPRODUCT_ResponseStatus status
State of this session.
Element stored in a set.
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:656
struct GNUNET_CADET_Port * port
Our open port.
#define GNUNET_MESSAGE_TYPE_SCALARPRODUCT_ECC_ALICE_CRYPTODATA
Alice -> Bob ECC crypto data.
static void cb_channel_destruction(void *cls, const struct GNUNET_CADET_Channel *channel)
Function called whenever a channel is destroyed.
static void * cb_channel_incoming(void *cls, struct GNUNET_CADET_Channel *channel, const struct GNUNET_PeerIdentity *initiator)
Function called for inbound channels on Bob&#39;s end.
#define GNUNET_MQ_hd_fixed_size(name, code, str, ctx)
const char * GNUNET_h2s(const struct GNUNET_HashCode *hc)
Convert a hash value to a string (for printing debug messages).
#define GNUNET_new(type)
Allocate a struct or union of the given type.
A scalarproduct session which tracks an offer for a multiplication service by a local client...
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
struct GNUNET_HashCode session_id
(hopefully) unique transaction ID
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 incomming MQ-based channels.
Definition: cadet_api.c:1029
#define GNUNET_memcpy(dst, src, n)
static char * value
Value of the record to add/remove.
#define GNUNET_MQ_hd_var_size(name, code, str, ctx)
static struct GNUNET_CADET_Handle * my_cadet
Handle to the CADET service.
struct GNUNET_SERVICE_Client * client
The client this request is related to.
struct GNUNET_CRYPTO_PaillierCiphertext s
Bob&#39;s "s".
uint32_t total
How many elements will be supplied in total from the client.
void GNUNET_SERVICE_client_drop(struct GNUNET_SERVICE_Client *c)
Ask the server to disconnect from the given client.
Definition: service.c:2618
Message handler for a specific message type.
There must only be one value per key; storing a value should fail if a value under the same key alrea...
#define GNUNET_SYSERR
Definition: gnunet_common.h:79
static const struct GNUNET_CONFIGURATION_Handle * cfg
GNUnet configuration handle.
Message type passed from requesting service Alice to responding service Bob to initiate a request and...
#define GNUNET_MESSAGE_TYPE_SCALARPRODUCT_ECC_SESSION_INITIALIZATION
Alice -> Bob ECC session initialization.
struct GNUNET_SET_Handle * intersection_set
Set of elements for which we will be conducting an intersection.
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.
uint32_t element_count_contained
contained elements the vector in payload contains
struct GNUNET_CONTAINER_MultiHashMap * intersected_elements
All non-0-value&#39;d elements transmitted to us.
#define GNUNET_log(kind,...)
struct GNUNET_CONTAINER_MultiHashMap * GNUNET_CONTAINER_multihashmap_create(unsigned int len, int do_not_copy_keys)
Create a multi hash map.
#define GNUNET_YES
Definition: gnunet_common.h:80
struct GNUNET_HashCode session_key
the transaction/session key used to identify a session
Set intersection, only return elements that are in both sets.
void GNUNET_SERVICE_client_continue(struct GNUNET_SERVICE_Client *c)
Continue receiving further messages from the given client.
Definition: service.c:2533
#define GNUNET_MQ_handler_end()
End-marker for the handlers array.
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_free(ptr)
Wrapper around free.
Here is the call graph for this function:

◆ shutdown_task()

static void shutdown_task ( void *  cls)
static

Task run during shutdown.

Parameters
clsunused

Definition at line 975 of file gnunet-service-scalarproduct-ecc_bob.c.

References GNUNET_CADET_disconnect(), GNUNET_CRYPTO_ecc_dlog_release(), GNUNET_ERROR_TYPE_DEBUG, and GNUNET_log.

Referenced by run().

976 {
978  "Shutting down, initiating cleanup.\n");
979  // FIXME: we have to cut our connections to CADET first!
980  if (NULL != my_cadet)
981  {
983  my_cadet = NULL;
984  }
985  if (NULL != edc)
986  {
988  edc = NULL;
989  }
990 }
void GNUNET_CADET_disconnect(struct GNUNET_CADET_Handle *handle)
Disconnect from the cadet service.
Definition: cadet_api.c:849
static struct GNUNET_CRYPTO_EccDlogContext * edc
Context for DLOG operations on a curve.
static struct GNUNET_CADET_Handle * my_cadet
Handle to the CADET service.
void GNUNET_CRYPTO_ecc_dlog_release(struct GNUNET_CRYPTO_EccDlogContext *dlc)
Release precalculated values.
#define GNUNET_log(kind,...)
Here is the call graph for this function:
Here is the caller graph for this function:

◆ client_connect_cb()

static void* client_connect_cb ( void *  cls,
struct GNUNET_SERVICE_Client client,
struct GNUNET_MQ_Handle mq 
)
static

A client connected.

Setup the associated data structure.

Parameters
clsclosure, NULL
clientidentification of the client
mqmessage queue to communicate with client
Returns
our struct BobServiceSession

Definition at line 1004 of file gnunet-service-scalarproduct-ecc_bob.c.

References BobServiceSession::client, BobServiceSession::client_mq, GNUNET_new, mq, and BobServiceSession::s.

Referenced by run().

1007 {
1008  struct BobServiceSession *s;
1009 
1010  s = GNUNET_new (struct BobServiceSession);
1011  s->client = client;
1012  s->client_mq = mq;
1013  return s;
1014 }
struct GNUNET_MQ_Handle * client_mq
Client message queue.
#define GNUNET_new(type)
Allocate a struct or union of the given type.
A scalarproduct session which tracks an offer for a multiplication service by a local client...
struct GNUNET_SERVICE_Client * client
The client this request is related to.
struct GNUNET_CRYPTO_PaillierCiphertext s
Bob&#39;s "s".
struct GNUNET_MQ_Handle * mq
Definition: 003.c:5
Here is the caller graph for this function:

◆ client_disconnect_cb()

static void client_disconnect_cb ( void *  cls,
struct GNUNET_SERVICE_Client client,
void *  app_cls 
)
static

A client disconnected.

Remove the associated session(s), release data structures and cancel pending outgoing transmissions to the client.

Parameters
clsclosure, NULL
clientidentification of the client
app_clsour struct BobServiceSession

Definition at line 1028 of file gnunet-service-scalarproduct-ecc_bob.c.

References BobServiceSession::client, destroy_service_session(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, and BobServiceSession::s.

Referenced by run().

1031 {
1032  struct BobServiceSession *s = app_cls;
1033 
1035  "Client disconnected from us.\n");
1036  s->client = NULL;
1038 }
A scalarproduct session which tracks an offer for a multiplication service by a local client...
struct GNUNET_SERVICE_Client * client
The client this request is related to.
struct GNUNET_CRYPTO_PaillierCiphertext s
Bob&#39;s "s".
static void destroy_service_session(struct BobServiceSession *s)
Destroy session state, we are done with it.
#define GNUNET_log(kind,...)
Here is the call graph for this function:
Here is the caller graph for this function:

◆ run()

static void run ( void *  cls,
const struct GNUNET_CONFIGURATION_Handle c,
struct GNUNET_SERVICE_Handle service 
)
static

Initialization of the program and message handlers.

Parameters
clsclosure
cconfiguration to use
servicethe initialized service

Definition at line 1049 of file gnunet-service-scalarproduct-ecc_bob.c.

References _, client_connect_cb(), client_disconnect_cb(), GNUNET_CADET_connect(), GNUNET_CRYPTO_ecc_dlog_prepare(), GNUNET_ERROR_TYPE_ERROR, GNUNET_log, GNUNET_MESSAGE_TYPE_SCALARPRODUCT_CLIENT_MULTIPART_BOB, GNUNET_MESSAGE_TYPE_SCALARPRODUCT_CLIENT_TO_BOB, GNUNET_MQ_handler_end, GNUNET_MQ_hd_var_size, GNUNET_SCHEDULER_add_shutdown(), GNUNET_SCHEDULER_shutdown(), GNUNET_SERVICE_MAIN(), GNUNET_SERVICE_OPTION_NONE, and shutdown_task().

1052 {
1053  cfg = c;
1054  /* We don't really do DLOG, so we can setup with very minimal resources */
1055  edc = GNUNET_CRYPTO_ecc_dlog_prepare (4 /* max value */,
1056  2 /* RAM */);
1059  NULL);
1060  if (NULL == my_cadet)
1061  {
1063  _("Connect to CADET failed\n"));
1065  return;
1066  }
1067 }
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:1293
static struct GNUNET_CRYPTO_EccDlogContext * edc
Context for DLOG operations on a curve.
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_SCHEDULER_shutdown(void)
Request the shutdown of a scheduler.
Definition: scheduler.c:524
struct GNUNET_CADET_Handle * GNUNET_CADET_connect(const struct GNUNET_CONFIGURATION_Handle *cfg)
Connect to the MQ-based cadet service.
Definition: cadet_api.c:995
#define _(String)
GNU gettext support macro.
Definition: platform.h:208
static struct GNUNET_CADET_Handle * my_cadet
Handle to the CADET service.
static const struct GNUNET_CONFIGURATION_Handle * cfg
GNUnet configuration handle.
#define GNUNET_log(kind,...)
static void shutdown_task(void *cls)
Task run during shutdown.
Here is the call graph for this function:

◆ GNUNET_SERVICE_MAIN()

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.

Referenced by run().

Here is the caller graph for this function:

Variable Documentation

◆ cfg

const struct GNUNET_CONFIGURATION_Handle* cfg
static

GNUnet configuration handle.

Definition at line 178 of file gnunet-service-scalarproduct-ecc_bob.c.

◆ my_cadet

struct GNUNET_CADET_Handle* my_cadet
static

Handle to the CADET service.

Definition at line 183 of file gnunet-service-scalarproduct-ecc_bob.c.

◆ edc

struct GNUNET_CRYPTO_EccDlogContext* edc
static

Context for DLOG operations on a curve.

Definition at line 188 of file gnunet-service-scalarproduct-ecc_bob.c.