gnunet-service-scalarproduct_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_seti_service.h"
#include "scalarproduct.h"
#include "gnunet-service-scalarproduct.h"

Include dependency graph for gnunet-service-scalarproduct_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__)
#define	ELEMENT_CAPACITY
	Maximum count of elements we can put into a multipart message. More...

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_multipart (struct BobServiceSession *s)
	Send a multipart chunk of a service response from Bob to Alice. More...
static void	transmit_bobs_cryptodata_message (struct BobServiceSession *s)
	Bob generates the response message to be sent to Alice after computing the values (1), (2), S and S'. More...
static gcry_mpi_t	compute_square_sum (const gcry_mpi_t *vector, uint32_t length)
	Computes the square sum over a vector of a given length. More...
static int	compute_service_response (struct BobServiceSession *session)
	Compute the values (1)[]: $E_A(a_{pi(i)}) otimes E_A(- r_{pi(i)} - b_{pi(i)}) &= E_A(a_{pi(i)} - r_{pi(i)} - b_{pi(i)})$ (2)[]: $E_A(a_{pi'(i)}) otimes E_A(- r_{pi'(i)}) &= E_A(a_{pi'(i)} - r_{pi'(i)})$ S: $S := E_A(sum (r_i + b_i)^2)$ S': $S' := E_A(sum r_i^2)$. 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 void	transmit_cryptographic_reply (struct BobServiceSession *s)
	Intersection operation and receiving data via CADET from Alice are both done, compute and transmit our reply via CADET. More...
static int	check_alices_cryptodata_message (void *cls, const struct AliceCryptodataMessage *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 AliceCryptodataMessage *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_SETI_Element *element, uint64_t current_size, enum GNUNET_SETI_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 ServiceRequestMessage *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_Handle *	cfg
	GNUnet configuration handle. More...
static struct GNUNET_CRYPTO_PaillierPublicKey	my_pubkey
	Service's own public key. More...
static struct GNUNET_CRYPTO_PaillierPrivateKey	my_privkey
	Service's own private key. More...
static gcry_mpi_t	my_offset
	Service's offset for values that could possibly be negative but are plaintext for encryption. More...
static struct GNUNET_CADET_Handle *	my_cadet
	Handle to the CADET service. More...

Detailed Description

scalarproduct service implementation

Author

Christian M. Fuchs

Christian Grothoff

Definition in file gnunet-service-scalarproduct_bob.c.

Macro Definition Documentation

LOG

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

Definition at line 39 of file gnunet-service-scalarproduct_bob.c.

ELEMENT_CAPACITY

#define ELEMENT_CAPACITY

Value:

                           ((GNUNET_CONSTANTS_MAX_CADET_MESSAGE_SIZE - 1 \
                           - sizeof(struct BobCryptodataMultipartMessage)) \
                          / sizeof(struct \
                                   GNUNET_CRYPTO_PaillierCiphertext))

Maximum count of elements we can put into a multipart message.

Definition at line 399 of file gnunet-service-scalarproduct_bob.c.

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

cls	NULL
key	key of the element
value	the value to free

Definition at line 239 of file gnunet-service-scalarproduct_bob.c.

{
  struct GNUNET_SCALARPRODUCT_Element *element = value;
 
  GNUNET_free (element);
  return GNUNET_OK;
}

References GNUNET_free, GNUNET_OK, and value.

Referenced by destroy_service_session().

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

session

the session to free elements from

Definition at line 256 of file gnunet-service-scalarproduct_bob.c.

{
  unsigned int i;
 
  if (GNUNET_YES == s->in_destroy)
    return;
  s->in_destroy = GNUNET_YES;
  if (NULL != s->client)
  {
    struct GNUNET_SERVICE_Client *c = s->client;
 
    s->client = NULL;
    GNUNET_SERVICE_client_drop (c);
  }
  if (NULL != s->intersected_elements)
  {
    GNUNET_CONTAINER_multihashmap_iterate (s->intersected_elements,
                                           &free_element_cb,
                                           NULL);
    GNUNET_CONTAINER_multihashmap_destroy (s->intersected_elements);
    s->intersected_elements = NULL;
  }
  if (NULL != s->intersection_op)
  {
    GNUNET_SETI_operation_cancel (s->intersection_op);
    s->intersection_op = NULL;
  }
  if (NULL != s->intersection_set)
  {
    GNUNET_SETI_destroy (s->intersection_set);
    s->intersection_set = NULL;
  }
  if (NULL != s->e_a)
  {
    GNUNET_free (s->e_a);
    s->e_a = NULL;
  }
  if (NULL != s->sorted_elements)
  {
    for (i = 0; i < s->used_element_count; i++)
      gcry_mpi_release (s->sorted_elements[i].value);
    GNUNET_free (s->sorted_elements);
    s->sorted_elements = NULL;
  }
  if (NULL != s->r)
  {
    GNUNET_free (s->r);
    s->r = NULL;
  }
  if (NULL != s->r_prime)
  {
    GNUNET_free (s->r_prime);
    s->r_prime = NULL;
  }
  if (NULL != s->port)
  {
    GNUNET_CADET_close_port (s->port);
    s->port = NULL;
  }
  if (NULL != s->channel)
  {
    GNUNET_CADET_channel_destroy (s->channel);
    s->channel = NULL;
  }
  GNUNET_free (s);
}

References BobServiceSession::channel, BobServiceSession::client, BobServiceSession::e_a, 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_SETI_destroy(), GNUNET_SETI_operation_cancel(), GNUNET_YES, BobServiceSession::in_destroy, BobServiceSession::intersected_elements, BobServiceSession::intersection_op, BobServiceSession::intersection_set, BobServiceSession::port, BobServiceSession::r, BobServiceSession::r_prime, BobServiceSession::sorted_elements, BobServiceSession::used_element_count, and MpiElement::value.

Referenced by cb_channel_destruction(), and client_disconnect_cb().

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

session

the associated client session to fail or succeed

Definition at line 332 of file gnunet-service-scalarproduct_bob.c.

{
  struct ClientResponseMessage *msg;
  struct GNUNET_MQ_Envelope *e;
 
  if (NULL == session->client_mq)
    return; /* no client left to be notified */
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Sending session-end notification with status %d to client for session %s\n",
              session->status,
              GNUNET_h2s (&session->session_id));
  e = GNUNET_MQ_msg (msg,
                     GNUNET_MESSAGE_TYPE_SCALARPRODUCT_RESULT);
  msg->range = 0;
  msg->product_length = htonl (0);
  msg->status = htonl (session->status);
  GNUNET_MQ_send (session->client_mq,
                  e);
}

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, BobServiceSession::session_id, and BobServiceSession::status.

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

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

