gnunet-service-scalarproduct-ecc_alice.c File Reference

scalarproduct service implementation More...

#include "platform.h"
#include <limits.h>
#include <gcrypt.h>
#include "gnunet_util_lib.h"
#include "gnunet_cadet_service.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 "gnunet_constants.h"

Include dependency graph for gnunet-service-scalarproduct-ecc_alice.c:

Go to the source code of this file.

Data Structures
struct	MpiElement
	An encrypted element key-value pair. More...
struct	AliceServiceSession
	A scalarproduct session which tracks a request form the client to our final response. More...

Macros
#define	LOG(kind, ...)    GNUNET_log_from (kind, "scalarproduct-alice", __VA_ARGS__)
#define	MAX_RESULT   (1024 * 1024)
	Maximum allowed result value for the scalarproduct computation.
#define	MAX_RAM   (1024)
	How many values should DLOG store in memory (determines baseline RAM consumption, roughly 100 bytes times the value given here).
#define	ELEMENT_CAPACITY
	Maximum number of elements we can put into a single cryptodata message.

Functions
static int	free_element_cb (void *cls, const struct GNUNET_HashCode *key, void *value)
	Iterator called to free elements.
static void	destroy_service_session (struct AliceServiceSession *s)
	Destroy session state, we are done with it.
static void	prepare_client_end_notification (struct AliceServiceSession *session)
	Notify the client that the session has failed.
static void	transmit_client_response (struct AliceServiceSession *s)
	Prepare the final (positive) response we will send to Alice's client.
static void	cb_channel_destruction (void *cls, const struct GNUNET_CADET_Channel *channel)
	Function called whenever a channel is destroyed.
static void	handle_bobs_cryptodata_message (void *cls, const struct EccBobCryptodataMessage *msg)
	Handle a response we got from another service we wanted to calculate a scalarproduct with.
static int	copy_element_cb (void *cls, const struct GNUNET_HashCode *key, void *value)
	Iterator to copy over messages from the hash map into an array for sorting.
static int	element_cmp (const void *a, const void *b)
	Compare two struct MpiValues by key for sorting.
static void	send_alices_cryptodata_message (struct AliceServiceSession *s)
	Send the cryptographic data from Alice to Bob.
static void	cb_intersection_element_removed (void *cls, const struct GNUNET_SETI_Element *element, uint64_t current_size, enum GNUNET_SETI_Status status)
	Callback for set operation results.
static void	cb_intersection_request_alice (void *cls, const struct GNUNET_PeerIdentity *other_peer, const struct GNUNET_MessageHeader *context_msg, struct GNUNET_SETI_Request *request)
	Called when another peer wants to do a set operation with the local peer.
static void	client_request_complete_alice (struct AliceServiceSession *s)
	Our client has finished sending us its multipart message.
static int	check_alice_client_message_multipart (void *cls, const struct ComputationBobCryptodataMultipartMessage *msg)
	We're receiving additional set data.
static void	handle_alice_client_message_multipart (void *cls, const struct ComputationBobCryptodataMultipartMessage *msg)
	We're receiving additional set data.
static int	check_alice_client_message (void *cls, const struct AliceComputationMessage *msg)
	Handler for Alice's client request message.
static void	handle_alice_client_message (void *cls, const struct AliceComputationMessage *msg)
	Handler for Alice's client request message.
static void	shutdown_task (void *cls)
	Task run during shutdown.
static void *	client_connect_cb (void *cls, struct GNUNET_SERVICE_Client *client, struct GNUNET_MQ_Handle *mq)
	A client connected.
static void	client_disconnect_cb (void *cls, struct GNUNET_SERVICE_Client *client, void *app_cls)
	A client disconnected.
static void	run (void *cls, const struct GNUNET_CONFIGURATION_Handle *c, struct GNUNET_SERVICE_Handle *service)
	Initialization of the program and message handlers.
	GNUNET_SERVICE_MAIN (GNUNET_OS_project_data_gnunet(), "scalarproduct-alice", GNUNET_SERVICE_OPTION_NONE, &run, &client_connect_cb, &client_disconnect_cb, NULL, GNUNET_MQ_hd_var_size(alice_client_message, GNUNET_MESSAGE_TYPE_SCALARPRODUCT_CLIENT_TO_ALICE, struct AliceComputationMessage, NULL), GNUNET_MQ_hd_var_size(alice_client_message_multipart, GNUNET_MESSAGE_TYPE_SCALARPRODUCT_CLIENT_MULTIPART_ALICE, struct ComputationBobCryptodataMultipartMessage, NULL), GNUNET_MQ_handler_end())
	Define "main" method using service macro.

Variables
static const struct GNUNET_CONFIGURATION_Handle *	cfg
	GNUnet configuration handle.
static struct GNUNET_CRYPTO_EccDlogContext *	edc
	Context for DLOG operations on a curve.
static struct GNUNET_CRYPTO_EccScalar	my_privkey
	Alice's private key ('a').
static struct GNUNET_CRYPTO_EccScalar	my_privkey_inv
	Inverse of Alice's private key ('a_inv').
static struct GNUNET_CADET_Handle *	my_cadet
	Handle to the CADET service.

Detailed Description

scalarproduct service implementation

Author

Christian M. Fuchs

Christian Grothoff

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

Macro Definition Documentation

LOG

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

Definition at line 38 of file gnunet-service-scalarproduct-ecc_alice.c.

{
  const struct GNUNET_HashCode *key;
 
  int64_t value;
};
 
 
struct AliceServiceSession
{
  struct GNUNET_HashCode session_id;
 
  struct GNUNET_PeerIdentity peer;
 
  struct GNUNET_SERVICE_Client *client;
 
  struct GNUNET_MQ_Handle *client_mq;
 
  struct GNUNET_MQ_Handle *cadet_mq;
 
  struct GNUNET_CONTAINER_MultiHashMap *intersected_elements;
 
  struct GNUNET_SETI_Handle *intersection_set;
 
  struct GNUNET_SETI_OperationHandle *intersection_op;
 
  struct GNUNET_SETI_ListenHandle *intersection_listen;
 
  struct GNUNET_CADET_Channel *channel;
 
  struct MpiElement *sorted_elements;
 
  int product;
 
  uint32_t total;
 
  uint32_t used_element_count;
 
  uint32_t client_received_element_count;
 
  enum GNUNET_SCALARPRODUCT_ResponseStatus status;
 
  int in_destroy;
};
 
 
static const struct GNUNET_CONFIGURATION_Handle *cfg;
 
static struct GNUNET_CRYPTO_EccDlogContext *edc;
 
static struct GNUNET_CRYPTO_EccScalar my_privkey;
 
static struct GNUNET_CRYPTO_EccScalar my_privkey_inv;
 
