GNUnet 0.21.1
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_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 "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. More...
 
#define MAX_RAM   (1024)
 How many values should DLOG store in memory (determines baseline RAM consumption, roughly 100 bytes times the value given here). More...
 
#define ELEMENT_CAPACITY
 Maximum number of elements we can put into a single cryptodata message. More...
 

Functions

static int free_element_cb (void *cls, const struct GNUNET_HashCode *key, void *value)
 Iterator called to free elements. More...
 
static void destroy_service_session (struct AliceServiceSession *s)
 Destroy session state, we are done with it. More...
 
static void prepare_client_end_notification (struct AliceServiceSession *session)
 Notify the client that the session has failed. More...
 
static void transmit_client_response (struct AliceServiceSession *s)
 Prepare the final (positive) response we will send to Alice's client. More...
 
static void cb_channel_destruction (void *cls, const struct GNUNET_CADET_Channel *channel)
 Function called whenever a channel is destroyed. More...
 
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. More...
 
static int copy_element_cb (void *cls, const struct GNUNET_HashCode *key, void *value)
 Iterator to copy over messages from the hash map into an array for sorting. More...
 
static int element_cmp (const void *a, const void *b)
 Compare two struct MpiValues by key for sorting. More...
 
static void send_alices_cryptodata_message (struct AliceServiceSession *s)
 Send the cryptographic data from Alice to Bob. 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 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. More...
 
static void client_request_complete_alice (struct AliceServiceSession *s)
 Our client has finished sending us its multipart message. More...
 
static int check_alice_client_message_multipart (void *cls, const struct ComputationBobCryptodataMultipartMessage *msg)
 We're receiving additional set data. More...
 
static void handle_alice_client_message_multipart (void *cls, const struct ComputationBobCryptodataMultipartMessage *msg)
 We're receiving additional set data. More...
 
static int check_alice_client_message (void *cls, const struct AliceComputationMessage *msg)
 Handler for Alice's client request message. More...
 
static void handle_alice_client_message (void *cls, const struct AliceComputationMessage *msg)
 Handler for Alice's 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-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. More...
 

Variables

static const struct GNUNET_CONFIGURATION_Handlecfg
 GNUnet configuration handle. More...
 
static struct GNUNET_CRYPTO_EccDlogContextedc
 Context for DLOG operations on a curve. More...
 
static struct GNUNET_CRYPTO_EccScalar my_privkey
 Alice's private key ('a'). More...
 
static struct GNUNET_CRYPTO_EccScalar my_privkey_inv
 Inverse of Alice's private key ('a_inv'). More...
 
static struct GNUNET_CADET_Handlemy_cadet
 Handle to the CADET service. More...
 

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 40 of file 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 48 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 56 of file gnunet-service-scalarproduct-ecc_alice.c.

◆ ELEMENT_CAPACITY

#define ELEMENT_CAPACITY
Value:
- sizeof(struct EccAliceCryptodataMessage)) \
/ sizeof(struct GNUNET_CRYPTO_EccPoint))
#define GNUNET_CONSTANTS_MAX_CADET_MESSAGE_SIZE
Maximum message size that can be sent on CADET.
Vector of ECC-encrypted values sent by Alice to Bob (after set intersection).
Point on a curve (always for Curve25519) encoded in a format suitable for network transmission (ECDH)...

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

Definition at line 529 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
clsthe struct AliceServiceSession * (unused)
keythe key (unused)
valuevalue to free
Returns
GNUNET_OK (continue to iterate)

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

219{
221
222 GNUNET_free (e);
223 return GNUNET_OK;
224}
static char * value
Value of the record to add/remove.
@ GNUNET_OK
#define GNUNET_free(ptr)
Wrapper around free.
An element key-value pair for scalarproduct.

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
sthe session to free elements from

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