cls	the struct BobServiceSession
channel	connection to the other end (henceforth invalid)

Definition at line 363 of file gnunet-service-scalarproduct_bob.c.

{
  struct BobServiceSession *s = cls;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Peer disconnected, terminating session %s with peer %s\n",
              GNUNET_h2s (&s->session_id),
              GNUNET_i2s (&s->peer));
  if (GNUNET_SCALARPRODUCT_STATUS_ACTIVE == s->status)
  {
    s->status = GNUNET_SCALARPRODUCT_STATUS_FAILURE;
    prepare_client_end_notification (s);
  }
  s->channel = NULL;
  destroy_service_session (s);
}

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

Referenced by handle_bob_client_message().

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 387 of file gnunet-service-scalarproduct_bob.c.

{
  struct BobServiceSession *session = cls;
 
  session->status = GNUNET_SCALARPRODUCT_STATUS_SUCCESS;
  prepare_client_end_notification (session);
}

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

Referenced by transmit_bobs_cryptodata_message(), and transmit_bobs_cryptodata_message_multipart().

Here is the call graph for this function:

Here is the caller graph for this function:

transmit_bobs_cryptodata_message_multipart()

static void transmit_bobs_cryptodata_message_multipart ( struct BobServiceSession *  s )

static

Send a multipart chunk of a service response from Bob to Alice.

This element only contains the two permutations of R, R'.

Parameters

s	the associated service session

Definition at line 412 of file gnunet-service-scalarproduct_bob.c.

{
  struct GNUNET_CRYPTO_PaillierCiphertext *payload;
  struct BobCryptodataMultipartMessage *msg;
  struct GNUNET_MQ_Envelope *e;
  unsigned int i;
  unsigned int j;
  uint32_t todo_count;
 
  while (s->cadet_transmitted_element_count != s->used_element_count)
  {
    todo_count = s->used_element_count - s->cadet_transmitted_element_count;
    if (todo_count > ELEMENT_CAPACITY / 2)
      todo_count = ELEMENT_CAPACITY / 2;
 
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Sending %u additional crypto values to Alice\n",
                (unsigned int) todo_count);
    e = GNUNET_MQ_msg_extra (msg,
                             todo_count * sizeof(struct
                                                 GNUNET_CRYPTO_PaillierCiphertext)
                             * 2,
                             GNUNET_MESSAGE_TYPE_SCALARPRODUCT_BOB_CRYPTODATA_MULTIPART);
    msg->contained_element_count = htonl (todo_count);
    payload = (struct GNUNET_CRYPTO_PaillierCiphertext *) &msg[1];
    for (i = s->cadet_transmitted_element_count, j = 0; i <
         s->cadet_transmitted_element_count + todo_count; i++)
    {
      // r[i][p] and r[i][q]
      GNUNET_memcpy (&payload[j++],
                     &s->r[i],
                     sizeof(struct GNUNET_CRYPTO_PaillierCiphertext));
      GNUNET_memcpy (&payload[j++],
                     &s->r_prime[i],
                     sizeof(struct GNUNET_CRYPTO_PaillierCiphertext));
    }
    s->cadet_transmitted_element_count += todo_count;
    if (s->cadet_transmitted_element_count == s->used_element_count)
      GNUNET_MQ_notify_sent (e,
                             &bob_cadet_done_cb,
                             s);
    GNUNET_MQ_send (s->cadet_mq,
                    e);
  }
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "All values queued for Alice, Bob is done\n");
}

References bob_cadet_done_cb(), BobServiceSession::cadet_mq, BobServiceSession::cadet_transmitted_element_count, e, ELEMENT_CAPACITY, GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_memcpy, GNUNET_MESSAGE_TYPE_SCALARPRODUCT_BOB_CRYPTODATA_MULTIPART, GNUNET_MQ_msg_extra, GNUNET_MQ_notify_sent(), GNUNET_MQ_send(), msg, payload, BobServiceSession::r, BobServiceSession::r_prime, and BobServiceSession::used_element_count.

Referenced by transmit_bobs_cryptodata_message().

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 after computing the values (1), (2), S and S'.

(1)[]: $E_A(a_{pi(i)}) times E_A(- r_{pi(i)} - b_{pi(i)}) &= E_A(a_{pi(i)} - r_{pi(i)} - b_{pi(i)})$ (2)[]: $E_A(a_{pi'(i)}) times E_A(- r_{pi'(i)}) &= E_A(a_{pi'(i)} - r_{pi'(i)})$ S: $S := E_A(sum (r_i + b_i)^2)$ S': $S' := E_A(sum r_i^2)$

Parameters

s	the associated requesting session with Alice

Definition at line 473 of file gnunet-service-scalarproduct_bob.c.

