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_seti_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_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 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_Handle *	cfg
	GNUnet configuration handle. More...
static struct GNUNET_CADET_Handle *	my_cadet
	Handle to the CADET service. More...
static struct GNUNET_CRYPTO_EccDlogContext *	edc
	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__)

Definition at line 39 of file gnunet-service-scalarproduct-ecc_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 197 of file gnunet-service-scalarproduct-ecc_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

s	the session to free elements from

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

{
  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->sorted_elements)
  {
    GNUNET_free (s->sorted_elements);
    s->sorted_elements = 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, 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, and BobServiceSession::sorted_elements.

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 271 of file gnunet-service-scalarproduct-ecc_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 302 of file gnunet-service-scalarproduct-ecc_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));
  s->channel = NULL;
  if (GNUNET_SCALARPRODUCT_STATUS_ACTIVE == s->status)
  {
    s->status = GNUNET_SCALARPRODUCT_STATUS_FAILURE;
    prepare_client_end_notification (s);
  }
  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 326 of file gnunet-service-scalarproduct-ecc_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().

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

s	the associated requesting session with Alice

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

{
  struct EccBobCryptodataMessage *msg;
  struct GNUNET_MQ_Envelope *e;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Sending response to Alice\n");
  e = GNUNET_MQ_msg (msg,
                     GNUNET_MESSAGE_TYPE_SCALARPRODUCT_ECC_BOB_CRYPTODATA);
  msg->contained_element_count = htonl (2);
  msg->prod_g_i_b_i = s->prod_g_i_b_i;
  msg->prod_h_i_b_i = s->prod_h_i_b_i;
  GNUNET_MQ_notify_sent (e,
                         &bob_cadet_done_cb,
                         s);
  GNUNET_MQ_send (s->cadet_mq,
                  e);
}

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

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:

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 AliceServiceSession *
key	the key (unused)
value	the struct GNUNET_SCALARPRODUCT_Element *

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

{
  struct BobServiceSession *s = cls;
  struct GNUNET_SCALARPRODUCT_Element *e = value;
 
  s->sorted_elements[s->used_element_count].value = (int64_t) GNUNET_ntohll (
    e->value);
  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 handle_alices_cryptodata_message().

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 394 of file gnunet-service-scalarproduct-ecc_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 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 EccAliceCryptodataMessage *  msg  )

static

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

Parameters

cls	closure (set from GNUNET_CADET_connect)
msg	the actual message

Returns

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

Definition at line 415 of file gnunet-service-scalarproduct-ecc_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);
  if (msize <= sizeof(struct EccAliceCryptodataMessage))
  {
    GNUNET_break_op (0);
    return GNUNET_SYSERR;
  }
  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 EccAliceCryptodataMessage)
               + contained_elements * sizeof(struct GNUNET_CRYPTO_EccPoint) * 2;
  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 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 EccAliceCryptodataMessage *  msg  )

static

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

Parameters

cls	closure (set from GNUNET_CADET_connect)
msg	the actual message

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

{
  struct BobServiceSession *s = cls;
  const struct GNUNET_CRYPTO_EccPoint *payload;
  uint32_t contained_elements;
  unsigned int max;
  const struct GNUNET_CRYPTO_EccPoint *g_i;
  const struct GNUNET_CRYPTO_EccPoint *h_i;
  struct GNUNET_CRYPTO_EccPoint g_i_b_i;
  struct GNUNET_CRYPTO_EccPoint h_i_b_i;
 
  contained_elements = ntohl (msg->contained_element_count);
  max = GNUNET_CONTAINER_multihashmap_size (s->intersected_elements);
  /* sort our vector for the computation */
  if (NULL == s->sorted_elements)
  {
    s->sorted_elements
      = GNUNET_new_array (GNUNET_CONTAINER_multihashmap_size (
                            s->intersected_elements),
                          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);
  }
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Received %u crypto values from Alice\n",
              (unsigned int) contained_elements);
  payload = (const struct GNUNET_CRYPTO_EccPoint *) &msg[1];
 
  for (unsigned int i = 0; i < contained_elements; i++)
  {
    int64_t val = s->sorted_elements[i + s->cadet_received_element_count].value;
    struct GNUNET_CRYPTO_EccScalar vali;
 
    GNUNET_assert (INT64_MIN != val);
    GNUNET_CRYPTO_ecc_scalar_from_int (val > 0 ? val : -val,
                                       &vali);
    if (val < 0)
      crypto_core_ed25519_scalar_negate (vali.v,
                                         vali.v);
    g_i = &payload[i * 2];
    /* g_i_b_i = g_i^vali */
    GNUNET_assert (GNUNET_OK ==
                   GNUNET_CRYPTO_ecc_pmul_mpi (g_i,
                                               &vali,
                                               &g_i_b_i));
    h_i = &payload[i * 2 + 1];
    /* h_i_b_i = h_i^vali */
    GNUNET_assert (GNUNET_OK ==
                   GNUNET_CRYPTO_ecc_pmul_mpi (h_i,
                                               &vali,
                                               &h_i_b_i));
    if (0 == i + s->cadet_received_element_count)
    {
      /* first iteration, nothing to add */
      s->prod_g_i_b_i = g_i_b_i;
      s->prod_h_i_b_i = h_i_b_i;
    }
    else
    {
      /* further iterations, cummulate resulting value */
      GNUNET_assert (GNUNET_OK ==
                     GNUNET_CRYPTO_ecc_add (&s->prod_g_i_b_i,
                                            &g_i_b_i,
                                            &s->prod_g_i_b_i));
      GNUNET_assert (GNUNET_OK ==
                     GNUNET_CRYPTO_ecc_add (&s->prod_h_i_b_i,
                                            &h_i_b_i,
                                            &s->prod_h_i_b_i));
    }
  }
  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_bobs_cryptodata_message (s);
  }
  GNUNET_CADET_receive_done (s->channel);
}