234{
235 if (GNUNET_YES == s->in_destroy)
236 return;
238 if (NULL != s->client)
239 {
240 struct GNUNET_SERVICE_Client *c = s->client;
241
242 s->client = NULL;
244 }
245 if (NULL != s->channel)
246 {
248 s->channel = NULL;
249 }
250 if (NULL != s->intersected_elements)
251 {
254 s);
256 s->intersected_elements = NULL;
257 }
258 if (NULL != s->intersection_listen)
259 {
261 s->intersection_listen = NULL;
262 }
263 if (NULL != s->intersection_op)
264 {
266 "Set intersection, op still ongoing!\n");
268 s->intersection_op = NULL;
269 }
270 if (NULL != s->intersection_set)
271 {
273 s->intersection_set = NULL;
274 }
275 if (NULL != s->sorted_elements)
276 {
278 s->sorted_elements = NULL;
279 }
280 GNUNET_free (s);
281}
#define LOG(kind,...)
static int free_element_cb(void *cls, const struct GNUNET_HashCode *key, void *value)
Iterator called to free elements.
void GNUNET_CADET_channel_destroy(struct GNUNET_CADET_Channel *channel)
Destroy an existing channel.
Definition: cadet_api.c:830
int GNUNET_CONTAINER_multihashmap_iterate(struct GNUNET_CONTAINER_MultiHashMap *map, GNUNET_CONTAINER_MultiHashMapIteratorCallback it, void *it_cls)
Iterate over all entries in the map.
void GNUNET_CONTAINER_multihashmap_destroy(struct GNUNET_CONTAINER_MultiHashMap *map)
Destroy a hash map.
@ GNUNET_YES
@ GNUNET_ERROR_TYPE_DEBUG
void GNUNET_SERVICE_client_drop(struct GNUNET_SERVICE_Client *c)
Ask the server to disconnect from the given client.
Definition: service.c:2484
void GNUNET_SETI_destroy(struct GNUNET_SETI_Handle *set)
Destroy the set handle, and free all associated resources.
Definition: seti_api.c:488
void GNUNET_SETI_operation_cancel(struct GNUNET_SETI_OperationHandle *oh)
Cancel the given set operation.
Definition: seti_api.c:335
void GNUNET_SETI_listen_cancel(struct GNUNET_SETI_ListenHandle *lh)
Cancel the given listen operation.
Definition: seti_api.c:734
struct MpiElement * sorted_elements
a(Alice), sorted array by key of length used_element_count.
struct GNUNET_CONTAINER_MultiHashMap * intersected_elements
all non-0-value'd elements transmitted to us.
struct GNUNET_SETI_Handle * intersection_set
Set of elements for which will conduction an intersection.
int in_destroy
Flag to prevent recursive calls to destroy_service_session() from doing harm.
struct GNUNET_SETI_OperationHandle * intersection_op
Set of elements for which will conduction an intersection.
struct GNUNET_SERVICE_Client * client
The client this request is related to.
struct GNUNET_CADET_Channel * channel
channel-handle associated with our cadet handle
struct GNUNET_SETI_ListenHandle * intersection_listen
Handle to Alice's Intersection operation listening for Bob.
Handle to a client that is connected to a service.
Definition: service.c:246

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
sessionthe associated client session to fail or succeed

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

292{
294 struct GNUNET_MQ_Envelope *e;
295
296 if (NULL == session->client_mq)
297 return; /* no client left to be notified */
298 GNUNET_log (
300 "Sending session-end notification with status %d to client for session %s\n",
301 session->status,
302 GNUNET_h2s (&session->session_id));
303 e = GNUNET_MQ_msg (msg,
305 msg->product_length = htonl (0);
306 msg->status = htonl (session->status);
307 GNUNET_MQ_send (session->client_mq,
308 e);
309}
struct GNUNET_MessageHeader * msg
Definition: 005.c:2
#define GNUNET_log(kind,...)
const char * GNUNET_h2s(const struct GNUNET_HashCode *hc)
Convert a hash value to a string (for printing debug messages).
void GNUNET_MQ_send(struct GNUNET_MQ_Handle *mq, struct GNUNET_MQ_Envelope *ev)
Send a message with the given message queue.
Definition: mq.c:304
#define GNUNET_MQ_msg(mvar, type)
Allocate a GNUNET_MQ_Envelope.
Definition: gnunet_mq_lib.h:78
#define GNUNET_MESSAGE_TYPE_SCALARPRODUCT_RESULT
Alice/Bob -> Client Result.
struct GNUNET_HashCode session_id
(hopefully) unique transaction ID
struct GNUNET_MQ_Handle * client_mq
The message queue for the client.
enum GNUNET_SCALARPRODUCT_ResponseStatus status
State of this session.
Message type passed from service client to finalize a session as requester or responder.

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
sthe session associated with our client.

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

320{
322 struct GNUNET_MQ_Envelope *e;
323 unsigned char *product_exported = NULL;
324 size_t product_length = 0;
325 int32_t range;
326 gcry_error_t rc;
327 gcry_mpi_t value;
328
329 if (INT_MAX == s->product)
330 {
331 GNUNET_break (0);
333 return;
334 }
335 value = gcry_mpi_new (32);
336 if (0 > s->product)
337 {
338 range = -1;
339 gcry_mpi_set_ui (value,
340 -s->product);
341 }
342 else if (0 < s->product)
343 {
344 range = 1;
345 gcry_mpi_set_ui (value,
346 s->product);
347 }
348 else
349 {
350 /* result is exactly zero */
351 range = 0;
352 }
353 if ( (0 != range) &&
354 (0 != (rc = gcry_mpi_aprint (GCRYMPI_FMT_STD,
355 &product_exported,
356 &product_length,
357 value))))
358 {
360 "gcry_mpi_scan",
361 rc);
363 return;
364 }
365 gcry_mpi_release (value);
367 product_length,
370 msg->range = htonl (range);
371 msg->product_length = htonl (product_length);
372 if (NULL != product_exported)
373 {
374 GNUNET_memcpy (&msg[1],
375 product_exported,
376 product_length);
377 GNUNET_free (product_exported);
378 }
380 e);
382 "Sent result to client, session %s has ended!\n",
383 GNUNET_h2s (&s->session_id));
384}
#define INT_MAX
static void prepare_client_end_notification(struct AliceServiceSession *session)
Notify the client that the session has failed.
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur.
@ GNUNET_ERROR_TYPE_ERROR
#define GNUNET_MQ_msg_extra(mvar, esize, type)
Allocate an envelope, with extra space allocated after the space needed by the message struct.
Definition: gnunet_mq_lib.h:63
@ GNUNET_SCALARPRODUCT_STATUS_SUCCESS
The computation was successful.
#define LOG_GCRY(level, cmd, rc)
Log an error message at log-level 'level' that indicates a failure of the command 'cmd' with the mess...
Definition: scalarproduct.h:35
int product
The computed scalar product.

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
clsthe struct AliceServiceSession
channelconnection to the other end (henceforth invalid)

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