static struct GNUNET_CADET_Handle *my_cadet;
 
 
static int
free_element_cb (void *cls,
                 const struct GNUNET_HashCode *key,
                 void *value)
{
  struct GNUNET_SCALARPRODUCT_Element *e = value;
 
  GNUNET_free (e);
  return GNUNET_OK;
}
 
 
static void
destroy_service_session (struct AliceServiceSession *s)
{
  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->channel)
  {
    GNUNET_CADET_channel_destroy (s->channel);
    s->channel = NULL;
  }
  if (NULL != s->intersected_elements)
  {
    GNUNET_CONTAINER_multihashmap_iterate (s->intersected_elements,
                                           &free_element_cb,
                                           s);
    GNUNET_CONTAINER_multihashmap_destroy (s->intersected_elements);
    s->intersected_elements = NULL;
  }
  if (NULL != s->intersection_listen)
  {
    GNUNET_SETI_listen_cancel (s->intersection_listen);
    s->intersection_listen = NULL;
  }
  if (NULL != s->intersection_op)
  {
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "Set intersection, op still ongoing!\n");
    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;
  }
  GNUNET_free (s);
}
 
 
static void
prepare_client_end_notification (struct AliceServiceSession *session)
{
  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->product_length = htonl (0);
  msg->status = htonl (session->status);
  GNUNET_MQ_send (session->client_mq,
                  e);
}
 
 
static void
transmit_client_response (struct AliceServiceSession *s)
{
  struct ClientResponseMessage *msg;
  struct GNUNET_MQ_Envelope *e;
  unsigned char *product_exported = NULL;
  size_t product_length = 0;
  int32_t range;
  gcry_error_t rc;
  gcry_mpi_t value;
 
  if (INT_MAX == s->product)
  {
    GNUNET_break (0);
    prepare_client_end_notification (s);
    return;
  }
  value = gcry_mpi_new (32);
  if (0 > s->product)
  {
    range = -1;
    gcry_mpi_set_ui (value,
                     -s->product);
  }
  else if (0 < s->product)
  {
    range = 1;
    gcry_mpi_set_ui (value,
                     s->product);
  }
  else
  {
    /* result is exactly zero */
    range = 0;
  }
  if ( (0 != range) &&
       (0 != (rc = gcry_mpi_aprint (GCRYMPI_FMT_STD,
                                    &product_exported,
                                    &product_length,
                                    value))))
  {
    LOG_GCRY (GNUNET_ERROR_TYPE_ERROR,
              "gcry_mpi_scan",
              rc);
    prepare_client_end_notification (s);
    return;
  }
  gcry_mpi_release (value);
  e = GNUNET_MQ_msg_extra (msg,
                           product_length,
                           GNUNET_MESSAGE_TYPE_SCALARPRODUCT_RESULT);
  msg->status = htonl (GNUNET_SCALARPRODUCT_STATUS_SUCCESS);
  msg->range = htonl (range);
  msg->product_length = htonl (product_length);
  if (NULL != product_exported)
  {
    GNUNET_memcpy (&msg[1],
                   product_exported,
                   product_length);
    GNUNET_free (product_exported);
  }
  GNUNET_MQ_send (s->client_mq,
                  e);
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Sent result to client, session %s has ended!\n",
              GNUNET_h2s (&s->session_id));
}
 
 
static void
cb_channel_destruction (void *cls,
                        const struct GNUNET_CADET_Channel *channel)
{
  struct AliceServiceSession *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)
  {
    /* We didn't get an answer yet, fail with error */
    s->status = GNUNET_SCALARPRODUCT_STATUS_FAILURE;
    prepare_client_end_notification (s);
  }
}
 
 
static void
handle_bobs_cryptodata_message (void *cls,
                                const struct EccBobCryptodataMessage *msg)
{
  struct AliceServiceSession *s = cls;
  uint32_t contained;
 
  contained = ntohl (msg->contained_element_count);
  if (2 != contained)
  {
    GNUNET_break_op (0);
    destroy_service_session (s);
    return;
  }
  if (NULL == s->sorted_elements)
  {
    /* we're not ready yet, how can Bob be? */
    GNUNET_break_op (0);
    destroy_service_session (s);
    return;
  }
  if (s->total != s->client_received_element_count)
  {
    /* we're not ready yet, how can Bob be? */
    GNUNET_break_op (0);
    destroy_service_session (s);
    return;
  }
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Received %u crypto values from Bob\n",
              (unsigned int) contained);
  GNUNET_CADET_receive_done (s->channel);
  {
    struct GNUNET_CRYPTO_EccPoint g_i_b_i_a_inv;
    struct GNUNET_CRYPTO_EccPoint g_ai_bi;
 
    GNUNET_assert (
      GNUNET_OK ==
      GNUNET_CRYPTO_ecc_pmul_mpi (&msg->prod_g_i_b_i,
                                  &my_privkey_inv,
                                  &g_i_b_i_a_inv));
    GNUNET_assert (
      GNUNET_OK ==
      GNUNET_CRYPTO_ecc_add (&g_i_b_i_a_inv,
                             &msg->prod_h_i_b_i,
                             &g_ai_bi));
    s->product = GNUNET_CRYPTO_ecc_dlog (edc,
                                         &g_ai_bi);
    if (INT_MAX == s->product)
    {
      /* result too big */
      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                  "Scalar product result out of range\n");
    }
  }
  transmit_client_response (s);
}
 
 
static int
copy_element_cb (void *cls,
                 const struct GNUNET_HashCode *key,
                 void *value)
{
  struct AliceServiceSession *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;
}
 
 
static int
element_cmp (const void *a,
             const void *b)
{
  const struct MpiElement *ma = a;
  const struct MpiElement *mb = b;
 
  return GNUNET_CRYPTO_hash_cmp (ma->key,
                                 mb->key);
}
 
 
#define ELEMENT_CAPACITY                          \
  ((GNUNET_CONSTANTS_MAX_CADET_MESSAGE_SIZE - 1   \
    - sizeof(struct EccAliceCryptodataMessage))    \
   / sizeof(struct GNUNET_CRYPTO_EccPoint))
 
 
