GNUnet 0.21.1
gnunet-service-scalarproduct-ecc_bob.c File Reference

scalarproduct service implementation More...

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

Go to the source code of this file.

Data Structures

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

Macros

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

Functions

static int free_element_cb (void *cls, const struct GNUNET_HashCode *key, void *value)
 Callback used to free the elements in the map. More...
 
static void destroy_service_session (struct BobServiceSession *s)
 Destroy session state, we are done with it. More...
 
static void prepare_client_end_notification (struct BobServiceSession *session)
 Notify the client that the session has succeeded or failed. More...
 
static void cb_channel_destruction (void *cls, const struct GNUNET_CADET_Channel *channel)
 Function called whenever a channel is destroyed. More...
 
static void bob_cadet_done_cb (void *cls)
 MQ finished giving our last message to CADET, now notify the client that we are finished. More...
 
static void transmit_bobs_cryptodata_message (struct BobServiceSession *s)
 Bob generates the response message to be sent to Alice. More...
 
static int copy_element_cb (void *cls, const struct GNUNET_HashCode *key, void *value)
 Iterator to copy over messages from the hash map into an array for sorting. More...
 
static int element_cmp (const void *a, const void *b)
 Compare two struct MpiValues by key for sorting. More...
 
static int check_alices_cryptodata_message (void *cls, const struct EccAliceCryptodataMessage *msg)
 Check a multipart-chunk of a request from another service to calculate a scalarproduct with us. More...
 
static void handle_alices_cryptodata_message (void *cls, const struct EccAliceCryptodataMessage *msg)
 Handle a multipart-chunk of a request from another service to calculate a scalarproduct with us. More...
 
static void cb_intersection_element_removed (void *cls, const struct GNUNET_SETI_Element *element, uint64_t current_size, enum GNUNET_SETI_Status status)
 Callback for set operation results. More...
 
static void start_intersection (struct BobServiceSession *s)
 We've paired up a client session with an incoming CADET request. More...
 
static void handle_alices_computation_request (void *cls, const struct EccServiceRequestMessage *msg)
 Handle a request from Alice to calculate a scalarproduct with us (Bob). More...
 
static void * cb_channel_incoming (void *cls, struct GNUNET_CADET_Channel *channel, const struct GNUNET_PeerIdentity *initiator)
 Function called for inbound channels on Bob's end. More...
 
static int check_bob_client_message_multipart (void *cls, const struct ComputationBobCryptodataMultipartMessage *msg)
 We're receiving additional set data. More...
 
static void handle_bob_client_message_multipart (void *cls, const struct ComputationBobCryptodataMultipartMessage *msg)
 We're receiving additional set data. More...
 
static int check_bob_client_message (void *cls, const struct BobComputationMessage *msg)
 Handler for Bob's a client request message. More...
 
static void handle_bob_client_message (void *cls, const struct BobComputationMessage *msg)
 Handler for Bob's a client request message. More...
 
static void shutdown_task (void *cls)
 Task run during shutdown. More...
 
static void * client_connect_cb (void *cls, struct GNUNET_SERVICE_Client *client, struct GNUNET_MQ_Handle *mq)
 A client connected. More...
 
static void client_disconnect_cb (void *cls, struct GNUNET_SERVICE_Client *client, void *app_cls)
 A client disconnected. More...
 
static void run (void *cls, const struct GNUNET_CONFIGURATION_Handle *c, struct GNUNET_SERVICE_Handle *service)
 Initialization of the program and message handlers. More...
 
 GNUNET_SERVICE_MAIN ("scalarproduct-bob", GNUNET_SERVICE_OPTION_NONE, &run, &client_connect_cb, &client_disconnect_cb, NULL, GNUNET_MQ_hd_var_size(bob_client_message, GNUNET_MESSAGE_TYPE_SCALARPRODUCT_CLIENT_TO_BOB, struct BobComputationMessage, NULL), GNUNET_MQ_hd_var_size(bob_client_message_multipart, GNUNET_MESSAGE_TYPE_SCALARPRODUCT_CLIENT_MULTIPART_BOB, struct ComputationBobCryptodataMultipartMessage, NULL), GNUNET_MQ_handler_end())
 Define "main" method using service macro. More...
 

Variables

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

Detailed Description

scalarproduct service implementation

Author
Christian M. Fuchs
Christian Grothoff

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

Macro Definition Documentation

◆ LOG

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

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

Function Documentation

◆ free_element_cb()

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