399{
400 struct AliceServiceSession *s = cls;
401
403 "Peer disconnected, terminating session %s with peer %s\n",
404 GNUNET_h2s (&s->session_id),
405 GNUNET_i2s (&s->peer));
406 s->channel = NULL;
408 {
409 /* We didn't get an answer yet, fail with error */
412 }
413}
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
@ GNUNET_SCALARPRODUCT_STATUS_ACTIVE
Operation is still active (never returned, used internally).
@ GNUNET_SCALARPRODUCT_STATUS_FAILURE
We encountered some error.
A scalarproduct session which tracks a request form the client to our final response.
struct GNUNET_CRYPTO_PaillierCiphertext s
Bob's "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
clsthe struct AliceServiceSession *
msgthe actual message

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

426{
427 struct AliceServiceSession *s = cls;
428 uint32_t contained;
429
430 contained = ntohl (msg->contained_element_count);
431 if (2 != contained)
432 {
433 GNUNET_break_op (0);
435 return;
436 }
437 if (NULL == s->sorted_elements)
438 {
439 /* we're not ready yet, how can Bob be? */
440 GNUNET_break_op (0);
442 return;
443 }
444 if (s->total != s->client_received_element_count)
445 {
446 /* we're not ready yet, how can Bob be? */
447 GNUNET_break_op (0);
449 return;
450 }
452 "Received %u crypto values from Bob\n",
453 (unsigned int) contained);
454 GNUNET_CADET_receive_done (s->channel);
455 {
456 struct GNUNET_CRYPTO_EccPoint g_i_b_i_a_inv;
457 struct GNUNET_CRYPTO_EccPoint g_ai_bi;
458
460 GNUNET_OK ==
461 GNUNET_CRYPTO_ecc_pmul_mpi (&msg->prod_g_i_b_i,
463 &g_i_b_i_a_inv));
465 GNUNET_OK ==
466 GNUNET_CRYPTO_ecc_add (&g_i_b_i_a_inv,
467 &msg->prod_h_i_b_i,
468 &g_ai_bi));
470 &g_ai_bi);
471 if (INT_MAX == s->product)
472 {
473 /* result too big */
475 "Scalar product result out of range\n");
476 }
477 }
479}
static struct GNUNET_CRYPTO_EccDlogContext * edc
Context for DLOG operations on a curve.
static void destroy_service_session(struct AliceServiceSession *s)
Destroy session state, we are done with it.
static struct GNUNET_CRYPTO_EccScalar my_privkey_inv
Inverse of Alice's private key ('a_inv').
static void transmit_client_response(struct AliceServiceSession *s)
Prepare the final (positive) response we will send to Alice's client.
void GNUNET_CADET_receive_done(struct GNUNET_CADET_Channel *channel)
Indicate readiness to receive the next message on a channel.
Definition: cadet_api.c:872
enum GNUNET_GenericReturnValue GNUNET_CRYPTO_ecc_pmul_mpi(const struct GNUNET_CRYPTO_EccPoint *p, const struct GNUNET_CRYPTO_EccScalar *val, struct GNUNET_CRYPTO_EccPoint *r)
Multiply the point p on the elliptic curve by val.
int GNUNET_CRYPTO_ecc_dlog(struct GNUNET_CRYPTO_EccDlogContext *edc, const struct GNUNET_CRYPTO_EccPoint *input)
Calculate ECC discrete logarithm for small factors.
enum GNUNET_GenericReturnValue GNUNET_CRYPTO_ecc_add(const struct GNUNET_CRYPTO_EccPoint *a, const struct GNUNET_CRYPTO_EccPoint *b, struct GNUNET_CRYPTO_EccPoint *r)
Add two points on the elliptic curve.
#define GNUNET_break_op(cond)
Use this for assertion violations caused by other peers (i.e.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.

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
clsthe struct AliceServiceSession *
keythe key (unused)
valuethe struct GNUNET_SCALARPRODUCT_Element *

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

494{
495 struct AliceServiceSession *s = cls;
497
499 e->value);
502 return GNUNET_OK;
503}
uint64_t GNUNET_ntohll(uint64_t n)
Convert unsigned 64-bit integer to host byte order.
Definition: common_endian.c:54
uint32_t used_element_count
How many elements actually are used for the scalar product.
struct GNUNET_HashCode key
Key used to identify matching pairs of values to multiply.
int64_t value
Value to multiply in scalar product, in NBO.
const struct GNUNET_HashCode * key
Key used to identify matching pairs of values to multiply.
int64_t value
a_i value, not disclosed to Bob.

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
apointer to first struct MpiValue *
bpointer to first struct MpiValue *
Returns
-1 for a < b, 0 for a=b, 1 for a > b.

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