{
  struct BobCryptodataMessage *msg;
  struct GNUNET_MQ_Envelope *e;
  struct GNUNET_CRYPTO_PaillierCiphertext *payload;
  unsigned int i;
 
  s->cadet_transmitted_element_count
    = ((GNUNET_CONSTANTS_MAX_CADET_MESSAGE_SIZE - 1 - sizeof(struct
                                                             BobCryptodataMessage))
       / sizeof(struct GNUNET_CRYPTO_PaillierCiphertext) / 2) - 1;
  if (s->cadet_transmitted_element_count > s->used_element_count)
    s->cadet_transmitted_element_count = s->used_element_count;
 
  e = GNUNET_MQ_msg_extra (msg,
                           (2 + s->cadet_transmitted_element_count * 2)
                           * sizeof(struct GNUNET_CRYPTO_PaillierCiphertext),
                           GNUNET_MESSAGE_TYPE_SCALARPRODUCT_BOB_CRYPTODATA);
  msg->contained_element_count = htonl (s->cadet_transmitted_element_count);
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Sending %u/%u crypto values to Alice\n",
              (unsigned int) s->cadet_transmitted_element_count,
              (unsigned int) s->used_element_count);
 
  payload = (struct GNUNET_CRYPTO_PaillierCiphertext *) &msg[1];
  GNUNET_memcpy (&payload[0],
                 &s->s,
                 sizeof(struct GNUNET_CRYPTO_PaillierCiphertext));
  GNUNET_memcpy (&payload[1],
                 &s->s_prime,
                 sizeof(struct GNUNET_CRYPTO_PaillierCiphertext));
 
  payload = &payload[2];
  // convert k[][]
  for (i = 0; i < s->cadet_transmitted_element_count; i++)
  {
    // k[i][p] and k[i][q]
    GNUNET_memcpy (&payload[i * 2],
                   &s->r[i],
                   sizeof(struct GNUNET_CRYPTO_PaillierCiphertext));
    GNUNET_memcpy (&payload[i * 2 + 1],
                   &s->r_prime[i],
                   sizeof(struct GNUNET_CRYPTO_PaillierCiphertext));
  }
  if (s->cadet_transmitted_element_count == s->used_element_count)
    GNUNET_MQ_notify_sent (e,
                           &bob_cadet_done_cb,
                           s);
  GNUNET_MQ_send (s->cadet_mq,
                  e);
  transmit_bobs_cryptodata_message_multipart (s);
}

References bob_cadet_done_cb(), BobServiceSession::cadet_mq, BobServiceSession::cadet_transmitted_element_count, e, GNUNET_CONSTANTS_MAX_CADET_MESSAGE_SIZE, GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_memcpy, GNUNET_MESSAGE_TYPE_SCALARPRODUCT_BOB_CRYPTODATA, GNUNET_MQ_msg_extra, GNUNET_MQ_notify_sent(), GNUNET_MQ_send(), msg, payload, BobServiceSession::r, BobServiceSession::r_prime, BobServiceSession::s, BobServiceSession::s_prime, transmit_bobs_cryptodata_message_multipart(), and BobServiceSession::used_element_count.

Referenced by transmit_cryptographic_reply().

Here is the call graph for this function:

Here is the caller graph for this function:

compute_square_sum()

static gcry_mpi_t compute_square_sum ( const gcry_mpi_t *  vector, uint32_t  length  )

static

Computes the square sum over a vector of a given length.

Parameters

vector	the vector to compute over
length	the length of the vector

Returns

an MPI value containing the calculated sum, never NULL TODO: code duplication with Alice!

Definition at line 540 of file gnunet-service-scalarproduct_bob.c.

{
  gcry_mpi_t elem;
  gcry_mpi_t sum;
  uint32_t i;
 
  GNUNET_assert (NULL != (sum = gcry_mpi_new (0)));
  GNUNET_assert (NULL != (elem = gcry_mpi_new (0)));
  for (i = 0; i < length; i++)
  {
    gcry_mpi_mul (elem, vector[i], vector[i]);
    gcry_mpi_add (sum, sum, elem);
  }
  gcry_mpi_release (elem);
  return sum;
}

References GNUNET_assert, and consensus-simulation::sum.

Referenced by compute_service_response().

Here is the caller graph for this function:

compute_service_response()

static int compute_service_response ( struct BobServiceSession *  session )

static

Compute the values (1)[]: $E_A(a_{pi(i)}) otimes E_A(- r_{pi(i)} - b_{pi(i)}) &= E_A(a_{pi(i)} - r_{pi(i)} - b_{pi(i)})$ (2)[]: $E_A(a_{pi'(i)}) otimes E_A(- r_{pi'(i)}) &= E_A(a_{pi'(i)} - r_{pi'(i)})$ S: $S := E_A(sum (r_i + b_i)^2)$ S': $S' := E_A(sum r_i^2)$.

Parameters

session

the requesting session + bob's requesting peer

Returns

GNUNET_OK on success

Definition at line 570 of file gnunet-service-scalarproduct_bob.c.