Callback used to free the elements in the map.

Parameters
clsNULL
keykey of the element
valuethe value to free

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

200{
201 struct GNUNET_SCALARPRODUCT_Element *element = value;
202
203 GNUNET_free (element);
204 return GNUNET_OK;
205}
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 BobServiceSession s)
static

Destroy session state, we are done with it.

Parameters
sthe session to free elements from

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

215{
216 if (GNUNET_YES == s->in_destroy)
217 return;
219 if (NULL != s->client)
220 {
221 struct GNUNET_SERVICE_Client *c = s->client;
222
223 s->client = NULL;
225 }
226 if (NULL != s->intersected_elements)
227 {
230 NULL);
232 s->intersected_elements = NULL;
233 }
234 if (NULL != s->intersection_op)
235 {
237 s->intersection_op = NULL;
238 }
239 if (NULL != s->intersection_set)
240 {
242 s->intersection_set = NULL;
243 }
244 if (NULL != s->sorted_elements)
245 {
247 s->sorted_elements = NULL;
248 }
249 if (NULL != s->port)
250 {
252 s->port = NULL;
253 }
254 if (NULL != s->channel)
255 {
257 s->channel = NULL;
258 }
259 GNUNET_free (s);
260}
static int free_element_cb(void *cls, const struct GNUNET_HashCode *key, void *value)
Callback used to free the elements in the map.
void GNUNET_CADET_channel_destroy(struct GNUNET_CADET_Channel *channel)
Destroy an existing channel.
Definition: cadet_api.c:830
void GNUNET_CADET_close_port(struct GNUNET_CADET_Port *p)
Close a port opened with GNUNET_CADET_open_port.
Definition: cadet_api.c:801
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
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
struct MpiElement * sorted_elements
b(Bob)
struct GNUNET_CADET_Port * port
Our open port.
struct GNUNET_CADET_Channel * channel
The CADET channel.
struct GNUNET_SETI_OperationHandle * intersection_op
Set of elements for which will conduction an intersection.
struct GNUNET_CONTAINER_MultiHashMap * intersected_elements
All non-0-value'd elements transmitted to us.
struct GNUNET_SERVICE_Client * client
The client this request is related to.
struct GNUNET_SETI_Handle * intersection_set
Set of elements for which we will be conducting an intersection.
int in_destroy
Are we already in destroy_service_session()?
Handle to a client that is connected to a service.
Definition: service.c:246

References BobServiceSession::channel, BobServiceSession::client, free_element_cb(), GNUNET_CADET_channel_destroy(), GNUNET_CADET_close_port(), GNUNET_CONTAINER_multihashmap_destroy(), GNUNET_CONTAINER_multihashmap_iterate(), GNUNET_free, GNUNET_SERVICE_client_drop(), GNUNET_SETI_destroy(), GNUNET_SETI_operation_cancel(), GNUNET_YES, BobServiceSession::in_destroy, BobServiceSession::intersected_elements, BobServiceSession::intersection_op, BobServiceSession::intersection_set, BobServiceSession::port, and BobServiceSession::sorted_elements.

Referenced by cb_channel_destruction(), and client_disconnect_cb().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ prepare_client_end_notification()

static void prepare_client_end_notification ( struct BobServiceSession session)
static

Notify the client that the session has succeeded or failed.

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

Parameters
sessionthe associated client session to fail or succeed

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

272{
274 struct GNUNET_MQ_Envelope *e;
275
276 if (NULL == session->client_mq)
277 return; /* no client left to be notified */
279 "Sending session-end notification with status %d to client for session %s\n",
280 session->status,
281 GNUNET_h2s (&session->session_id));
282 e = GNUNET_MQ_msg (msg,
284 msg->range = 0;
285 msg->product_length = htonl (0);
286 msg->status = htonl (session->status);
287 GNUNET_MQ_send (session->client_mq,
288 e);
289}
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).
@ GNUNET_ERROR_TYPE_DEBUG
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
enum GNUNET_SCALARPRODUCT_ResponseStatus status
State of this session.
struct GNUNET_MQ_Handle * client_mq
Client message queue.
Message type passed from service client to finalize a session as requester or responder.

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

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

Here is the call graph for this function:
Here is the caller graph for this function:

◆ cb_channel_destruction()

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

Function called whenever a channel is destroyed.

Should clean up any associated state.

It must NOT call GNUNET_CADET_channel_destroy() on the channel.