516{
517 const struct MpiElement *ma = a;
518 const struct MpiElement *mb = b;
519
520 return GNUNET_CRYPTO_hash_cmp (ma->key,
521 mb->key);
522}
int GNUNET_CRYPTO_hash_cmp(const struct GNUNET_HashCode *h1, const struct GNUNET_HashCode *h2)
Compare function for HashCodes, producing a total ordering of all hashcodes.
Definition: crypto_hash.c:221
An encrypted element key-value pair.

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
sthe associated service session

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

543{
545 struct GNUNET_MQ_Envelope *e;
547 struct GNUNET_CRYPTO_EccScalar r_ia;
548 struct GNUNET_CRYPTO_EccScalar r_ia_ai;
549 unsigned int off;
550 unsigned int todo_count;
551
554 struct MpiElement);
555 s->used_element_count = 0;
558 s);
560 "Finished intersection, %d items remain\n",
562 qsort (s->sorted_elements,
564 sizeof(struct MpiElement),
565 &element_cmp);
566 off = 0;
567 while (off < s->used_element_count)
568 {
569 todo_count = s->used_element_count - off;
570 if (todo_count > ELEMENT_CAPACITY)
571 todo_count = ELEMENT_CAPACITY;
573 "Sending %u/%u crypto values to Bob\n",
574 (unsigned int) todo_count,
575 (unsigned int) s->used_element_count);
576
577 e =
579 todo_count * 2
580 * sizeof(struct GNUNET_CRYPTO_EccPoint),
582 msg->contained_element_count = htonl (todo_count);
583 payload = (struct GNUNET_CRYPTO_EccPoint *) &msg[1];
584 for (unsigned int i = off; i < off + todo_count; i++)
585 {
586 struct GNUNET_CRYPTO_EccScalar r_i;
587 struct GNUNET_CRYPTO_EccPoint g_i;
588 struct GNUNET_CRYPTO_EccPoint h_i;
589
590 /* r_i = random() mod n */
592 /* g_i = g^{r_i} */
595 &g_i));
596 /* r_ia = r_i * a */
597 crypto_core_ed25519_scalar_mul (r_ia.v,
598 r_i.v,
599 my_privkey.v);
600 /* r_ia_ai = r_ia + a_i */
601 {
602 int64_t val = s->sorted_elements[i].value;
603 struct GNUNET_CRYPTO_EccScalar vali;
604
605 GNUNET_assert (INT64_MIN != val);
606 GNUNET_CRYPTO_ecc_scalar_from_int (val > 0 ? val : -val,
607 &vali);
608 if (val > 0)
609 crypto_core_ed25519_scalar_add (r_ia_ai.v,
610 r_ia.v,
611 vali.v);
612 else
613 crypto_core_ed25519_scalar_sub (r_ia_ai.v,
614 r_ia.v,
615 vali.v);
616 }
617 /* h_i = g^{r_ia_ai} */
620 &h_i));
621 memcpy (&payload[(i - off) * 2],
622 &g_i,
623 sizeof (g_i));
624 memcpy (&payload[(i - off) * 2 + 1],
625 &h_i,
626 sizeof (h_i));
627 }
628 off += todo_count;
630 e);
631 }
632}
static unsigned long long payload
How much data are we currently storing in the database?
static struct GNUNET_CRYPTO_EccScalar my_privkey
Alice's private key ('a').
#define ELEMENT_CAPACITY
Maximum number of elements we can put into a single cryptodata message.
static int element_cmp(const void *a, const void *b)
Compare two struct MpiValues by key for sorting.
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.
unsigned int GNUNET_CONTAINER_multihashmap_size(const struct GNUNET_CONTAINER_MultiHashMap *map)
Get the number of key-value pairs in the map.
enum GNUNET_GenericReturnValue GNUNET_CRYPTO_ecc_dexp_mpi(const struct GNUNET_CRYPTO_EccScalar *val, struct GNUNET_CRYPTO_EccPoint *r)
Multiply the generator g of the elliptic curve by val to obtain the point on the curve representing v...
void GNUNET_CRYPTO_ecc_scalar_from_int(int64_t val, struct GNUNET_CRYPTO_EccScalar *r)
Create a scalar from int value.
void GNUNET_CRYPTO_ecc_random_mod_n(struct GNUNET_CRYPTO_EccScalar *r)
Generate a random value mod n.
#define GNUNET_new_array(n, type)
Allocate a size n array with structs or unions of the given type.
#define GNUNET_MESSAGE_TYPE_SCALARPRODUCT_ECC_ALICE_CRYPTODATA
Alice -> Bob ECC crypto data.
struct GNUNET_MQ_Handle * cadet_mq
The message queue for CADET.
A ECC scalar for use in point multiplications.
unsigned char v[256/8]

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
clsclosure with the struct AliceServiceSession
elementa result element, only valid if status is #GNUNET_SETI_STATUS_OK
current_sizecurrent set size
statuswhat has happened with the set intersection?

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