{
  uint32_t i;
  unsigned int *p;
  unsigned int *q;
  uint32_t count;
  gcry_mpi_t *rand;
  gcry_mpi_t tmp;
  const struct MpiElement *b;
  struct GNUNET_CRYPTO_PaillierCiphertext *a;
  struct GNUNET_CRYPTO_PaillierCiphertext *r;
  struct GNUNET_CRYPTO_PaillierCiphertext *r_prime;
 
  count = session->used_element_count;
  a = session->e_a;
  b = session->sorted_elements;
  q = GNUNET_CRYPTO_random_permute (GNUNET_CRYPTO_QUALITY_WEAK,
                                    count);
  p = GNUNET_CRYPTO_random_permute (GNUNET_CRYPTO_QUALITY_WEAK,
                                    count);
  rand = GNUNET_malloc (sizeof(gcry_mpi_t) * count);
  for (i = 0; i < count; i++)
    GNUNET_assert (NULL != (rand[i] = gcry_mpi_new (0)));
  r = GNUNET_malloc (sizeof(struct GNUNET_CRYPTO_PaillierCiphertext) * count);
  r_prime = GNUNET_malloc (sizeof(struct GNUNET_CRYPTO_PaillierCiphertext)
                           * count);
 
  for (i = 0; i < count; i++)
  {
    int32_t svalue;
 
    svalue = (int32_t) GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK,
                                                 UINT32_MAX);
    // long to gcry_mpi_t
    if (svalue < 0)
      gcry_mpi_sub_ui (rand[i],
                       rand[i],
                       -svalue);
    else
      rand[i] = gcry_mpi_set_ui (rand[i], svalue);
  }
 
  tmp = gcry_mpi_new (0);
  // encrypt the element
  // for the sake of readability I decided to have dedicated permutation
  // vectors, which get rid of all the lookups in p/q.
  // however, ap/aq are not absolutely necessary but are just abstraction
  // Calculate Kp = E(S + a_pi) (+) E(S - r_pi - b_pi)
  for (i = 0; i < count; i++)
  {
    // E(S - r_pi - b_pi)
    gcry_mpi_sub (tmp, my_offset, rand[p[i]]);
    gcry_mpi_sub (tmp, tmp, b[p[i]].value);
    GNUNET_assert (2 ==
                   GNUNET_CRYPTO_paillier_encrypt (&session->remote_pubkey,
                                                   tmp,
                                                   2,
                                                   &r[i]));
 
    // E(S - r_pi - b_pi) * E(S + a_pi) ==  E(2*S + a - r - b)
    if (GNUNET_OK !=
        GNUNET_CRYPTO_paillier_hom_add (&session->remote_pubkey,
                                        &r[i],
                                        &a[p[i]],
                                        &r[i]))
    {
      GNUNET_break_op (0);
      goto error_cleanup;
    }
  }
 
  // Calculate Kq = E(S + a_qi) (+) E(S - r_qi)
  for (i = 0; i < count; i++)
  {
    // E(S - r_qi)
    gcry_mpi_sub (tmp, my_offset, rand[q[i]]);
    GNUNET_assert (2 ==
                   GNUNET_CRYPTO_paillier_encrypt (&session->remote_pubkey,
                                                   tmp,
                                                   2,
                                                   &r_prime[i]));
 
    // E(S - r_qi) * E(S + a_qi) == E(2*S + a_qi - r_qi)
    if (GNUNET_OK !=
        GNUNET_CRYPTO_paillier_hom_add (&session->remote_pubkey,
                                        &r_prime[i],
                                        &a[q[i]],
                                        &r_prime[i]))
    {
      GNUNET_break_op (0);
      goto error_cleanup;
    }
  }
  gcry_mpi_release (tmp);
 
  // Calculate S' =  E(SUM( r_i^2 ))
  tmp = compute_square_sum (rand, count);
  GNUNET_assert (1 ==
                 GNUNET_CRYPTO_paillier_encrypt (&session->remote_pubkey,
                                                 tmp,
                                                 1,
                                                 &session->s_prime));
  gcry_mpi_release (tmp);
 
  // Calculate S = E(SUM( (r_i + b_i)^2 ))
  for (i = 0; i < count; i++)
    gcry_mpi_add (rand[i], rand[i], b[i].value);
  tmp = compute_square_sum (rand, count);
  GNUNET_assert (1 ==
                 GNUNET_CRYPTO_paillier_encrypt (&session->remote_pubkey,
                                                 tmp,
                                                 1,
                                                 &session->s));
  gcry_mpi_release (tmp);
 
  session->r = r;
  session->r_prime = r_prime;
 
  for (i = 0; i < count; i++)
    gcry_mpi_release (rand[i]);
  GNUNET_free (session->e_a);
  session->e_a = NULL;
  GNUNET_free (p);
  GNUNET_free (q);
  GNUNET_free (rand);
  return GNUNET_OK;
 
error_cleanup:
  GNUNET_free (r);
  GNUNET_free (r_prime);
  gcry_mpi_release (tmp);
  GNUNET_free (p);
  GNUNET_free (q);
  for (i = 0; i < count; i++)
    gcry_mpi_release (rand[i]);
  GNUNET_free (rand);
  return GNUNET_SYSERR;
}

References compute_square_sum(), BobServiceSession::e_a, GNUNET_assert, GNUNET_break_op, GNUNET_CRYPTO_paillier_encrypt(), GNUNET_CRYPTO_paillier_hom_add(), GNUNET_CRYPTO_QUALITY_WEAK, GNUNET_CRYPTO_random_permute(), GNUNET_CRYPTO_random_u32(), GNUNET_free, GNUNET_malloc, GNUNET_OK, GNUNET_SYSERR, my_offset, p, q, BobServiceSession::r, BobServiceSession::r_prime, BobServiceSession::remote_pubkey, BobServiceSession::s, BobServiceSession::s_prime, BobServiceSession::sorted_elements, BobServiceSession::used_element_count, and value.

Referenced by transmit_cryptographic_reply().

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

cls	the struct BobServiceSession *
key	the key (unused)
value	the struct GNUNET_SCALARPRODUCT_Element * TODO: code duplication with Alice!

Definition at line 720 of file gnunet-service-scalarproduct_bob.c.

{
  struct BobServiceSession *s = cls;
  struct GNUNET_SCALARPRODUCT_Element *e = value;
  gcry_mpi_t mval;
  int64_t val;
 
  mval = gcry_mpi_new (0);
  val = (int64_t) GNUNET_ntohll (e->value);
  if (0 > val)
    gcry_mpi_sub_ui (mval, mval, -val);
  else
    gcry_mpi_add_ui (mval, mval, val);
  s->sorted_elements [s->used_element_count].value = mval;
  s->sorted_elements [s->used_element_count].key = &e->key;
  s->used_element_count++;
  return GNUNET_OK;
}

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

Referenced by transmit_cryptographic_reply().

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

a	pointer to first struct MpiValue *
b	pointer 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 751 of file gnunet-service-scalarproduct_bob.c.