static void
send_alices_cryptodata_message (struct AliceServiceSession *s)
{
  struct EccAliceCryptodataMessage *msg;
  struct GNUNET_MQ_Envelope *e;
  struct GNUNET_CRYPTO_EccPoint *payload;
  struct GNUNET_CRYPTO_EccScalar r_ia;
  struct GNUNET_CRYPTO_EccScalar r_ia_ai;
  unsigned int off;
  unsigned int todo_count;
 
  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);
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Finished intersection, %d items remain\n",
       s->used_element_count);
  qsort (s->sorted_elements,
         s->used_element_count,
         sizeof(struct MpiElement),
         &element_cmp);
  off = 0;
  while (off < s->used_element_count)
  {
    todo_count = s->used_element_count - off;
    if (todo_count > ELEMENT_CAPACITY)
      todo_count = ELEMENT_CAPACITY;
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Sending %u/%u crypto values to Bob\n",
                (unsigned int) todo_count,
                (unsigned int) s->used_element_count);
 
    e =
      GNUNET_MQ_msg_extra (msg,
                           todo_count * 2
                           * sizeof(struct GNUNET_CRYPTO_EccPoint),
                           GNUNET_MESSAGE_TYPE_SCALARPRODUCT_ECC_ALICE_CRYPTODATA);
    msg->contained_element_count = htonl (todo_count);
    payload = (struct GNUNET_CRYPTO_EccPoint *) &msg[1];
    for (unsigned int i = off; i < off + todo_count; i++)
    {
      struct GNUNET_CRYPTO_EccScalar r_i;
      struct GNUNET_CRYPTO_EccPoint g_i;
      struct GNUNET_CRYPTO_EccPoint h_i;
 
      /* r_i = random() mod n */
      GNUNET_CRYPTO_ecc_random_mod_n (&r_i);
      /* g_i = g^{r_i} */
      GNUNET_assert (GNUNET_OK ==
                     GNUNET_CRYPTO_ecc_dexp_mpi (&r_i,
                                                 &g_i));
      /* r_ia = r_i * a */
      crypto_core_ed25519_scalar_mul (r_ia.v,
                                      r_i.v,
                                      my_privkey.v);
      /* r_ia_ai = r_ia + a_i */
      {
        int64_t val = s->sorted_elements[i].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_add (r_ia_ai.v,
                                          r_ia.v,
                                          vali.v);
        else
          crypto_core_ed25519_scalar_sub (r_ia_ai.v,
                                          r_ia.v,
                                          vali.v);
      }
      /* h_i = g^{r_ia_ai} */
      GNUNET_assert (GNUNET_OK ==
                     GNUNET_CRYPTO_ecc_dexp_mpi (&r_ia_ai,
                                                 &h_i));
      memcpy (&payload[(i - off) * 2],
              &g_i,
              sizeof (g_i));
      memcpy (&payload[(i - off) * 2 + 1],
              &h_i,
              sizeof (h_i));
    }
    off += todo_count;
    GNUNET_MQ_send (s->cadet_mq,
                    e);
  }
}
 
 
static void
cb_intersection_element_removed (void *cls,
                                 const struct GNUNET_SETI_Element *element,
                                 uint64_t current_size,
                                 enum GNUNET_SETI_Status status)
{
  struct AliceServiceSession *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,
         "Intersection 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;
    if (NULL != s->intersection_set)
    {
      GNUNET_SETI_destroy (s->intersection_set);
      s->intersection_set = NULL;
    }
    send_alices_cryptodata_message (s);
    return;
  case GNUNET_SETI_STATUS_FAILURE:
    /* unhandled status code */
    LOG (GNUNET_ERROR_TYPE_DEBUG, "Set intersection failed!\n");
    if (NULL != s->intersection_listen)
    {
      GNUNET_SETI_listen_cancel (s->intersection_listen);
      s->intersection_listen = NULL;
    }
    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;
  }
}
 
 
static void
cb_intersection_request_alice (void *cls,
                               const struct GNUNET_PeerIdentity *other_peer,
                               const struct GNUNET_MessageHeader *context_msg,
                               struct GNUNET_SETI_Request *request)
{
  struct AliceServiceSession *s = cls;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Received intersection request from %s!\n",
              GNUNET_i2s (other_peer));
  if (0 != GNUNET_memcmp (other_peer,
                          &s->peer))
  {
    GNUNET_break_op (0);
    return;
  }
  s->intersection_op
    = GNUNET_SETI_accept (request,
                          (struct GNUNET_SETI_Option[]){ { 0 } },
                          &cb_intersection_element_removed,
                          s);
  if (NULL == s->intersection_op)
  {
    GNUNET_break (0);
    s->status = GNUNET_SCALARPRODUCT_STATUS_FAILURE;
    prepare_client_end_notification (s);
    return;
  }
  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;
  }
}
 
 
static void
client_request_complete_alice (struct AliceServiceSession *s)
{
  struct GNUNET_MQ_MessageHandler cadet_handlers[] = {
    GNUNET_MQ_hd_fixed_size (bobs_cryptodata_message,
                             GNUNET_MESSAGE_TYPE_SCALARPRODUCT_ECC_BOB_CRYPTODATA,
                             struct EccBobCryptodataMessage,
                             s),
    GNUNET_MQ_handler_end ()
  };
  struct EccServiceRequestMessage *msg;
  struct GNUNET_MQ_Envelope *e;
  struct GNUNET_HashCode set_sid;
 
  GNUNET_CRYPTO_hash (&s->session_id,
                      sizeof(struct GNUNET_HashCode),
                      &set_sid);
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Creating new channel for session with key %s.\n",
              GNUNET_h2s (&s->session_id));
  s->channel = GNUNET_CADET_channel_create (my_cadet,
                                            s,
                                            &s->peer,
                                            &s->session_id,
                                            NULL,
                                            &cb_channel_destruction,
                                            cadet_handlers);
  if (NULL == s->channel)
  {
    s->status = GNUNET_SCALARPRODUCT_STATUS_FAILURE;
    prepare_client_end_notification (s);
    return;
  }
  s->cadet_mq = GNUNET_CADET_get_mq (s->channel);
  s->intersection_listen = GNUNET_SETI_listen (cfg,
                                               &set_sid,
                                               &cb_intersection_request_alice,
                                               s);
  if (NULL == s->intersection_listen)
  {
    s->status = GNUNET_SCALARPRODUCT_STATUS_FAILURE;
    GNUNET_CADET_channel_destroy (s->channel);
    s->channel = NULL;
    prepare_client_end_notification (s);
    return;
  }
 
  e =
    GNUNET_MQ_msg (msg,
                   GNUNET_MESSAGE_TYPE_SCALARPRODUCT_ECC_SESSION_INITIALIZATION);
  GNUNET_MQ_env_set_options (e, GNUNET_MQ_PRIO_CRITICAL_CONTROL);
  msg->session_id = s->session_id;
  GNUNET_MQ_send (s->cadet_mq, e);
}
 
 
static int
check_alice_client_message_multipart (
  void *cls,
  const struct ComputationBobCryptodataMultipartMessage *msg)
{
  struct AliceServiceSession *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) ||
      (s->total == s->client_received_element_count) ||
      (s->total < s->client_received_element_count + contained_count))
  {
    GNUNET_break_op (0);
    return GNUNET_SYSERR;
  }
  return GNUNET_OK;
}
 
 
static void
handle_alice_client_message_multipart (
  void *cls,
  const struct ComputationBobCryptodataMultipartMessage *msg)
{
  struct AliceServiceSession *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);
  s->client_received_element_count += contained_count;
  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->used_element_count++;
  }
  GNUNET_SERVICE_client_continue (s->client);
  if (s->total != s->client_received_element_count)
  {
    /* more to come */
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Received client multipart data, waiting for more!\n");
    return;
  }
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Launching computation\n");
  client_request_complete_alice (s);
}
 
 
static int
check_alice_client_message (void *cls,
                            const struct AliceComputationMessage *msg)
{
  struct AliceServiceSession *s = cls;
  uint16_t msize;
  uint32_t total_count;
  uint32_t contained_count;
 
  if (NULL != s->intersected_elements)
  {
    /* only one concurrent session per client connection allowed,
       simplifies logic a lot... */
    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) ||
      (msize !=
       (sizeof(struct AliceComputationMessage)
        + contained_count * sizeof(struct GNUNET_SCALARPRODUCT_Element))))
  {
    GNUNET_break_op (0);
    return GNUNET_SYSERR;
  }
  return GNUNET_OK;
}
 
 
static void
handle_alice_client_message (void *cls,
                             const struct AliceComputationMessage *msg)
{
  struct AliceServiceSession *s = cls;
  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->peer = msg->peer;
  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);
    *elem = elements[i];
    if (GNUNET_SYSERR ==
        GNUNET_CONTAINER_multihashmap_put (
          s->intersected_elements,
          &elem->key,
          elem,
          GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY))
    {
      /* element with same key encountered twice! */
      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);
  if (s->total != s->client_received_element_count)
  {
    /* wait for multipart msg */
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Received partial client request, waiting for more!\n");
    return;
  }
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Launching computation\n");
  client_request_complete_alice (s);
}
 
 
static void
shutdown_task (void *cls)
{
  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;
  }
}
 
 
static void *
client_connect_cb (void *cls,
                   struct GNUNET_SERVICE_Client *client,
                   struct GNUNET_MQ_Handle *mq)
{
  struct AliceServiceSession *s;
 