650{
651 struct AliceServiceSession *s = cls;
653
654 switch (status)
655 {
657 /* this element has been removed from the set */
659 element->data);
660 GNUNET_assert (NULL != se);
662 "Intersection removed element with key %s and value %lld\n",
663 GNUNET_h2s (&se->key),
664 (long long) GNUNET_ntohll (se->value));
666 GNUNET_YES ==
668 element->data,
669 se));
670 GNUNET_free (se);
671 return;
673 s->intersection_op = NULL;
674 if (NULL != s->intersection_set)
675 {
677 s->intersection_set = NULL;
678 }
680 return;
682 /* unhandled status code */
683 LOG (GNUNET_ERROR_TYPE_DEBUG, "Set intersection failed!\n");
684 if (NULL != s->intersection_listen)
685 {
687 s->intersection_listen = NULL;
688 }
689 s->intersection_op = NULL;
690 if (NULL != s->intersection_set)
691 {
693 s->intersection_set = NULL;
694 }
697 return;
698
699 default:
700 GNUNET_break (0);
701 return;
702 }
703}
static int status
The program status; 0 for success.
Definition: gnunet-nse.c:39
static void send_alices_cryptodata_message(struct AliceServiceSession *s)
Send the cryptographic data from Alice to Bob.
void * GNUNET_CONTAINER_multihashmap_get(const struct GNUNET_CONTAINER_MultiHashMap *map, const struct GNUNET_HashCode *key)
Given a key find a value in the map matching the key.
enum GNUNET_GenericReturnValue GNUNET_CONTAINER_multihashmap_remove(struct GNUNET_CONTAINER_MultiHashMap *map, const struct GNUNET_HashCode *key, const void *value)
Remove the given key-value pair from the map.
@ GNUNET_SETI_STATUS_DONE
Success, all elements have been sent (and received).
@ GNUNET_SETI_STATUS_FAILURE
The other peer refused to do the operation with us, or something went wrong.
@ GNUNET_SETI_STATUS_DEL_LOCAL
Element should be delete from the result set of the local peer, i.e.
const void * data
Actual data of the element.

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
clsclosure with the struct AliceServiceSession *
other_peerthe other peer
context_msgmessage with application specific information from the other peer
requestrequest 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 722 of file gnunet-service-scalarproduct-ecc_alice.c.