{
  const struct MpiElement *ma = a;
  const struct MpiElement *mb = b;
 
  return GNUNET_CRYPTO_hash_cmp (ma->key,
                                 mb->key);
}

References GNUNET_CRYPTO_hash_cmp(), and MpiElement::key.

Referenced by transmit_cryptographic_reply().

Here is the call graph for this function:

Here is the caller graph for this function:

transmit_cryptographic_reply()

static void transmit_cryptographic_reply ( struct BobServiceSession *  s )

static

Intersection operation and receiving data via CADET from Alice are both done, compute and transmit our reply via CADET.

Parameters

s	session to transmit reply for.

Definition at line 770 of file gnunet-service-scalarproduct_bob.c.

{
  struct GNUNET_CADET_Channel *channel;
 
  /* TODO: code duplication with Alice! */
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Received everything, building reply for Alice\n");
  s->sorted_elements
    = GNUNET_malloc (GNUNET_CONTAINER_multihashmap_size (
                       s->intersected_elements)
                     * sizeof(struct MpiElement));
  s->used_element_count = 0;
  GNUNET_CONTAINER_multihashmap_iterate (s->intersected_elements,
                                         &copy_element_cb,
                                         s);
  qsort (s->sorted_elements,
         s->used_element_count,
         sizeof(struct MpiElement),
         &element_cmp);
  if (GNUNET_OK !=
      compute_service_response (s))
  {
    channel = s->channel;
    s->channel = NULL;
    GNUNET_CADET_channel_destroy (channel);
    return;
  }
  transmit_bobs_cryptodata_message (s);
}

References BobServiceSession::channel, compute_service_response(), copy_element_cb(), element_cmp(), GNUNET_CADET_channel_destroy(), GNUNET_CONTAINER_multihashmap_iterate(), GNUNET_CONTAINER_multihashmap_size(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_malloc, GNUNET_OK, BobServiceSession::intersected_elements, LOG, BobServiceSession::sorted_elements, transmit_bobs_cryptodata_message(), and BobServiceSession::used_element_count.

Referenced by cb_intersection_element_removed(), and handle_alices_cryptodata_message().

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 AliceCryptodataMessage *  msg  )

static

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

Parameters

cls	the struct BobServiceSession *
msg	the actual message

Returns

GNUNET_OK to keep the connection open, GNUNET_SYSERR to close it (signal serious error)

Definition at line 811 of file gnunet-service-scalarproduct_bob.c.

{
  struct BobServiceSession *s = cls;
  uint32_t contained_elements;
  size_t msg_length;
  uint16_t msize;
  unsigned int max;
 
  msize = ntohs (msg->header.size);
  contained_elements = ntohl (msg->contained_element_count);
  /* Our intersection may still be ongoing, but this is nevertheless
     an upper bound on the required array size */
  max = GNUNET_CONTAINER_multihashmap_size (s->intersected_elements);
  msg_length = sizeof(struct AliceCryptodataMessage)
               + contained_elements * sizeof(struct
                                             GNUNET_CRYPTO_PaillierCiphertext);
  if ((msize != msg_length) ||
      (0 == contained_elements) ||
      (contained_elements > UINT16_MAX) ||
      (max < contained_elements + s->cadet_received_element_count))
  {
    GNUNET_break_op (0);
    return GNUNET_SYSERR;
  }
  return GNUNET_OK;
}

References BobServiceSession::cadet_received_element_count, GNUNET_break_op, GNUNET_CONTAINER_multihashmap_size(), GNUNET_OK, GNUNET_SYSERR, max, msg, BobServiceSession::s, and GNUNET_MessageHeader::size.

Here is the call graph for this function:

handle_alices_cryptodata_message()

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

static

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

Parameters

cls	the struct BobServiceSession *
msg	the actual message

Definition at line 848 of file gnunet-service-scalarproduct_bob.c.

{
  struct BobServiceSession *s = cls;
  const struct GNUNET_CRYPTO_PaillierCiphertext *payload;
  uint32_t contained_elements;
  unsigned int max;
 
  contained_elements = ntohl (msg->contained_element_count);
  /* Our intersection may still be ongoing, but this is nevertheless
     an upper bound on the required array size */
  max = GNUNET_CONTAINER_multihashmap_size (s->intersected_elements);
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Received %u crypto values from Alice\n",
              (unsigned int) contained_elements);
 
  payload = (const struct GNUNET_CRYPTO_PaillierCiphertext *) &msg[1];
  if (NULL == s->e_a)
    s->e_a = GNUNET_new_array (max,
                               struct GNUNET_CRYPTO_PaillierCiphertext);
  GNUNET_memcpy (&s->e_a[s->cadet_received_element_count],
                 payload,
                 sizeof(struct GNUNET_CRYPTO_PaillierCiphertext)
                 * contained_elements);
  s->cadet_received_element_count += contained_elements;
 
  if ((s->cadet_received_element_count == max) &&
      (NULL == s->intersection_op))
  {
    /* intersection has finished also on our side, and
       we got the full set, so we can proceed with the
       CADET response(s) */
    transmit_cryptographic_reply (s);
  }
  GNUNET_CADET_receive_done (s->channel);
}