  s = GNUNET_new (struct AliceServiceSession);
  s->client = client;
  s->client_mq = mq;
  return s;
}
 
 
static void
client_disconnect_cb (void *cls,
                      struct GNUNET_SERVICE_Client *client,
                      void *app_cls)
{
  struct AliceServiceSession *s = app_cls;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Client %p disconnected from us.\n",
              client);
  s->client = NULL;
  s->client_mq = NULL;
  destroy_service_session (s);
}
 
 
static void
run (void *cls,
     const struct GNUNET_CONFIGURATION_Handle *c,
     struct GNUNET_SERVICE_Handle *service)
{
  cfg = c;
  edc = GNUNET_CRYPTO_ecc_dlog_prepare (MAX_RESULT,
                                        MAX_RAM);
  /* Select a random 'a' value for Alice */
  GNUNET_CRYPTO_ecc_rnd_mpi (&my_privkey,
                             &my_privkey_inv);
  my_cadet = GNUNET_CADET_connect (cfg);
  if (NULL == my_cadet)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                _ ("Connect to CADET failed\n"));
    GNUNET_SCHEDULER_shutdown ();
    return;
  }
  GNUNET_SCHEDULER_add_shutdown (&shutdown_task,
                                 NULL);
}
 
 
GNUNET_SERVICE_MAIN (
  GNUNET_OS_project_data_gnunet(),
  "scalarproduct-alice",
  GNUNET_SERVICE_OPTION_NONE,
  &run,
  &client_connect_cb,
  &client_disconnect_cb,
  NULL,
  GNUNET_MQ_hd_var_size (alice_client_message,
                         GNUNET_MESSAGE_TYPE_SCALARPRODUCT_CLIENT_TO_ALICE,
                         struct AliceComputationMessage,
                         NULL),
  GNUNET_MQ_hd_var_size (
    alice_client_message_multipart,
    GNUNET_MESSAGE_TYPE_SCALARPRODUCT_CLIENT_MULTIPART_ALICE,
    struct ComputationBobCryptodataMultipartMessage,
    NULL),
  GNUNET_MQ_handler_end ());
 
 
/* end of gnunet-service-scalarproduct-ecc_alice.c */

MAX_RESULT

#define MAX_RESULT   (1024 * 1024)

Maximum allowed result value for the scalarproduct computation.

DLOG will fail if the result is bigger. At 1 million, the precomputation takes about 2s on a fast machine.

Definition at line 46 of file gnunet-service-scalarproduct-ecc_alice.c.

MAX_RAM

#define MAX_RAM   (1024)

How many values should DLOG store in memory (determines baseline RAM consumption, roughly 100 bytes times the value given here).

Should be about SQRT (MAX_RESULT), larger values will make the online computation faster.

Definition at line 54 of file gnunet-service-scalarproduct-ecc_alice.c.

ELEMENT_CAPACITY

#define ELEMENT_CAPACITY

Value:

  ((GNUNET_CONSTANTS_MAX_CADET_MESSAGE_SIZE - 1   \
    - sizeof(struct EccAliceCryptodataMessage))    \
   / sizeof(struct GNUNET_CRYPTO_EccPoint))

Maximum number of elements we can put into a single cryptodata message.

Definition at line 527 of file gnunet-service-scalarproduct-ecc_alice.c.

Function Documentation

free_element_cb()

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

static

Iterator called to free elements.

Parameters

cls	the struct AliceServiceSession * (unused)
key	the key (unused)
value	value to free

Returns

GNUNET_OK (continue to iterate)

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

{
  struct GNUNET_SCALARPRODUCT_Element *e = value;
 
  GNUNET_free (e);
  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 AliceServiceSession *  s )

static

Destroy session state, we are done with it.

Parameters

s	the session to free elements from

Definition at line 231 of file gnunet-service-scalarproduct-ecc_alice.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->channel)
  {
    GNUNET_CADET_channel_destroy (s->channel);
    s->channel = NULL;
  }
  if (NULL != s->intersected_elements)
  {
    GNUNET_CONTAINER_multihashmap_iterate (s->intersected_elements,
                                           &free_element_cb,
                                           s);
    GNUNET_CONTAINER_multihashmap_destroy (s->intersected_elements);
    s->intersected_elements = NULL;
  }
  if (NULL != s->intersection_listen)
  {
    GNUNET_SETI_listen_cancel (s->intersection_listen);
    s->intersection_listen = NULL;
  }
  if (NULL != s->intersection_op)
  {
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "Set intersection, op still ongoing!\n");
    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;
  }
  GNUNET_free (s);
}

References AliceServiceSession::channel, AliceServiceSession::client, free_element_cb(), GNUNET_CADET_channel_destroy(), GNUNET_CONTAINER_multihashmap_destroy(), GNUNET_CONTAINER_multihashmap_iterate(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_SERVICE_client_drop(), GNUNET_SETI_destroy(), GNUNET_SETI_listen_cancel(), GNUNET_SETI_operation_cancel(), GNUNET_YES, AliceServiceSession::in_destroy, AliceServiceSession::intersected_elements, AliceServiceSession::intersection_listen, AliceServiceSession::intersection_op, AliceServiceSession::intersection_set, LOG, and AliceServiceSession::sorted_elements.

Referenced by client_disconnect_cb(), and handle_bobs_cryptodata_message().

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 AliceServiceSession *  session )