Parameters
clsthe struct BobServiceSession
channelconnection to the other end (henceforth invalid)

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

304{
305 struct BobServiceSession *s = cls;
306
308 "Peer disconnected, terminating session %s with peer %s\n",
309 GNUNET_h2s (&s->session_id),
310 GNUNET_i2s (&s->peer));
311 s->channel = NULL;
313 {
316 }
318}
static void prepare_client_end_notification(struct BobServiceSession *session)
Notify the client that the session has succeeded or failed.
static void destroy_service_session(struct BobServiceSession *s)
Destroy session state, we are done with it.
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 an offer for a multiplication service by a local client.
struct GNUNET_CRYPTO_PaillierCiphertext s
Bob's "s".

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

Referenced by handle_bob_client_message().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ bob_cadet_done_cb()

static void bob_cadet_done_cb ( void *  cls)
static

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

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

327{
328 struct BobServiceSession *session = cls;
329
332}
@ GNUNET_SCALARPRODUCT_STATUS_SUCCESS
The computation was successful.

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

Referenced by transmit_bobs_cryptodata_message().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ transmit_bobs_cryptodata_message()

static void transmit_bobs_cryptodata_message ( struct BobServiceSession s)
static

Bob generates the response message to be sent to Alice.

Parameters
sthe associated requesting session with Alice

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

342{
344 struct GNUNET_MQ_Envelope *e;
345
347 "Sending response to Alice\n");
348 e = GNUNET_MQ_msg (msg,
350 msg->contained_element_count = htonl (2);
351 msg->prod_g_i_b_i = s->prod_g_i_b_i;
352 msg->prod_h_i_b_i = s->prod_h_i_b_i;
355 s);
357 e);
358}
static void bob_cadet_done_cb(void *cls)
MQ finished giving our last message to CADET, now notify the client that we are finished.
void GNUNET_MQ_notify_sent(struct GNUNET_MQ_Envelope *ev, GNUNET_SCHEDULER_TaskCallback cb, void *cb_cls)
Call a callback once the envelope has been sent, that is, sending it can not be canceled anymore.
Definition: mq.c:638
#define GNUNET_MESSAGE_TYPE_SCALARPRODUCT_ECC_BOB_CRYPTODATA
Bob -> Alice ECC crypto data.
struct GNUNET_MQ_Handle * cadet_mq
The message queue for this channel.
struct GNUNET_CRYPTO_EccPoint prod_h_i_b_i
Product of the h_i^{b_i}.
struct GNUNET_CRYPTO_EccPoint prod_g_i_b_i
Product of the g_i^{b_i}.
Message type passed from responding service Bob to responding service Alice to complete a request and...

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

Referenced by cb_intersection_element_removed(), and handle_alices_cryptodata_message().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ copy_element_cb()

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

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

Parameters
clsthe struct AliceServiceSession *
keythe key (unused)
valuethe struct GNUNET_SCALARPRODUCT_Element *

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

373{
374 struct BobServiceSession *s = cls;
376
378 e->value);
381 return GNUNET_OK;
382}
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, BobServiceSession::s, BobServiceSession::sorted_elements, BobServiceSession::used_element_count, value, MpiElement::value, and GNUNET_SCALARPRODUCT_Element::value.

Referenced by handle_alices_cryptodata_message().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ element_cmp()

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

Compare two struct MpiValues by key for sorting.

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

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

396{
397 const struct MpiElement *ma = a;
398 const struct MpiElement *mb = b;
399
400 return GNUNET_CRYPTO_hash_cmp (ma->key,
401 mb->key);
402}
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 handle_alices_cryptodata_message().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ check_alices_cryptodata_message()

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

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

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

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

417{
418 struct BobServiceSession *s = cls;
419 uint32_t contained_elements;
420 size_t msg_length;
421 uint16_t msize;
422 unsigned int max;
423
424 msize = ntohs (msg->header.size);
425 if (msize <= sizeof(struct EccAliceCryptodataMessage))
426 {
427 GNUNET_break_op (0);
428 return GNUNET_SYSERR;
429 }
430 contained_elements = ntohl (msg->contained_element_count);
431 /* Our intersection may still be ongoing, but this is nevertheless
432 an upper bound on the required array size */
433 max = GNUNET_CONTAINER_multihashmap_size (s->intersected_elements);
434 msg_length = sizeof(struct EccAliceCryptodataMessage)
435 + contained_elements * sizeof(struct GNUNET_CRYPTO_EccPoint) * 2;
436 if ((msize != msg_length) ||
437 (0 == contained_elements) ||
438 (contained_elements > UINT16_MAX) ||
439 (max < contained_elements + s->cadet_received_element_count))
440 {
441 GNUNET_break_op (0);
442 return GNUNET_SYSERR;
443 }
444 return GNUNET_OK;
445}
unsigned int GNUNET_CONTAINER_multihashmap_size(const struct GNUNET_CONTAINER_MultiHashMap *map)
Get the number of key-value pairs in the map.
uint16_t size
The length of the struct (in bytes, including the length field itself), in big-endian format.
@ GNUNET_SYSERR
#define GNUNET_break_op(cond)
Use this for assertion violations caused by other peers (i.e.
#define max(x, y)
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)...

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