References BobServiceSession::cadet_received_element_count, BobServiceSession::channel, BobServiceSession::e_a, GNUNET_CADET_receive_done(), GNUNET_CONTAINER_multihashmap_size(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_memcpy, GNUNET_new_array, BobServiceSession::intersected_elements, BobServiceSession::intersection_op, max, msg, payload, BobServiceSession::s, and transmit_cryptographic_reply().

Here is the call graph for this function:

cb_intersection_element_removed()

static void cb_intersection_element_removed ( void *  cls, const struct GNUNET_SETI_Element *  element, uint64_t  current_size, enum GNUNET_SETI_Status  status  )

static

Callback for set operation results.

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

Parameters

cls	closure with the struct BobServiceSession
element	a result element, only valid if status is #GNUNET_SETI_STATUS_OK
current_size	current set size
status	what has happened with the set intersection?

Definition at line 896 of file gnunet-service-scalarproduct_bob.c.

{
  struct BobServiceSession *s = cls;
  struct GNUNET_SCALARPRODUCT_Element *se;
 
  switch (status)
  {
  case GNUNET_SETI_STATUS_DEL_LOCAL:
    /* this element has been removed from the set */
    se = GNUNET_CONTAINER_multihashmap_get (s->intersected_elements,
                                            element->data);
    GNUNET_assert (NULL != se);
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "Removed element with key %s and value %lld\n",
         GNUNET_h2s (&se->key),
         (long long) GNUNET_ntohll (se->value));
    GNUNET_assert (GNUNET_YES ==
                   GNUNET_CONTAINER_multihashmap_remove (
                     s->intersected_elements,
                     element->data,
                     se));
    GNUNET_free (se);
    return;
  case GNUNET_SETI_STATUS_DONE:
    s->intersection_op = NULL;
    GNUNET_break (NULL == s->intersection_set);
    GNUNET_CADET_receive_done (s->channel);
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "Finished intersection, %d items remain\n",
         GNUNET_CONTAINER_multihashmap_size (s->intersected_elements));
    if (s->client_received_element_count ==
        GNUNET_CONTAINER_multihashmap_size (s->intersected_elements))
    {
      /* CADET transmission from Alice is also already done,
         start with our own reply */
      transmit_cryptographic_reply (s);
    }
    return;
  case GNUNET_SETI_STATUS_FAILURE:
    /* unhandled status code */
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "Set intersection failed!\n");
    s->intersection_op = NULL;
    if (NULL != s->intersection_set)
    {
      GNUNET_SETI_destroy (s->intersection_set);
      s->intersection_set = NULL;
    }
    s->status = GNUNET_SCALARPRODUCT_STATUS_FAILURE;
    prepare_client_end_notification (s);
    return;
  default:
    GNUNET_break (0);
    return;
  }
}

References BobServiceSession::channel, BobServiceSession::client_received_element_count, GNUNET_SETI_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_SETI_destroy(), GNUNET_SETI_STATUS_DEL_LOCAL, GNUNET_SETI_STATUS_DONE, GNUNET_SETI_STATUS_FAILURE, GNUNET_YES, BobServiceSession::intersected_elements, BobServiceSession::intersection_op, BobServiceSession::intersection_set, GNUNET_SCALARPRODUCT_Element::key, LOG, prepare_client_end_notification(), BobServiceSession::s, BobServiceSession::status, status, transmit_cryptographic_reply(), and GNUNET_SCALARPRODUCT_Element::value.

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

s	client session to start intersection for

Definition at line 964 of file gnunet-service-scalarproduct_bob.c.

{
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Got session with key %s and %u elements, starting intersection.\n",
              GNUNET_h2s (&s->session_id),
              (unsigned int) s->total);
 
  s->intersection_op
    = GNUNET_SETI_prepare (&s->peer,
                           &s->session_id,
                           NULL,
                           (struct GNUNET_SETI_Option[]) { { 0 } },
                           &cb_intersection_element_removed,
                           s);
  if (GNUNET_OK !=
      GNUNET_SETI_commit (s->intersection_op,
                          s->intersection_set))
  {
    GNUNET_break (0);
    s->status = GNUNET_SCALARPRODUCT_STATUS_FAILURE;
    prepare_client_end_notification (s);
    return;
  }
  GNUNET_SETI_destroy (s->intersection_set);
  s->intersection_set = NULL;
}

References GNUNET_ERROR_TYPE_DEBUG, GNUNET_h2s(), GNUNET_log, GNUNET_SETI_prepare(), BobServiceSession::intersection_op, BobServiceSession::peer, BobServiceSession::session_id, and BobServiceSession::total.

Referenced by handle_alices_computation_request(), and handle_bob_client_message_multipart().

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 ServiceRequestMessage *  msg  )

static

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

Parameters

cls	the struct BobServiceSession *
msg	the actual message

Definition at line 999 of file gnunet-service-scalarproduct_bob.c.

{
  struct BobServiceSession *s = cls;
 
  s->session_id = msg->session_id; // ??
  s->remote_pubkey = msg->public_key;
  if (s->client_received_element_count == s->total)
    start_intersection (s);
}

References msg, BobServiceSession::s, and start_intersection().

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

cls	closure with the struct BobServiceSession
channel	new handle to the channel
initiator	peer that started the channel

Returns

session associated with the channel

Definition at line 1022 of file gnunet-service-scalarproduct_bob.c.

{
  struct BobServiceSession *s = cls;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "New incoming channel from peer %s.\n",
              GNUNET_i2s (initiator));
  GNUNET_CADET_close_port (s->port);
  s->port = NULL;
  s->channel = channel;
  s->peer = *initiator;
  s->cadet_mq = GNUNET_CADET_get_mq (s->channel);
  return s;
}

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

Referenced by handle_bob_client_message().

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

cls	identification of the client
msg	the actual message

Returns

GNUNET_OK if msg is well-formed

Definition at line 1048 of file gnunet-service-scalarproduct_bob.c.

{
  struct BobServiceSession *s = cls;
  uint32_t contained_count;
  uint16_t msize;
 
  msize = ntohs (msg->header.size);
  contained_count = ntohl (msg->element_count_contained);
  if ((msize != (sizeof(struct ComputationBobCryptodataMultipartMessage)
                 + contained_count * sizeof(struct
                                            GNUNET_SCALARPRODUCT_Element))) ||
      (0 == contained_count) ||
      (UINT16_MAX < contained_count) ||
      (s->total == s->client_received_element_count) ||
      (s->total < s->client_received_element_count + contained_count))
  {
    GNUNET_break (0);
    return GNUNET_SYSERR;
  }
  return GNUNET_OK;
}