static

Notify the client that the session has failed.

A message gets sent to Alice's client if we encountered any error.

Parameters

session

the associated client session to fail or succeed

Definition at line 289 of file gnunet-service-scalarproduct-ecc_alice.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->product_length = htonl (0);
  msg->status = htonl (session->status);
  GNUNET_MQ_send (session->client_mq,
                  e);
}

References AliceServiceSession::client_mq, GNUNET_ERROR_TYPE_DEBUG, GNUNET_h2s(), GNUNET_log, GNUNET_MESSAGE_TYPE_SCALARPRODUCT_RESULT, GNUNET_MQ_msg, GNUNET_MQ_send(), msg, AliceServiceSession::session_id, and AliceServiceSession::status.

Referenced by cb_channel_destruction(), cb_intersection_element_removed(), cb_intersection_request_alice(), client_request_complete_alice(), and transmit_client_response().

Here is the call graph for this function:

Here is the caller graph for this function:

transmit_client_response()

static void transmit_client_response ( struct AliceServiceSession *  s )

static

Prepare the final (positive) response we will send to Alice's client.

Parameters

s	the session associated with our client.

Definition at line 317 of file gnunet-service-scalarproduct-ecc_alice.c.

{
  struct ClientResponseMessage *msg;
  struct GNUNET_MQ_Envelope *e;
  unsigned char *product_exported = NULL;
  size_t product_length = 0;
  int32_t range;
  gcry_error_t rc;
  gcry_mpi_t value;
 
  if (INT_MAX == s->product)
  {
    GNUNET_break (0);
    prepare_client_end_notification (s);
    return;
  }
  value = gcry_mpi_new (32);
  if (0 > s->product)
  {
    range = -1;
    gcry_mpi_set_ui (value,
                     -s->product);
  }
  else if (0 < s->product)
  {
    range = 1;
    gcry_mpi_set_ui (value,
                     s->product);
  }
  else
  {
    /* result is exactly zero */
    range = 0;
  }
  if ( (0 != range) &&
       (0 != (rc = gcry_mpi_aprint (GCRYMPI_FMT_STD,
                                    &product_exported,
                                    &product_length,
                                    value))))
  {
    LOG_GCRY (GNUNET_ERROR_TYPE_ERROR,
              "gcry_mpi_scan",
              rc);
    prepare_client_end_notification (s);
    return;
  }
  gcry_mpi_release (value);
  e = GNUNET_MQ_msg_extra (msg,
                           product_length,
                           GNUNET_MESSAGE_TYPE_SCALARPRODUCT_RESULT);
  msg->status = htonl (GNUNET_SCALARPRODUCT_STATUS_SUCCESS);
  msg->range = htonl (range);
  msg->product_length = htonl (product_length);
  if (NULL != product_exported)
  {
    GNUNET_memcpy (&msg[1],
                   product_exported,
                   product_length);
    GNUNET_free (product_exported);
  }
  GNUNET_MQ_send (s->client_mq,
                  e);
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Sent result to client, session %s has ended!\n",
              GNUNET_h2s (&s->session_id));
}

References AliceServiceSession::client_mq, GNUNET_break, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_free, GNUNET_h2s(), GNUNET_log, GNUNET_memcpy, GNUNET_MESSAGE_TYPE_SCALARPRODUCT_RESULT, GNUNET_MQ_msg_extra, GNUNET_MQ_send(), GNUNET_SCALARPRODUCT_STATUS_SUCCESS, INT_MAX, LOG_GCRY, msg, prepare_client_end_notification(), AliceServiceSession::product, AliceServiceSession::session_id, and value.

Referenced by handle_bobs_cryptodata_message().

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 AliceServiceSession
channel	connection to the other end (henceforth invalid)

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

{
  struct AliceServiceSession *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)
  {
    /* We didn't get an answer yet, fail with error */
    s->status = GNUNET_SCALARPRODUCT_STATUS_FAILURE;
    prepare_client_end_notification (s);
  }
}

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

Referenced by client_request_complete_alice().

Here is the call graph for this function:

Here is the caller graph for this function:

handle_bobs_cryptodata_message()

static void handle_bobs_cryptodata_message ( void *  cls, const struct EccBobCryptodataMessage *  msg  )

static

Handle a response we got from another service we wanted to calculate a scalarproduct with.

Parameters

cls	the struct AliceServiceSession *
msg	the actual message

Definition at line 422 of file gnunet-service-scalarproduct-ecc_alice.c.

{
  struct AliceServiceSession *s = cls;
  uint32_t contained;
 
  contained = ntohl (msg->contained_element_count);
  if (2 != contained)
  {
    GNUNET_break_op (0);
    destroy_service_session (s);
    return;
  }
  if (NULL == s->sorted_elements)
  {
    /* we're not ready yet, how can Bob be? */
    GNUNET_break_op (0);
    destroy_service_session (s);
    return;
  }
  if (s->total != s->client_received_element_count)
  {
    /* we're not ready yet, how can Bob be? */
    GNUNET_break_op (0);
    destroy_service_session (s);
    return;
  }
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Received %u crypto values from Bob\n",
              (unsigned int) contained);
  GNUNET_CADET_receive_done (s->channel);
  {
    struct GNUNET_CRYPTO_EccPoint g_i_b_i_a_inv;
    struct GNUNET_CRYPTO_EccPoint g_ai_bi;
 
    GNUNET_assert (
      GNUNET_OK ==
      GNUNET_CRYPTO_ecc_pmul_mpi (&msg->prod_g_i_b_i,
                                  &my_privkey_inv,
                                  &g_i_b_i_a_inv));
    GNUNET_assert (
      GNUNET_OK ==
      GNUNET_CRYPTO_ecc_add (&g_i_b_i_a_inv,
                             &msg->prod_h_i_b_i,
                             &g_ai_bi));
    s->product = GNUNET_CRYPTO_ecc_dlog (edc,
                                         &g_ai_bi);
    if (INT_MAX == s->product)
    {
      /* result too big */
      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                  "Scalar product result out of range\n");
    }
  }
  transmit_client_response (s);
}