Here is the call graph for this function:

◆ handle_alices_cryptodata_message()

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

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

Parameters
clsclosure (set from GNUNET_CADET_connect)
msgthe actual message

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

458{
459 struct BobServiceSession *s = cls;
460 const struct GNUNET_CRYPTO_EccPoint *payload;
461 uint32_t contained_elements;
462 unsigned int max;
463 const struct GNUNET_CRYPTO_EccPoint *g_i;
464 const struct GNUNET_CRYPTO_EccPoint *h_i;
465 struct GNUNET_CRYPTO_EccPoint g_i_b_i;
466 struct GNUNET_CRYPTO_EccPoint h_i_b_i;
467
468 contained_elements = ntohl (msg->contained_element_count);
470 /* sort our vector for the computation */
471 if (NULL == s->sorted_elements)
472 {
476 struct MpiElement);
477 s->used_element_count = 0;
480 s);
481 qsort (s->sorted_elements,
483 sizeof(struct MpiElement),
484 &element_cmp);
485 }
486
488 "Received %u crypto values from Alice\n",
489 (unsigned int) contained_elements);
490 payload = (const struct GNUNET_CRYPTO_EccPoint *) &msg[1];
491
492 for (unsigned int i = 0; i < contained_elements; i++)
493 {
494 int64_t val = s->sorted_elements[i + s->cadet_received_element_count].value;
495 struct GNUNET_CRYPTO_EccScalar vali;
496
497 GNUNET_assert (INT64_MIN != val);
498 GNUNET_CRYPTO_ecc_scalar_from_int (val > 0 ? val : -val,
499 &vali);
500 if (val < 0)
501 crypto_core_ed25519_scalar_negate (vali.v,
502 vali.v);
503 g_i = &payload[i * 2];
504 /* g_i_b_i = g_i^vali */
507 &vali,
508 &g_i_b_i));
509 h_i = &payload[i * 2 + 1];
510 /* h_i_b_i = h_i^vali */
513 &vali,
514 &h_i_b_i));
515 if (0 == i + s->cadet_received_element_count)
516 {
517 /* first iteration, nothing to add */
518 s->prod_g_i_b_i = g_i_b_i;
519 s->prod_h_i_b_i = h_i_b_i;
520 }
521 else
522 {
523 /* further iterations, cummulate resulting value */
526 &g_i_b_i,
527 &s->prod_g_i_b_i));
530 &h_i_b_i,
531 &s->prod_h_i_b_i));
532 }
533 }
534 s->cadet_received_element_count += contained_elements;
535 if ((s->cadet_received_element_count == max) &&
536 (NULL == s->intersection_op))
537 {
538 /* intersection has finished also on our side, and
539 we got the full set, so we can proceed with the
540 CADET response(s) */
542 }
544}
static unsigned long long payload
How much data are we currently storing in the database?
static void transmit_bobs_cryptodata_message(struct BobServiceSession *s)
Bob generates the response message to be sent to Alice.
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.
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.
void GNUNET_CRYPTO_ecc_scalar_from_int(int64_t val, struct GNUNET_CRYPTO_EccScalar *r)
Create a scalar from int value.
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_assert(cond)
Use this for fatal errors that cannot be handled.
#define GNUNET_new_array(n, type)
Allocate a size n array with structs or unions of the given type.
uint32_t cadet_received_element_count
Counts the number of values received from Alice by us.
A ECC scalar for use in point multiplications.