References GNUNET_break, GNUNET_OK, GNUNET_SYSERR, msg, BobServiceSession::s, and GNUNET_MessageHeader::size.

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

cls	identification of the client
msg	the actual message

Definition at line 1082 of file gnunet-service-scalarproduct_bob.c.

{
  struct BobServiceSession *s = cls;
  uint32_t contained_count;
  const struct GNUNET_SCALARPRODUCT_Element *elements;
  struct GNUNET_SETI_Element set_elem;
  struct GNUNET_SCALARPRODUCT_Element *elem;
 
  contained_count = ntohl (msg->element_count_contained);
  elements = (const struct GNUNET_SCALARPRODUCT_Element *) &msg[1];
  for (uint32_t i = 0; i < contained_count; i++)
  {
    elem = GNUNET_new (struct GNUNET_SCALARPRODUCT_Element);
    GNUNET_memcpy (elem,
                   &elements[i],
                   sizeof(struct GNUNET_SCALARPRODUCT_Element));
    if (GNUNET_SYSERR ==
        GNUNET_CONTAINER_multihashmap_put (s->intersected_elements,
                                           &elem->key,
                                           elem,
                                           GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY))
    {
      GNUNET_break (0);
      GNUNET_free (elem);
      continue;
    }
    set_elem.data = &elem->key;
    set_elem.size = sizeof(elem->key);
    set_elem.element_type = 0;
    GNUNET_SETI_add_element (s->intersection_set,
                             &set_elem,
                             NULL, NULL);
  }
  s->client_received_element_count += contained_count;
  GNUNET_SERVICE_client_continue (s->client);
  if (s->total != s->client_received_element_count)
  {
    /* more to come */
    return;
  }
  if (NULL == s->channel)
  {
    /* no Alice waiting for this request, wait for Alice */
    return;
  }
  start_intersection (s);
}

References BobServiceSession::channel, BobServiceSession::client, BobServiceSession::client_received_element_count, GNUNET_SETI_Element::data, GNUNET_SETI_Element::element_type, GNUNET_break, GNUNET_CONTAINER_multihashmap_put(), GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY, GNUNET_free, GNUNET_memcpy, GNUNET_new, GNUNET_SERVICE_client_continue(), GNUNET_SETI_add_element(), GNUNET_SYSERR, BobServiceSession::intersected_elements, BobServiceSession::intersection_set, GNUNET_SCALARPRODUCT_Element::key, msg, BobServiceSession::s, GNUNET_SETI_Element::size, start_intersection(), and BobServiceSession::total.

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

cls	identification of the client
msg	the actual message

Returns

GNUNET_OK if msg is well-formed

Definition at line 1143 of file gnunet-service-scalarproduct_bob.c.

{
  struct BobServiceSession *s = cls;
  uint32_t contained_count;
  uint32_t total_count;
  uint16_t msize;
 
  if (GNUNET_SCALARPRODUCT_STATUS_INIT != s->status)
  {
    GNUNET_break (0);
    return GNUNET_SYSERR;
  }
  msize = ntohs (msg->header.size);
  total_count = ntohl (msg->element_count_total);
  contained_count = ntohl (msg->element_count_contained);
  if ((0 == total_count) ||
      (0 == contained_count) ||
      (UINT16_MAX < contained_count) ||
      (msize != (sizeof(struct BobComputationMessage)
                 + contained_count * sizeof(struct
                                            GNUNET_SCALARPRODUCT_Element))))
  {
    GNUNET_break_op (0);
    return GNUNET_SYSERR;
  }
  return GNUNET_OK;
}

References GNUNET_break, GNUNET_break_op, GNUNET_OK, GNUNET_SCALARPRODUCT_STATUS_INIT, GNUNET_SYSERR, msg, BobServiceSession::s, and GNUNET_MessageHeader::size.

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

cls	identification of the client
msg	the actual message

Definition at line 1182 of file gnunet-service-scalarproduct_bob.c.

{
  struct BobServiceSession *s = cls;
  struct GNUNET_MQ_MessageHandler cadet_handlers[] = {
    GNUNET_MQ_hd_fixed_size (alices_computation_request,
                             GNUNET_MESSAGE_TYPE_SCALARPRODUCT_SESSION_INITIALIZATION,
                             struct ServiceRequestMessage,
                             NULL),
    GNUNET_MQ_hd_var_size (alices_cryptodata_message,
                           GNUNET_MESSAGE_TYPE_SCALARPRODUCT_ALICE_CRYPTODATA,
                           struct AliceCryptodataMessage,
                           NULL),
    GNUNET_MQ_handler_end ()
  };
  uint32_t contained_count;
  uint32_t total_count;
  const struct GNUNET_SCALARPRODUCT_Element *elements;
  struct GNUNET_SETI_Element set_elem;
  struct GNUNET_SCALARPRODUCT_Element *elem;
 
  total_count = ntohl (msg->element_count_total);
  contained_count = ntohl (msg->element_count_contained);
 
  s->status = GNUNET_SCALARPRODUCT_STATUS_ACTIVE;
  s->total = total_count;
  s->client_received_element_count = contained_count;
  s->session_id = msg->session_key;
  elements = (const struct GNUNET_SCALARPRODUCT_Element *) &msg[1];
  s->intersected_elements
    = GNUNET_CONTAINER_multihashmap_create (s->total,
                                            GNUNET_YES);
  s->intersection_set = GNUNET_SETI_create (cfg);
  for (uint32_t i = 0; i < contained_count; i++)
  {
    if (0 == GNUNET_ntohll (elements[i].value))
      continue;
    elem = GNUNET_new (struct GNUNET_SCALARPRODUCT_Element);
    GNUNET_memcpy (elem,
                   &elements[i],
                   sizeof(struct GNUNET_SCALARPRODUCT_Element));
    if (GNUNET_SYSERR ==
        GNUNET_CONTAINER_multihashmap_put (s->intersected_elements,
                                           &elem->key,
                                           elem,
                                           GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY))
    {
      GNUNET_break (0);
      GNUNET_free (elem);
      continue;
    }
    set_elem.data = &elem->key;
    set_elem.size = sizeof(elem->key);
    set_elem.element_type = 0;
    GNUNET_SETI_add_element (s->intersection_set,
                             &set_elem,
                             NULL, NULL);
    s->used_element_count++;
  }
  GNUNET_SERVICE_client_continue (s->client);
  /* We're ready, open the port */
  s->port = GNUNET_CADET_open_port (my_cadet,
                                    &msg->session_key,
                                    &cb_channel_incoming,
                                    s,
                                    NULL,
                                    &cb_channel_destruction,
                                    cadet_handlers);
  if (NULL == s->port)
  {
    GNUNET_break (0);
    GNUNET_SERVICE_client_drop (s->client);
    return;
  }
}