References destroy_service_session(), edc, GNUNET_assert, GNUNET_break_op, GNUNET_CADET_receive_done(), GNUNET_CRYPTO_ecc_add(), GNUNET_CRYPTO_ecc_dlog(), GNUNET_CRYPTO_ecc_pmul_mpi(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_log, GNUNET_OK, INT_MAX, msg, my_privkey_inv, AliceServiceSession::product, AliceServiceSession::s, and transmit_client_response().

Here is the call 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 489 of file gnunet-service-scalarproduct-ecc_alice.c.

{
  struct AliceServiceSession *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 GNUNET_ntohll(), GNUNET_OK, MpiElement::key, GNUNET_SCALARPRODUCT_Element::key, AliceServiceSession::s, AliceServiceSession::sorted_elements, AliceServiceSession::used_element_count, value, MpiElement::value, and GNUNET_SCALARPRODUCT_Element::value.

Referenced by send_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.

Definition at line 512 of file gnunet-service-scalarproduct-ecc_alice.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 send_alices_cryptodata_message().

Here is the call graph for this function:

Here is the caller graph for this function:

send_alices_cryptodata_message()

static void send_alices_cryptodata_message ( struct AliceServiceSession *  s )

static

Send the cryptographic data from Alice to Bob.

Does nothing if we already transferred all elements.

Parameters

s	the associated service session

Definition at line 540 of file gnunet-service-scalarproduct-ecc_alice.c.

{
  struct EccAliceCryptodataMessage *msg;
  struct GNUNET_MQ_Envelope *e;
  struct GNUNET_CRYPTO_EccPoint *payload;
  struct GNUNET_CRYPTO_EccScalar r_ia;
  struct GNUNET_CRYPTO_EccScalar r_ia_ai;
  unsigned int off;
  unsigned int todo_count;
 
  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);
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Finished intersection, %d items remain\n",
       s->used_element_count);
  qsort (s->sorted_elements,
         s->used_element_count,
         sizeof(struct MpiElement),
         &element_cmp);
  off = 0;
  while (off < s->used_element_count)
  {
    todo_count = s->used_element_count - off;
    if (todo_count > ELEMENT_CAPACITY)
      todo_count = ELEMENT_CAPACITY;
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Sending %u/%u crypto values to Bob\n",
                (unsigned int) todo_count,
                (unsigned int) s->used_element_count);
 
    e =
      GNUNET_MQ_msg_extra (msg,
                           todo_count * 2
                           * sizeof(struct GNUNET_CRYPTO_EccPoint),
                           GNUNET_MESSAGE_TYPE_SCALARPRODUCT_ECC_ALICE_CRYPTODATA);
    msg->contained_element_count = htonl (todo_count);
    payload = (struct GNUNET_CRYPTO_EccPoint *) &msg[1];
    for (unsigned int i = off; i < off + todo_count; i++)
    {
      struct GNUNET_CRYPTO_EccScalar r_i;
      struct GNUNET_CRYPTO_EccPoint g_i;
      struct GNUNET_CRYPTO_EccPoint h_i;
 
      /* r_i = random() mod n */
      GNUNET_CRYPTO_ecc_random_mod_n (&r_i);
      /* g_i = g^{r_i} */
      GNUNET_assert (GNUNET_OK ==
                     GNUNET_CRYPTO_ecc_dexp_mpi (&r_i,
                                                 &g_i));
      /* r_ia = r_i * a */
      crypto_core_ed25519_scalar_mul (r_ia.v,
                                      r_i.v,
                                      my_privkey.v);
      /* r_ia_ai = r_ia + a_i */
      {
        int64_t val = s->sorted_elements[i].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_add (r_ia_ai.v,
                                          r_ia.v,
                                          vali.v);
        else
          crypto_core_ed25519_scalar_sub (r_ia_ai.v,
                                          r_ia.v,
                                          vali.v);
      }
      /* h_i = g^{r_ia_ai} */
      GNUNET_assert (GNUNET_OK ==
                     GNUNET_CRYPTO_ecc_dexp_mpi (&r_ia_ai,
                                                 &h_i));
      memcpy (&payload[(i - off) * 2],
              &g_i,
              sizeof (g_i));
      memcpy (&payload[(i - off) * 2 + 1],
              &h_i,
              sizeof (h_i));
    }
    off += todo_count;
    GNUNET_MQ_send (s->cadet_mq,
                    e);
  }
}