References BobServiceSession::cadet_received_element_count, BobServiceSession::channel, copy_element_cb(), element_cmp(), GNUNET_assert, GNUNET_CADET_receive_done(), GNUNET_CONTAINER_multihashmap_iterate(), GNUNET_CONTAINER_multihashmap_size(), GNUNET_CRYPTO_ecc_add(), GNUNET_CRYPTO_ecc_pmul_mpi(), GNUNET_CRYPTO_ecc_scalar_from_int(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_new_array, GNUNET_OK, BobServiceSession::intersected_elements, BobServiceSession::intersection_op, max, msg, payload, BobServiceSession::prod_g_i_b_i, BobServiceSession::prod_h_i_b_i, BobServiceSession::s, BobServiceSession::sorted_elements, transmit_bobs_cryptodata_message(), BobServiceSession::used_element_count, GNUNET_CRYPTO_EccScalar::v, and MpiElement::value.

Here is the call graph for this function:

◆ cb_intersection_element_removed()

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

Callback for set operation results.

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

Parameters
clsclosure with the struct BobServiceSession
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 557 of file gnunet-service-scalarproduct-ecc_bob.c.

561{
562 struct BobServiceSession *s = cls;
564
565 switch (status)
566 {
568 /* this element has been removed from the set */
570 element->data);
571 GNUNET_assert (NULL != se);
573 "Removed element with key %s and value %lld\n",
574 GNUNET_h2s (&se->key),
575 (long long) GNUNET_ntohll (se->value));
579 element->data,
580 se));
581 GNUNET_free (se);
582 return;
584 s->intersection_op = NULL;
585 GNUNET_break (NULL == s->intersection_set);
588 "Finished intersection, %d items remain\n",
592 {
593 /* CADET transmission from Alice is also already done,
594 start with our own reply */
596 }
597 return;
599 /* unhandled status code */
601 "Set intersection failed!\n");
602 s->intersection_op = NULL;
603 if (NULL != s->intersection_set)
604 {
606 s->intersection_set = NULL;
607 }
610 return;
611
612 default:
613 GNUNET_break (0);
614 return;
615 }
616}
static int status
The program status; 0 for success.
Definition: gnunet-nse.c:39
#define LOG(kind,...)
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.
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur.
@ 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.
uint32_t client_received_element_count
Already transferred elements (received) for multipart messages from client.
const void * data
Actual data of the element.

References BobServiceSession::channel, BobServiceSession::client_received_element_count, GNUNET_SETI_Element::data, GNUNET_assert, GNUNET_break, GNUNET_CADET_receive_done(), GNUNET_CONTAINER_multihashmap_get(), GNUNET_CONTAINER_multihashmap_remove(), GNUNET_CONTAINER_multihashmap_size(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_h2s(), GNUNET_ntohll(), GNUNET_SCALARPRODUCT_STATUS_FAILURE, GNUNET_SETI_destroy(), GNUNET_SETI_STATUS_DEL_LOCAL, GNUNET_SETI_STATUS_DONE, GNUNET_SETI_STATUS_FAILURE, GNUNET_YES, BobServiceSession::intersected_elements, BobServiceSession::intersection_op, BobServiceSession::intersection_set, GNUNET_SCALARPRODUCT_Element::key, LOG, prepare_client_end_notification(), BobServiceSession::s, status, BobServiceSession::status, transmit_bobs_cryptodata_message(), and GNUNET_SCALARPRODUCT_Element::value.

Here is the call graph for this function:

◆ start_intersection()

static void start_intersection ( struct BobServiceSession s)
static

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

Initiate set intersection work.

Parameters
sclient session to start intersection for

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

627{
628 struct GNUNET_HashCode set_sid;
629
631 sizeof(struct GNUNET_HashCode),
632 &set_sid);
634 "Got session with key %s and %u elements, starting intersection.\n",
636 (unsigned int) s->total);
637
640 &set_sid,
641 NULL,
642 (struct GNUNET_SETI_Option[]) { { 0 } },
644 s);
645 if (GNUNET_OK !=
648 {
649 GNUNET_break (0);
652 return;
653 }
655 s->intersection_set = NULL;
656}
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.
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
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
struct GNUNET_SETI_OperationHandle * GNUNET_SETI_prepare(const struct GNUNET_PeerIdentity *other_peer, const struct GNUNET_HashCode *app_id, const struct GNUNET_MessageHeader *context_msg, const struct GNUNET_SETI_Option options[], GNUNET_SETI_ResultIterator result_cb, void *result_cls)
Prepare a set operation to be evaluated with another peer.
Definition: seti_api.c:513
uint32_t total
How many elements will be supplied in total from the client.
struct GNUNET_PeerIdentity peer
Originator's peer identity.
A 512-bit hashcode.
Option for set operations.

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