726{
727 struct AliceServiceSession *s = cls;
728
730 "Received intersection request from %s!\n",
731 GNUNET_i2s (other_peer));
732 if (0 != GNUNET_memcmp (other_peer,
733 &s->peer))
734 {
735 GNUNET_break_op (0);
736 return;
737 }
738 s->intersection_op
740 (struct GNUNET_SETI_Option[]){ { 0 } },
742 s);
743 if (NULL == s->intersection_op)
744 {
745 GNUNET_break (0);
748 return;
749 }
750 if (GNUNET_OK !=
751 GNUNET_SETI_commit (s->intersection_op,
752 s->intersection_set))
753 {
754 GNUNET_break (0);
757 return;
758 }
759}
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 struct GNUNET_VPN_RedirectionRequest * request
Opaque redirection request handle.
Definition: gnunet-vpn.c:40
#define GNUNET_memcmp(a, b)
Compare memory in a and b, where both must be of the same pointer type.
struct GNUNET_SETI_OperationHandle * GNUNET_SETI_accept(struct GNUNET_SETI_Request *request, const struct GNUNET_SETI_Option options[], GNUNET_SETI_ResultIterator result_cb, void *result_cls)
Accept a request we got via GNUNET_SETI_listen().
Definition: seti_api.c:754
int GNUNET_SETI_commit(struct GNUNET_SETI_OperationHandle *oh, struct GNUNET_SETI_Handle *set)
Commit a set to be used with a set operation.
Definition: seti_api.c:810
Option for set operations.

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
sthe service session context

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

769{
770 struct GNUNET_MQ_MessageHandler cadet_handlers[] = {
771 GNUNET_MQ_hd_fixed_size (bobs_cryptodata_message,
774 s),
776 };
778 struct GNUNET_MQ_Envelope *e;
779 struct GNUNET_HashCode set_sid;
780
782 sizeof(struct GNUNET_HashCode),
783 &set_sid);
785 "Creating new channel for session with key %s.\n",
786 GNUNET_h2s (&s->session_id));
788 s,
789 &s->peer,
790 &s->session_id,
791 NULL,
793 cadet_handlers);
794 if (NULL == s->channel)
795 {
798 return;
799 }
802 &set_sid,
804 s);
805 if (NULL == s->intersection_listen)
806 {
809 s->channel = NULL;
811 return;
812 }
813
814 e =
818 msg->session_id = s->session_id;
819 GNUNET_MQ_send (s->cadet_mq, e);
820}
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 struct GNUNET_CADET_Handle * my_cadet
Handle to the CADET service.
static const struct GNUNET_CONFIGURATION_Handle * cfg
GNUnet configuration handle.
static void cb_channel_destruction(void *cls, const struct GNUNET_CADET_Channel *channel)
Function called whenever a channel is destroyed.
struct GNUNET_MQ_Handle * GNUNET_CADET_get_mq(const struct GNUNET_CADET_Channel *channel)
Obtain the message queue for a connected channel.
Definition: cadet_api.c:1066
struct GNUNET_CADET_Channel * GNUNET_CADET_channel_create(struct GNUNET_CADET_Handle *h, void *channel_cls, const struct GNUNET_PeerIdentity *destination, const struct GNUNET_HashCode *port, GNUNET_CADET_WindowSizeEventHandler window_changes, GNUNET_CADET_DisconnectEventHandler disconnects, const struct GNUNET_MQ_MessageHandler *handlers)
Create a new channel towards a remote peer.
Definition: cadet_api.c:1015
void GNUNET_CRYPTO_hash(const void *block, size_t size, struct GNUNET_HashCode *ret)
Compute hash of a given block.
Definition: crypto_hash.c:41
void GNUNET_MQ_env_set_options(struct GNUNET_MQ_Envelope *env, enum GNUNET_MQ_PriorityPreferences pp)
Set application-specific options for this envelope.
Definition: mq.c:830
#define GNUNET_MQ_handler_end()
End-marker for the handlers array.
#define GNUNET_MQ_hd_fixed_size(name, code, str, ctx)
@ GNUNET_MQ_PRIO_CRITICAL_CONTROL
Highest priority, control traffic (e.g.
#define GNUNET_MESSAGE_TYPE_SCALARPRODUCT_ECC_SESSION_INITIALIZATION
Alice -> Bob ECC session initialization.
#define GNUNET_MESSAGE_TYPE_SCALARPRODUCT_ECC_BOB_CRYPTODATA
Bob -> Alice ECC crypto data.
struct GNUNET_SETI_ListenHandle * GNUNET_SETI_listen(const struct GNUNET_CONFIGURATION_Handle *cfg, const struct GNUNET_HashCode *app_id, GNUNET_SETI_ListenCallback listen_cb, void *listen_cls)
Wait for set operation requests for the given application ID.
Definition: seti_api.c:702
struct GNUNET_PeerIdentity peer
Alice or Bob's peerID.
Message type passed from responding service Bob to responding service Alice to complete a request and...
Message type passed from requesting service Alice to responding service Bob to initiate a request and...
A 512-bit hashcode.
Message handler for a specific message type.

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
clsclient identification of the client
msgthe actual message
Returns
GNUNET_OK if msg is well-formed

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

835{
836 struct AliceServiceSession *s = cls;
837 uint32_t contained_count;
838 uint16_t msize;
839
840 msize = ntohs (msg->header.size);
841 contained_count = ntohl (msg->element_count_contained);
842 if ((msize !=
844 + contained_count * sizeof(struct GNUNET_SCALARPRODUCT_Element))) ||
845 (0 == contained_count) ||
846 (s->total == s->client_received_element_count) ||
847 (s->total < s->client_received_element_count + contained_count))
848 {
849 GNUNET_break_op (0);
850 return GNUNET_SYSERR;
851 }
852 return GNUNET_OK;
853}
uint16_t size
The length of the struct (in bytes, including the length field itself), in big-endian format.
@ GNUNET_SYSERR
multipart messages following struct ComputationMessage

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
clsclient identification of the client
msgthe actual message

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