References AliceServiceSession::cadet_mq, copy_element_cb(), ELEMENT_CAPACITY, element_cmp(), GNUNET_assert, GNUNET_CONTAINER_multihashmap_iterate(), GNUNET_CONTAINER_multihashmap_size(), GNUNET_CRYPTO_ecc_dexp_mpi(), GNUNET_CRYPTO_ecc_random_mod_n(), GNUNET_CRYPTO_ecc_scalar_from_int(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_MESSAGE_TYPE_SCALARPRODUCT_ECC_ALICE_CRYPTODATA, GNUNET_MQ_msg_extra, GNUNET_MQ_send(), GNUNET_new_array, GNUNET_OK, AliceServiceSession::intersected_elements, LOG, msg, my_privkey, payload, AliceServiceSession::sorted_elements, AliceServiceSession::used_element_count, GNUNET_CRYPTO_EccScalar::v, and MpiElement::value.

Referenced by cb_intersection_element_removed().

Here is the call graph for this function:

Here is the caller 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 should be removed from the result set, and then once to indicate that the set intersection operation is done.

Parameters

cls	closure with the struct AliceServiceSession
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 644 of file gnunet-service-scalarproduct-ecc_alice.c.

{
  struct AliceServiceSession *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,
         "Intersection 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;
    if (NULL != s->intersection_set)
    {
      GNUNET_SETI_destroy (s->intersection_set);
      s->intersection_set = NULL;
    }
    send_alices_cryptodata_message (s);
    return;
  case GNUNET_SETI_STATUS_FAILURE:
    /* unhandled status code */
    LOG (GNUNET_ERROR_TYPE_DEBUG, "Set intersection failed!\n");
    if (NULL != s->intersection_listen)
    {
      GNUNET_SETI_listen_cancel (s->intersection_listen);
      s->intersection_listen = NULL;
    }
    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 GNUNET_SETI_Element::data, GNUNET_assert, GNUNET_break, GNUNET_CONTAINER_multihashmap_get(), GNUNET_CONTAINER_multihashmap_remove(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_h2s(), GNUNET_ntohll(), GNUNET_SCALARPRODUCT_STATUS_FAILURE, GNUNET_SETI_destroy(), GNUNET_SETI_listen_cancel(), GNUNET_SETI_STATUS_DEL_LOCAL, GNUNET_SETI_STATUS_DONE, GNUNET_SETI_STATUS_FAILURE, GNUNET_YES, AliceServiceSession::intersected_elements, AliceServiceSession::intersection_listen, AliceServiceSession::intersection_op, AliceServiceSession::intersection_set, GNUNET_SCALARPRODUCT_Element::key, LOG, prepare_client_end_notification(), AliceServiceSession::s, send_alices_cryptodata_message(), status, AliceServiceSession::status, and GNUNET_SCALARPRODUCT_Element::value.

Referenced by cb_intersection_request_alice().

Here is the call graph for this function:

Here is the caller graph for this function:

cb_intersection_request_alice()

static void cb_intersection_request_alice ( void *  cls, const struct GNUNET_PeerIdentity *  other_peer, const struct GNUNET_MessageHeader *  context_msg, struct GNUNET_SETI_Request *  request  )

static

Called when another peer wants to do a set operation with the local peer.

If a listen error occurs, the request is NULL.

Parameters

cls	closure with the struct AliceServiceSession *
other_peer	the other peer
context_msg	message with application specific information from the other peer
request	request from the other peer (never NULL), use GNUNET_SETI_accept() to accept it, otherwise the request will be refused Note that we can't just return value from the listen callback, as it is also necessary to specify the set we want to do the operation with, which sometimes can be derived from the context message. It's necessary to specify the timeout.

Definition at line 720 of file gnunet-service-scalarproduct-ecc_alice.c.

{
  struct AliceServiceSession *s = cls;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Received intersection request from %s!\n",
              GNUNET_i2s (other_peer));
  if (0 != GNUNET_memcmp (other_peer,
                          &s->peer))
  {
    GNUNET_break_op (0);
    return;
  }
  s->intersection_op
    = GNUNET_SETI_accept (request,
                          (struct GNUNET_SETI_Option[]){ { 0 } },
                          &cb_intersection_element_removed,
                          s);
  if (NULL == s->intersection_op)
  {
    GNUNET_break (0);
    s->status = GNUNET_SCALARPRODUCT_STATUS_FAILURE;
    prepare_client_end_notification (s);
    return;
  }
  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;
  }
}

References cb_intersection_element_removed(), GNUNET_break, GNUNET_break_op, GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s(), GNUNET_log, GNUNET_memcmp, GNUNET_OK, GNUNET_SCALARPRODUCT_STATUS_FAILURE, GNUNET_SETI_accept(), GNUNET_SETI_commit(), prepare_client_end_notification(), request, and AliceServiceSession::s.

Referenced by client_request_complete_alice().

Here is the call graph for this function:

Here is the caller graph for this function:

client_request_complete_alice()

static void client_request_complete_alice ( struct AliceServiceSession *  s )

static

Our client has finished sending us its multipart message.

Parameters

s	the service session context

Definition at line 766 of file gnunet-service-scalarproduct-ecc_alice.c.

{
  struct GNUNET_MQ_MessageHandler cadet_handlers[] = {
    GNUNET_MQ_hd_fixed_size (bobs_cryptodata_message,
                             GNUNET_MESSAGE_TYPE_SCALARPRODUCT_ECC_BOB_CRYPTODATA,
                             struct EccBobCryptodataMessage,
                             s),
    GNUNET_MQ_handler_end ()
  };
  struct EccServiceRequestMessage *msg;
  struct GNUNET_MQ_Envelope *e;
  struct GNUNET_HashCode set_sid;
 
  GNUNET_CRYPTO_hash (&s->session_id,
                      sizeof(struct GNUNET_HashCode),
                      &set_sid);
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Creating new channel for session with key %s.\n",
              GNUNET_h2s (&s->session_id));
  s->channel = GNUNET_CADET_channel_create (my_cadet,
                                            s,
                                            &s->peer,
                                            &s->session_id,
                                            NULL,
                                            &cb_channel_destruction,
                                            cadet_handlers);
  if (NULL == s->channel)
  {
    s->status = GNUNET_SCALARPRODUCT_STATUS_FAILURE;
    prepare_client_end_notification (s);
    return;
  }
  s->cadet_mq = GNUNET_CADET_get_mq (s->channel);
  s->intersection_listen = GNUNET_SETI_listen (cfg,
                                               &set_sid,
                                               &cb_intersection_request_alice,
                                               s);
  if (NULL == s->intersection_listen)
  {
    s->status = GNUNET_SCALARPRODUCT_STATUS_FAILURE;
    GNUNET_CADET_channel_destroy (s->channel);
    s->channel = NULL;
    prepare_client_end_notification (s);
    return;
  }
 
  e =
    GNUNET_MQ_msg (msg,
                   GNUNET_MESSAGE_TYPE_SCALARPRODUCT_ECC_SESSION_INITIALIZATION);
  GNUNET_MQ_env_set_options (e, GNUNET_MQ_PRIO_CRITICAL_CONTROL);
  msg->session_id = s->session_id;
  GNUNET_MQ_send (s->cadet_mq, e);
}

References AliceServiceSession::cadet_mq, cb_channel_destruction(), cb_intersection_request_alice(), cfg, AliceServiceSession::channel, GNUNET_CADET_channel_create(), GNUNET_CADET_channel_destroy(), GNUNET_CADET_get_mq(), GNUNET_CRYPTO_hash(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_h2s(), GNUNET_log, GNUNET_MESSAGE_TYPE_SCALARPRODUCT_ECC_BOB_CRYPTODATA, GNUNET_MESSAGE_TYPE_SCALARPRODUCT_ECC_SESSION_INITIALIZATION, GNUNET_MQ_env_set_options(), GNUNET_MQ_handler_end, GNUNET_MQ_hd_fixed_size, GNUNET_MQ_msg, GNUNET_MQ_PRIO_CRITICAL_CONTROL, GNUNET_MQ_send(), GNUNET_SCALARPRODUCT_STATUS_FAILURE, GNUNET_SETI_listen(), AliceServiceSession::intersection_listen, msg, my_cadet, AliceServiceSession::peer, prepare_client_end_notification(), AliceServiceSession::session_id, and AliceServiceSession::status.

Referenced by handle_alice_client_message(), and handle_alice_client_message_multipart().

Here is the call graph for this function:

Here is the caller graph for this function:

check_alice_client_message_multipart()

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

static

We're receiving additional set data.

Check if msg is well-formed.

Parameters

cls	client identification of the client
msg	the actual message

Returns

GNUNET_OK if msg is well-formed

Definition at line 830 of file gnunet-service-scalarproduct-ecc_alice.c.

{
  struct AliceServiceSession *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) ||
      (s->total == s->client_received_element_count) ||
      (s->total < s->client_received_element_count + contained_count))
  {
    GNUNET_break_op (0);
    return GNUNET_SYSERR;
  }
  return GNUNET_OK;
}

References GNUNET_break_op, GNUNET_OK, GNUNET_SYSERR, msg, AliceServiceSession::s, and GNUNET_MessageHeader::size.

handle_alice_client_message_multipart()

static void handle_alice_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	client identification of the client
msg	the actual message

Definition at line 862 of file gnunet-service-scalarproduct-ecc_alice.c.

{
  struct AliceServiceSession *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);
  s->client_received_element_count += contained_count;
  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->used_element_count++;
  }
  GNUNET_SERVICE_client_continue (s->client);
  if (s->total != s->client_received_element_count)
  {
    /* more to come */
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Received client multipart data, waiting for more!\n");
    return;
  }
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Launching computation\n");
  client_request_complete_alice (s);
}

References AliceServiceSession::client, AliceServiceSession::client_received_element_count, client_request_complete_alice(), 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, AliceServiceSession::intersected_elements, AliceServiceSession::intersection_set, GNUNET_SCALARPRODUCT_Element::key, msg, AliceServiceSession::s, GNUNET_SETI_Element::size, AliceServiceSession::total, and AliceServiceSession::used_element_count.