References cb_channel_destruction(), cb_channel_incoming(), cfg, BobServiceSession::client, BobServiceSession::client_received_element_count, GNUNET_SETI_Element::data, GNUNET_SETI_Element::element_type, GNUNET_break, GNUNET_CADET_open_port(), GNUNET_CONTAINER_multihashmap_create(), GNUNET_CONTAINER_multihashmap_put(), GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY, GNUNET_free, GNUNET_memcpy, GNUNET_MESSAGE_TYPE_SCALARPRODUCT_ALICE_CRYPTODATA, GNUNET_MESSAGE_TYPE_SCALARPRODUCT_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_SETI_add_element(), GNUNET_SETI_create(), GNUNET_SYSERR, GNUNET_YES, BobServiceSession::intersected_elements, BobServiceSession::intersection_set, GNUNET_SCALARPRODUCT_Element::key, msg, my_cadet, BobServiceSession::port, BobServiceSession::s, BobServiceSession::session_id, GNUNET_SETI_Element::size, BobServiceSession::status, BobServiceSession::total, BobServiceSession::used_element_count, and value.

Here is the call graph for this function:

shutdown_task()

static void shutdown_task ( void *  cls )

static

Task run during shutdown.

Parameters

cls

unused

Definition at line 1265 of file gnunet-service-scalarproduct_bob.c.

{
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Shutting down, initiating cleanup.\n");
  // FIXME: we have to cut our connections to CADET first!
  if (NULL != my_cadet)
  {
    GNUNET_CADET_disconnect (my_cadet);
    my_cadet = NULL;
  }
}

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

Referenced by run().

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

cls	closure, NULL
client	identification of the client
mq	message queue to communicate with client

Returns

our struct BobServiceSession

Definition at line 1289 of file gnunet-service-scalarproduct_bob.c.

{
  struct BobServiceSession *s;
 
  s = GNUNET_new (struct BobServiceSession);
  s->client = client;
  s->client_mq = mq;
  return s;
}

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

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

cls	closure, NULL
client	identification of the client
app_cls	our struct BobServiceSession

Definition at line 1313 of file gnunet-service-scalarproduct_bob.c.

{
  struct BobServiceSession *s = app_cls;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Client disconnected from us.\n");
  s->client = NULL;
  destroy_service_session (s);
}

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

Here is the call 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

cls	closure
c	configuration to use
service	the initialized service

Definition at line 1334 of file gnunet-service-scalarproduct_bob.c.

{
  cfg = c;
  /*
     offset has to be sufficiently small to allow computation of:
     m1+m2 mod n == (S + a) + (S + b) mod n,
     if we have more complex operations, this factor needs to be lowered */
  my_offset = gcry_mpi_new (GNUNET_CRYPTO_PAILLIER_BITS / 3);
  gcry_mpi_set_bit (my_offset,
                    GNUNET_CRYPTO_PAILLIER_BITS / 3);
 
  GNUNET_CRYPTO_paillier_create (&my_pubkey,
                                 &my_privkey);
  my_cadet = GNUNET_CADET_connect (cfg);
  GNUNET_SCHEDULER_add_shutdown (&shutdown_task,
                                 NULL);
  if (NULL == my_cadet)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                _ ("Connect to CADET failed\n"));
    GNUNET_SCHEDULER_shutdown ();
    return;
  }
}

References _, cfg, GNUNET_CADET_connect(), GNUNET_CRYPTO_PAILLIER_BITS, GNUNET_CRYPTO_paillier_create(), GNUNET_ERROR_TYPE_ERROR, GNUNET_log, GNUNET_SCHEDULER_add_shutdown(), GNUNET_SCHEDULER_shutdown(), my_cadet, my_offset, my_privkey, my_pubkey, and shutdown_task().

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.

Variable Documentation

cfg

const struct GNUNET_CONFIGURATION_Handle* cfg

static

GNUnet configuration handle.

Definition at line 208 of file gnunet-service-scalarproduct_bob.c.

Referenced by handle_bob_client_message(), and run().

my_pubkey

struct GNUNET_CRYPTO_PaillierPublicKey my_pubkey

static

Service's own public key.

Definition at line 208 of file gnunet-service-scalarproduct_bob.c.

Referenced by run().

my_privkey

struct GNUNET_CRYPTO_PaillierPrivateKey my_privkey

static

Service's own private key.

Definition at line 208 of file gnunet-service-scalarproduct_bob.c.

Referenced by run().

my_offset

gcry_mpi_t my_offset

static

Service's offset for values that could possibly be negative but are plaintext for encryption.

Definition at line 223 of file gnunet-service-scalarproduct_bob.c.

Referenced by compute_service_response(), and run().

my_cadet

struct GNUNET_CADET_Handle* my_cadet

static

Handle to the CADET service.

Definition at line 228 of file gnunet-service-scalarproduct_bob.c.

Referenced by handle_bob_client_message(), run(), and shutdown_task().