867{
868 struct AliceServiceSession *s = cls;
869 uint32_t contained_count;
870 const struct GNUNET_SCALARPRODUCT_Element *elements;
871 struct GNUNET_SETI_Element set_elem;
872 struct GNUNET_SCALARPRODUCT_Element *elem;
873
874 contained_count = ntohl (msg->element_count_contained);
875 s->client_received_element_count += contained_count;
876 elements = (const struct GNUNET_SCALARPRODUCT_Element *) &msg[1];
877 for (uint32_t i = 0; i < contained_count; i++)
878 {
880 GNUNET_memcpy (elem,
881 &elements[i],
882 sizeof(struct GNUNET_SCALARPRODUCT_Element));
885 &elem->key,
886 elem,
888 {
889 GNUNET_break (0);
890 GNUNET_free (elem);
891 continue;
892 }
893 set_elem.data = &elem->key;
894 set_elem.size = sizeof(elem->key);
895 set_elem.element_type = 0;
896 GNUNET_SETI_add_element (s->intersection_set, &set_elem, NULL, NULL);
898 }
901 {
902 /* more to come */
904 "Received client multipart data, waiting for more!\n");
905 return;
906 }
907 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Launching computation\n");
909}
static void client_request_complete_alice(struct AliceServiceSession *s)
Our client has finished sending us its multipart message.
enum GNUNET_GenericReturnValue GNUNET_CONTAINER_multihashmap_put(struct GNUNET_CONTAINER_MultiHashMap *map, const struct GNUNET_HashCode *key, void *value, enum GNUNET_CONTAINER_MultiHashMapOption opt)
Store a key-value pair in the map.
@ GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY
There must only be one value per key; storing a value should fail if a value under the same key alrea...
#define GNUNET_new(type)
Allocate a struct or union of the given type.
void GNUNET_SERVICE_client_continue(struct GNUNET_SERVICE_Client *c)
Continue receiving further messages from the given client.
Definition: service.c:2455
int GNUNET_SETI_add_element(struct GNUNET_SETI_Handle *set, const struct GNUNET_SETI_Element *element, GNUNET_SCHEDULER_TaskCallback cb, void *cb_cls)
Add an element to the given set.
Definition: seti_api.c:447
uint32_t total
How many elements we were supplied with from the client (total count before intersection).
uint32_t client_received_element_count
Already transferred elements from client to us.
Element stored in a set.

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
clsidentification of the client
msgthe actual message
Returns
GNUNET_OK if msg is well-formed

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

923{
924 struct AliceServiceSession *s = cls;
925 uint16_t msize;
926 uint32_t total_count;
927 uint32_t contained_count;
928
929 if (NULL != s->intersected_elements)
930 {
931 /* only one concurrent session per client connection allowed,
932 simplifies logic a lot... */
933 GNUNET_break (0);
934 return GNUNET_SYSERR;
935 }
936 msize = ntohs (msg->header.size);
937 total_count = ntohl (msg->element_count_total);
938 contained_count = ntohl (msg->element_count_contained);
939 if ((0 == total_count) || (0 == contained_count) ||
940 (msize !=
941 (sizeof(struct AliceComputationMessage)
942 + contained_count * sizeof(struct GNUNET_SCALARPRODUCT_Element))))
943 {
944 GNUNET_break_op (0);
945 return GNUNET_SYSERR;
946 }
947 return GNUNET_OK;
948}
Message type passed from client to service to initiate a request or responder role.
Definition: scalarproduct.h:46

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
clsidentification of the client
msgthe actual message

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