Here is the call graph for this function:

check_alice_client_message()

static int check_alice_client_message ( void *  cls, const struct AliceComputationMessage *  msg  )

static

Handler for Alice's client request message.

Check that 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 919 of file gnunet-service-scalarproduct-ecc_alice.c.

{
  struct AliceServiceSession *s = cls;
  uint16_t msize;
  uint32_t total_count;
  uint32_t contained_count;
 
  if (NULL != s->intersected_elements)
  {
    /* only one concurrent session per client connection allowed,
       simplifies logic a lot... */
    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) ||
      (msize !=
       (sizeof(struct AliceComputationMessage)
        + 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_SYSERR, msg, AliceServiceSession::s, and GNUNET_MessageHeader::size.

handle_alice_client_message()

static void handle_alice_client_message ( void *  cls, const struct AliceComputationMessage *  msg  )

static

Handler for Alice's client request message.

We are doing request-initiation to compute a scalar product with a peer.

Parameters

cls	identification of the client
msg	the actual message

Definition at line 957 of file gnunet-service-scalarproduct-ecc_alice.c.

{
  struct AliceServiceSession *s = cls;
  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->peer = msg->peer;
  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);
    *elem = elements[i];
    if (GNUNET_SYSERR ==
        GNUNET_CONTAINER_multihashmap_put (
          s->intersected_elements,
          &elem->key,
          elem,
          GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY))
    {
      /* element with same key encountered twice! */
      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);
  if (s->total != s->client_received_element_count)
  {
    /* wait for multipart msg */
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Received partial client request, waiting for more!\n");
    return;
  }
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Launching computation\n");
  client_request_complete_alice (s);
}

References cfg, AliceServiceSession::client, AliceServiceSession::client_received_element_count, client_request_complete_alice(), GNUNET_SETI_Element::data, GNUNET_SETI_Element::element_type, GNUNET_break, GNUNET_CONTAINER_multihashmap_create(), GNUNET_CONTAINER_multihashmap_put(), GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_log, GNUNET_new, GNUNET_ntohll(), GNUNET_SCALARPRODUCT_STATUS_ACTIVE, GNUNET_SERVICE_client_continue(), GNUNET_SETI_add_element(), GNUNET_SETI_create(), GNUNET_SYSERR, GNUNET_YES, AliceServiceSession::intersected_elements, AliceServiceSession::intersection_set, GNUNET_SCALARPRODUCT_Element::key, msg, AliceServiceSession::peer, AliceServiceSession::s, AliceServiceSession::session_id, GNUNET_SETI_Element::size, AliceServiceSession::status, AliceServiceSession::total, AliceServiceSession::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
tc	unused

Definition at line 1027 of file gnunet-service-scalarproduct-ecc_alice.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.

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

Definition at line 1056 of file gnunet-service-scalarproduct-ecc_alice.c.

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

References AliceServiceSession::client, GNUNET_new, mq, and AliceServiceSession::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 AliceServiceSession

Definition at line 1080 of file gnunet-service-scalarproduct-ecc_alice.c.

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

References AliceServiceSession::client, destroy_service_session(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, and AliceServiceSession::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 1103 of file gnunet-service-scalarproduct-ecc_alice.c.

{
  cfg = c;
  edc = GNUNET_CRYPTO_ecc_dlog_prepare (MAX_RESULT,
                                        MAX_RAM);
  /* Select a random 'a' value for Alice */
  GNUNET_CRYPTO_ecc_rnd_mpi (&my_privkey,
                             &my_privkey_inv);
  my_cadet = GNUNET_CADET_connect (cfg);
  if (NULL == my_cadet)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                _ ("Connect to CADET failed\n"));
    GNUNET_SCHEDULER_shutdown ();
    return;
  }
  GNUNET_SCHEDULER_add_shutdown (&shutdown_task,
                                 NULL);
}

References _, cfg, edc, GNUNET_CADET_connect(), GNUNET_CRYPTO_ecc_dlog_prepare(), GNUNET_CRYPTO_ecc_rnd_mpi(), GNUNET_ERROR_TYPE_ERROR, GNUNET_log, GNUNET_SCHEDULER_add_shutdown(), GNUNET_SCHEDULER_shutdown(), MAX_RAM, MAX_RESULT, my_cadet, my_privkey, my_privkey_inv, and shutdown_task.

Here is the call graph for this function:

GNUNET_SERVICE_MAIN()

GNUNET_SERVICE_MAIN	(	GNUNET_OS_project_data_gnunet()	,
		"scalarproduct-alice"	,
		GNUNET_SERVICE_OPTION_NONE	,
		&	run,
		&	client_connect_cb,
		&	client_disconnect_cb,
		NULL	,
		GNUNET_MQ_hd_var_size(alice_client_message, GNUNET_MESSAGE_TYPE_SCALARPRODUCT_CLIENT_TO_ALICE, struct AliceComputationMessage, NULL)	,
		GNUNET_MQ_hd_var_size(alice_client_message_multipart, GNUNET_MESSAGE_TYPE_SCALARPRODUCT_CLIENT_MULTIPART_ALICE, struct ComputationBobCryptodataMultipartMessage, NULL)	,
		GNUNET_MQ_handler_end()
	)

Define "main" method using service macro.

Variable Documentation

cfg

const struct GNUNET_CONFIGURATION_Handle* cfg

static

GNUnet configuration handle.

Definition at line 182 of file gnunet-service-scalarproduct-ecc_alice.c.

Referenced by client_request_complete_alice(), handle_alice_client_message(), and run().

edc

struct GNUNET_CRYPTO_EccDlogContext* edc

static

Context for DLOG operations on a curve.

Definition at line 187 of file gnunet-service-scalarproduct-ecc_alice.c.

Referenced by GNUNET_CRYPTO_ecc_dlog(), GNUNET_CRYPTO_ecc_dlog_prepare(), GNUNET_CRYPTO_ecc_dlog_release(), handle_bobs_cryptodata_message(), run(), and shutdown_task().

my_privkey

struct GNUNET_CRYPTO_EccScalar my_privkey

static

Alice's private key ('a').

Definition at line 192 of file gnunet-service-scalarproduct-ecc_alice.c.

Referenced by run(), and send_alices_cryptodata_message().

my_privkey_inv

struct GNUNET_CRYPTO_EccScalar my_privkey_inv

static

Inverse of Alice's private key ('a_inv').

Definition at line 197 of file gnunet-service-scalarproduct-ecc_alice.c.

Referenced by handle_bobs_cryptodata_message(), and run().

my_cadet

struct GNUNET_CADET_Handle* my_cadet

static

Handle to the CADET service.

Definition at line 202 of file gnunet-service-scalarproduct-ecc_alice.c.

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