Referenced by handle_alices_computation_request(), and handle_bob_client_message_multipart().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ handle_alices_computation_request()

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

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

Parameters
clsclosure (set from GNUNET_CADET_connect)
msgthe actual message

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

668{
669 struct BobServiceSession *s = cls;
670
671 s->session_id = msg->session_id; // ??
672 if (s->client_received_element_count < s->total)
673 {
675 "Alice ready, still waiting for Bob client data!\n");
676 return;
677 }
679 "Both ready, launching intersection!\n");
681}
static void start_intersection(struct BobServiceSession *s)
We've paired up a client session with an incoming CADET request.

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

Here is the call graph for this function:

◆ cb_channel_incoming()

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

Function called for inbound channels on Bob's end.

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

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

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

698{
699 struct BobServiceSession *s = cls;
700
702 "New incoming channel from peer %s.\n",
703 GNUNET_i2s (initiator));
705 s->port = NULL;
706 s->peer = *initiator;
707 s->channel = channel;
708 s->cadet_mq = GNUNET_CADET_get_mq (s->channel);
709 return s;
710}
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

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

Referenced by handle_bob_client_message().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ check_bob_client_message_multipart()

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

We're receiving additional set data.

Check it is well-formed.

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

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

724{
725 struct BobServiceSession *s = cls;
726 uint32_t contained_count;
727 uint16_t msize;
728
729 msize = ntohs (msg->header.size);
730 contained_count = ntohl (msg->element_count_contained);
731 if ((msize != (sizeof(struct ComputationBobCryptodataMultipartMessage)
732 + contained_count * sizeof(struct
734 (0 == contained_count) ||
735 (UINT16_MAX < contained_count) ||
736 (s->total == s->client_received_element_count) ||
737 (s->total < s->client_received_element_count + contained_count))
738 {
739 GNUNET_break (0);
740 return GNUNET_SYSERR;
741 }
742 return GNUNET_OK;
743}
multipart messages following struct ComputationMessage

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

◆ handle_bob_client_message_multipart()

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

We're receiving additional set data.

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

Parameters
clsidentification of the client
msgthe actual message

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

757{
758 struct BobServiceSession *s = cls;
759 uint32_t contained_count;
760 const struct GNUNET_SCALARPRODUCT_Element *elements;
761 struct GNUNET_SETI_Element set_elem;
762 struct GNUNET_SCALARPRODUCT_Element *elem;
763
764 contained_count = ntohl (msg->element_count_contained);
765 elements = (const struct GNUNET_SCALARPRODUCT_Element *) &msg[1];
766 for (uint32_t i = 0; i < contained_count; i++)
767 {
769 GNUNET_memcpy (elem,
770 &elements[i],
771 sizeof(struct GNUNET_SCALARPRODUCT_Element));
772 if (GNUNET_SYSERR ==
774 &elem->key,
775 elem,
777 {
778 GNUNET_break (0);
779 GNUNET_free (elem);
780 continue;
781 }
782 set_elem.data = &elem->key;
783 set_elem.size = sizeof(elem->key);
784 set_elem.element_type = 0;
786 &set_elem,
787 NULL, NULL);
788 }
789 s->client_received_element_count += contained_count;
792 {
793 /* more to come */
795 "Request still partial, waiting for more client data!\n");
796 return;
797 }
798 if (NULL == s->channel)
799 {
800 /* no Alice waiting for this request, wait for Alice */
802 "Client ready, still waiting for Alice!\n");
803 return;
804 }
806 "Both ready, launching intersection!\n");
808}
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_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
#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
Element stored in a set.

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

Here is the call graph for this function:

◆ check_bob_client_message()

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

Handler for Bob's a client request message.

Check msg is well-formed.

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

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