961{
962 struct AliceServiceSession *s = cls;
963 uint32_t contained_count;
964 uint32_t total_count;
965 const struct GNUNET_SCALARPRODUCT_Element *elements;
966 struct GNUNET_SETI_Element set_elem;
967 struct GNUNET_SCALARPRODUCT_Element *elem;
968
969 total_count = ntohl (msg->element_count_total);
970 contained_count = ntohl (msg->element_count_contained);
971 s->peer = msg->peer;
973 s->total = total_count;
974 s->client_received_element_count = contained_count;
975 s->session_id = msg->session_key;
976 elements = (const struct GNUNET_SCALARPRODUCT_Element *) &msg[1];
979 GNUNET_YES);
981 for (uint32_t i = 0; i < contained_count; i++)
982 {
983 if (0 == GNUNET_ntohll (elements[i].value))
984 continue;
986 *elem = elements[i];
987 if (GNUNET_SYSERR ==
990 &elem->key,
991 elem,
993 {
994 /* element with same key encountered twice! */
995 GNUNET_break (0);
996 GNUNET_free (elem);
997 continue;
998 }
999 set_elem.data = &elem->key;
1000 set_elem.size = sizeof(elem->key);
1001 set_elem.element_type = 0;
1003 &set_elem,
1004 NULL,
1005 NULL);
1006 s->used_element_count++;
1007 }
1010 {
1011 /* wait for multipart msg */
1013 "Received partial client request, waiting for more!\n");
1014 return;
1015 }
1017 "Launching computation\n");
1019}
struct GNUNET_CONTAINER_MultiHashMap * GNUNET_CONTAINER_multihashmap_create(unsigned int len, int do_not_copy_keys)
Create a multi hash map.
struct GNUNET_SETI_Handle * GNUNET_SETI_create(const struct GNUNET_CONFIGURATION_Handle *cfg)
Create an empty set, supporting the specified operation.
Definition: seti_api.c:399

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
clsunused
tcunused

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

1030{
1032 "Shutting down, initiating cleanup.\n");
1033 // FIXME: we have to cut our connections to CADET first!
1034 if (NULL != my_cadet)
1035 {
1037 my_cadet = NULL;
1038 }
1039 if (NULL != edc)
1040 {
1042 edc = NULL;
1043 }
1044}
void GNUNET_CADET_disconnect(struct GNUNET_CADET_Handle *handle)
Disconnect from the cadet service.
Definition: cadet_api.c:774
void GNUNET_CRYPTO_ecc_dlog_release(struct GNUNET_CRYPTO_EccDlogContext *dlc)
Release precalculated values.

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
clsclosure, NULL
clientidentification of the client
mqmessage queue to communicate with client
Returns
our struct AliceServiceSession

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

1061{
1062 struct AliceServiceSession *s;
1063
1064 s = GNUNET_new (struct AliceServiceSession);
1065 s->client = client;
1066 s->client_mq = mq;
1067 return s;
1068}
struct GNUNET_MQ_Handle * mq
Definition: 003.c:5

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
clsclosure, NULL
clientidentification of the client
app_clsour struct AliceServiceSession

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

1085{
1086 struct AliceServiceSession *s = app_cls;
1087
1089 "Client %p disconnected from us.\n",
1090 client);
1091 s->client = NULL;
1092 s->client_mq = NULL;
1094}

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
clsclosure
cconfiguration to use
servicethe initialized service

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

1108{
1109 cfg = c;
1111 MAX_RAM);
1112 /* Select a random 'a' value for Alice */
1116 if (NULL == my_cadet)
1117 {
1119 _ ("Connect to CADET failed\n"));
1121 return;
1122 }
1124 NULL);
1125}
#define MAX_RAM
How many values should DLOG store in memory (determines baseline RAM consumption, roughly 100 bytes t...
static void shutdown_task(void *cls)
Task run during shutdown.
#define MAX_RESULT
Maximum allowed result value for the scalarproduct computation.
struct GNUNET_CADET_Handle * GNUNET_CADET_connect(const struct GNUNET_CONFIGURATION_Handle *cfg)
Connect to the MQ-based cadet service.
Definition: cadet_api.c:894
void GNUNET_CRYPTO_ecc_rnd_mpi(struct GNUNET_CRYPTO_EccScalar *r, struct GNUNET_CRYPTO_EccScalar *r_neg)
Obtain a random scalar for point multiplication on the curve and its additive inverse.
struct GNUNET_CRYPTO_EccDlogContext * GNUNET_CRYPTO_ecc_dlog_prepare(unsigned int max, unsigned int mem)
Do pre-calculation for ECC discrete logarithm for small factors.
void GNUNET_SCHEDULER_shutdown(void)
Request the shutdown of a scheduler.
Definition: scheduler.c:567
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_shutdown(GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run on shutdown, that is when a CTRL-C signal is received,...
Definition: scheduler.c:1340
#define _(String)
GNU gettext support macro.
Definition: platform.h:178

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 ( "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 184 of file gnunet-service-scalarproduct-ecc_alice.c.

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

◆ edc

◆ my_privkey

struct GNUNET_CRYPTO_EccScalar my_privkey
static

Alice's private key ('a').

Definition at line 194 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 199 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 204 of file gnunet-service-scalarproduct-ecc_alice.c.

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