References BobServiceSession::cadet_received_element_count, BobServiceSession::channel, copy_element_cb(), element_cmp(), GNUNET_assert, GNUNET_CADET_receive_done(), GNUNET_CONTAINER_multihashmap_iterate(), GNUNET_CONTAINER_multihashmap_size(), GNUNET_CRYPTO_ecc_add(), GNUNET_CRYPTO_ecc_pmul_mpi(), GNUNET_CRYPTO_ecc_scalar_from_int(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_new_array, GNUNET_OK, BobServiceSession::intersected_elements, BobServiceSession::intersection_op, max, msg, 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, GNUNET_CRYPTO_EccScalar::v, and MpiElement::value.

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 557 of file gnunet-service-scalarproduct-ecc_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_bobs_cryptodata_message (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_bobs_cryptodata_message(), 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 626 of file gnunet-service-scalarproduct-ecc_bob.c.

{
  struct GNUNET_HashCode set_sid;
 
  GNUNET_CRYPTO_hash (&s->session_id,
                      sizeof(struct GNUNET_HashCode),
                      &set_sid);
  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,
                           &set_sid,
                           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_CRYPTO_hash(), 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 EccServiceRequestMessage *  msg  )

static

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

Parameters

cls	closure (set from GNUNET_CADET_connect)
msg	the actual message

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

{
  struct BobServiceSession *s = cls;
 
  s->session_id = msg->session_id; // ??
  if (s->client_received_element_count < s->total)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Alice ready, still waiting for Bob client data!\n");
    return;
  }
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Both ready, launching intersection!\n");
  start_intersection (s);
}

References GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, 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	our struct BobServiceSession
channel	new handle to the channel
initiator	peer that started the channel

Returns

session associated with the channel

Definition at line 695 of file gnunet-service-scalarproduct-ecc_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->peer = *initiator;
  s->channel = channel;
  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 721 of file gnunet-service-scalarproduct-ecc_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 754 of file gnunet-service-scalarproduct-ecc_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 */
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Request still partial, waiting for more client data!\n");
    return;
  }
  if (NULL == s->channel)
  {
    /* no Alice waiting for this request, wait for Alice */
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Client ready, still waiting for Alice!\n");
    return;
  }
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Both ready, launching intersection!\n");
  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_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_log, 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 820 of file gnunet-service-scalarproduct-ecc_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 859 of file gnunet-service-scalarproduct-ecc_bob.c.

{
  struct BobServiceSession *s = cls;
  struct GNUNET_MQ_MessageHandler cadet_handlers[] = {
    GNUNET_MQ_hd_fixed_size (alices_computation_request,
                             GNUNET_MESSAGE_TYPE_SCALARPRODUCT_ECC_SESSION_INITIALIZATION,
                             struct EccServiceRequestMessage,
                             s),
    GNUNET_MQ_hd_var_size (alices_cryptodata_message,
                           GNUNET_MESSAGE_TYPE_SCALARPRODUCT_ECC_ALICE_CRYPTODATA,
                           struct EccAliceCryptodataMessage,
                           s),
    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);
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Received client request, opening port %s!\n",
              GNUNET_h2s (&msg->session_key));
  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_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_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 944 of file gnunet-service-scalarproduct-ecc_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;
  }
  if (NULL != edc)
  {
    GNUNET_CRYPTO_ecc_dlog_release (edc);
    edc = NULL;
  }
}

References edc, GNUNET_CADET_disconnect(), GNUNET_CRYPTO_ecc_dlog_release(), 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 973 of file gnunet-service-scalarproduct-ecc_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 997 of file gnunet-service-scalarproduct-ecc_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 1018 of file gnunet-service-scalarproduct-ecc_bob.c.

{
  cfg = c;
  /* We don't really do DLOG, so we can setup with very minimal resources */
  edc = GNUNET_CRYPTO_ecc_dlog_prepare (4 /* max value */,
                                        2 /* RAM */);
  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, edc, GNUNET_CADET_connect(), GNUNET_CRYPTO_ecc_dlog_prepare(), GNUNET_ERROR_TYPE_ERROR, GNUNET_log, GNUNET_SCHEDULER_add_shutdown(), GNUNET_SCHEDULER_shutdown(), my_cadet, 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 176 of file gnunet-service-scalarproduct-ecc_bob.c.

Referenced by handle_bob_client_message(), and run().

my_cadet

struct GNUNET_CADET_Handle* my_cadet

static

Handle to the CADET service.

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

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

edc

struct GNUNET_CRYPTO_EccDlogContext* edc

static

Context for DLOG operations on a curve.

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

Referenced by run(), and shutdown_task().