822{
823 struct BobServiceSession *s = cls;
824 uint32_t contained_count;
825 uint32_t total_count;
826 uint16_t msize;
827
828 if (GNUNET_SCALARPRODUCT_STATUS_INIT != s->status)
829 {
830 GNUNET_break (0);
831 return GNUNET_SYSERR;
832 }
833 msize = ntohs (msg->header.size);
834 total_count = ntohl (msg->element_count_total);
835 contained_count = ntohl (msg->element_count_contained);
836 if ((0 == total_count) ||
837 (0 == contained_count) ||
838 (UINT16_MAX < contained_count) ||
839 (msize != (sizeof(struct BobComputationMessage)
840 + contained_count * sizeof(struct
842 {
843 GNUNET_break_op (0);
844 return GNUNET_SYSERR;
845 }
846 return GNUNET_OK;
847}
@ GNUNET_SCALARPRODUCT_STATUS_INIT
Operation is still active (never returned, used internally).
Message type passed from client to service to initiate a request or responder role.
Definition: scalarproduct.h:89

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

◆ handle_bob_client_message()

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

Handler for Bob's a client request message.

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

Parameters
clsidentification of the client
msgthe actual message

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

861{
862 struct BobServiceSession *s = cls;
863 struct GNUNET_MQ_MessageHandler cadet_handlers[] = {
864 GNUNET_MQ_hd_fixed_size (alices_computation_request,
867 s),
868 GNUNET_MQ_hd_var_size (alices_cryptodata_message,
871 s),
873 };
874 uint32_t contained_count;
875 uint32_t total_count;
876 const struct GNUNET_SCALARPRODUCT_Element *elements;
877 struct GNUNET_SETI_Element set_elem;
878 struct GNUNET_SCALARPRODUCT_Element *elem;
879
880 total_count = ntohl (msg->element_count_total);
881 contained_count = ntohl (msg->element_count_contained);
882
884 s->total = total_count;
885 s->client_received_element_count = contained_count;
886 s->session_id = msg->session_key;
887 elements = (const struct GNUNET_SCALARPRODUCT_Element *) &msg[1];
890 GNUNET_YES);
892 for (uint32_t i = 0; i < contained_count; i++)
893 {
894 if (0 == GNUNET_ntohll (elements[i].value))
895 continue;
897 GNUNET_memcpy (elem,
898 &elements[i],
899 sizeof(struct GNUNET_SCALARPRODUCT_Element));
900 if (GNUNET_SYSERR ==
902 &elem->key,
903 elem,
905 {
906 GNUNET_break (0);
907 GNUNET_free (elem);
908 continue;
909 }
910 set_elem.data = &elem->key;
911 set_elem.size = sizeof(elem->key);
912 set_elem.element_type = 0;
914 &set_elem,
915 NULL, NULL);
917 }
920 "Received client request, opening port %s!\n",
921 GNUNET_h2s (&msg->session_key));
923 &msg->session_key,
925 s,
926 NULL,
928 cadet_handlers);
929 if (NULL == s->port)
930 {
931 GNUNET_break (0);
933 return;
934 }
935}
static void * cb_channel_incoming(void *cls, struct GNUNET_CADET_Channel *channel, const struct GNUNET_PeerIdentity *initiator)
Function called for inbound channels on Bob's end.
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_CADET_Port * GNUNET_CADET_open_port(struct GNUNET_CADET_Handle *h, const struct GNUNET_HashCode *port, GNUNET_CADET_ConnectEventHandler connects, void *connects_cls, GNUNET_CADET_WindowSizeEventHandler window_changes, GNUNET_CADET_DisconnectEventHandler disconnects, const struct GNUNET_MQ_MessageHandler *handlers)
Open a port to receive incoming MQ-based channels.
Definition: cadet_api.c:954
struct GNUNET_CONTAINER_MultiHashMap * GNUNET_CONTAINER_multihashmap_create(unsigned int len, int do_not_copy_keys)
Create a multi hash map.
#define GNUNET_MQ_handler_end()
End-marker for the handlers array.
#define GNUNET_MQ_hd_var_size(name, code, str, ctx)
#define GNUNET_MQ_hd_fixed_size(name, code, str, ctx)
#define GNUNET_MESSAGE_TYPE_SCALARPRODUCT_ECC_SESSION_INITIALIZATION
Alice -> Bob ECC session initialization.
#define GNUNET_MESSAGE_TYPE_SCALARPRODUCT_ECC_ALICE_CRYPTODATA
Alice -> Bob ECC crypto data.
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
Message type passed from requesting service Alice to responding service Bob to initiate a request and...
Message handler for a specific message type.

References cb_channel_destruction(), cb_channel_incoming(), cfg, BobServiceSession::client, BobServiceSession::client_received_element_count, GNUNET_SETI_Element::data, GNUNET_SETI_Element::element_type, GNUNET_break, GNUNET_CADET_open_port(), GNUNET_CONTAINER_multihashmap_create(), GNUNET_CONTAINER_multihashmap_put(), GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_h2s(), GNUNET_log, GNUNET_memcpy, GNUNET_MESSAGE_TYPE_SCALARPRODUCT_ECC_ALICE_CRYPTODATA, GNUNET_MESSAGE_TYPE_SCALARPRODUCT_ECC_SESSION_INITIALIZATION, GNUNET_MQ_handler_end, GNUNET_MQ_hd_fixed_size, GNUNET_MQ_hd_var_size, GNUNET_new, GNUNET_ntohll(), GNUNET_SCALARPRODUCT_STATUS_ACTIVE, GNUNET_SERVICE_client_continue(), GNUNET_SERVICE_client_drop(), GNUNET_SETI_add_element(), GNUNET_SETI_create(), GNUNET_SYSERR, GNUNET_YES, BobServiceSession::intersected_elements, BobServiceSession::intersection_set, GNUNET_SCALARPRODUCT_Element::key, msg, my_cadet, BobServiceSession::port, BobServiceSession::s, BobServiceSession::session_id, GNUNET_SETI_Element::size, BobServiceSession::status, BobServiceSession::total, BobServiceSession::used_element_count, and value.

Here is the call graph for this function:

◆ shutdown_task()

static void shutdown_task ( void *  cls)
static

Task run during shutdown.

Parameters
clsunused

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

945{
947 "Shutting down, initiating cleanup.\n");
948 // FIXME: we have to cut our connections to CADET first!
949 if (NULL != my_cadet)
950 {
952 my_cadet = NULL;
953 }
954 if (NULL != edc)
955 {
957 edc = NULL;
958 }
959}
static struct GNUNET_CRYPTO_EccDlogContext * edc
Context for DLOG operations on a curve.
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 BobServiceSession

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

976{
977 struct BobServiceSession *s;
978
979 s = GNUNET_new (struct BobServiceSession);
980 s->client = client;
981 s->client_mq = mq;
982 return s;
983}
struct GNUNET_MQ_Handle * mq
Definition: 003.c:5

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

◆ client_disconnect_cb()

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

A client disconnected.

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

Parameters
clsclosure, NULL
clientidentification of the client
app_clsour struct BobServiceSession

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

1000{
1001 struct BobServiceSession *s = app_cls;
1002
1004 "Client disconnected from us.\n");
1005 s->client = NULL;
1007}

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

Here is the call graph for this function:

◆ run()

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

Initialization of the program and message handlers.

Parameters
clsclosure
cconfiguration to use
servicethe initialized service

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

1021{
1022 cfg = c;
1023 /* We don't really do DLOG, so we can setup with very minimal resources */
1024 edc = GNUNET_CRYPTO_ecc_dlog_prepare (4 /* max value */,
1025 2 /* RAM */);
1028 NULL);
1029 if (NULL == my_cadet)
1030 {
1032 _ ("Connect to CADET failed\n"));
1034 return;
1035 }
1036}
static void shutdown_task(void *cls)
Task run during shutdown.
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
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.
@ GNUNET_ERROR_TYPE_ERROR
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_ERROR_TYPE_ERROR, GNUNET_log, GNUNET_SCHEDULER_add_shutdown(), GNUNET_SCHEDULER_shutdown(), my_cadet, and shutdown_task().

Here is the call graph for this function:

◆ GNUNET_SERVICE_MAIN()

GNUNET_SERVICE_MAIN ( "scalarproduct-bob"  ,
GNUNET_SERVICE_OPTION_NONE  ,
run,
client_connect_cb,
client_disconnect_cb,
NULL  ,
GNUNET_MQ_hd_var_size(bob_client_message, GNUNET_MESSAGE_TYPE_SCALARPRODUCT_CLIENT_TO_BOB, struct BobComputationMessage, NULL)  ,
GNUNET_MQ_hd_var_size(bob_client_message_multipart, GNUNET_MESSAGE_TYPE_SCALARPRODUCT_CLIENT_MULTIPART_BOB, struct ComputationBobCryptodataMultipartMessage, NULL)  ,
GNUNET_MQ_handler_end()   
)

Define "main" method using service macro.

Variable Documentation

◆ cfg

const struct GNUNET_CONFIGURATION_Handle* cfg
static

GNUnet configuration handle.

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

Referenced by handle_bob_client_message(), and run().

◆ my_cadet

struct GNUNET_CADET_Handle* my_cadet
static

Handle to the CADET service.

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

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

◆ edc

struct GNUNET_CRYPTO_EccDlogContext* edc
static

Context for DLOG operations on a curve.

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

Referenced by run(), and shutdown_task().